Remove phys_addr_range, just use addr_range for both virtual and physical address ranges (as requested by Ingo).

headers/private/kernel/boot/addr_range.h

@@ -16,12 +16,6 @@ typedef struct addr_range {
 } _PACKED addr_range;
 
 
-typedef struct phys_addr_range {
-	phys_addr_t	start;
-	phys_size_t	size;
-} _PACKED phys_addr_range;
-
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -36,18 +30,8 @@ bool is_address_range_covered(addr_range* ranges, uint32 numRanges, uint64 base,
 	uint64 size);
 void sort_address_ranges(addr_range* ranges, uint32 numRanges);
 
-status_t insert_physical_address_range(phys_addr_range* ranges,
+status_t insert_physical_memory_range(uint64 start, uint64 size);
-	uint32* _numRanges, uint32 maxRanges, phys_addr_t start, phys_size_t size);
+status_t insert_physical_allocated_range(uint64 start, uint64 size);
-status_t remove_physical_address_range(phys_addr_range* ranges,
-	uint32* _numRanges, uint32 maxRanges, phys_addr_t start, phys_size_t size);
-bool get_free_physical_address_range(phys_addr_range* ranges, uint32 numRanges,
-	phys_addr_t base, phys_size_t size, phys_addr_t* _rangeBase);
-bool is_physical_address_range_covered(phys_addr_range* ranges,
-	uint32 numRanges, phys_addr_t base, phys_size_t size);
-void sort_physical_address_ranges(phys_addr_range* ranges, uint32 numRanges);
-
-status_t insert_physical_memory_range(phys_addr_t start, phys_size_t size);
-status_t insert_physical_allocated_range(phys_addr_t start, phys_size_t size);
 status_t insert_virtual_allocated_range(uint64 start, uint64 size);
 void ignore_physical_memory_ranges_beyond_4gb();
 

headers/private/kernel/boot/kernel_args.h

@@ -48,9 +48,9 @@ typedef struct kernel_args {
 	FixedWidthPointer<struct preloaded_image> preloaded_images;
 
 	uint32		num_physical_memory_ranges;
-	phys_addr_range	physical_memory_range[MAX_PHYSICAL_MEMORY_RANGE];
+	addr_range	physical_memory_range[MAX_PHYSICAL_MEMORY_RANGE];
 	uint32		num_physical_allocated_ranges;
-	phys_addr_range	physical_allocated_range[MAX_PHYSICAL_ALLOCATED_RANGE];
+	addr_range	physical_allocated_range[MAX_PHYSICAL_ALLOCATED_RANGE];
 	uint32		num_virtual_allocated_ranges;
 	addr_range	virtual_allocated_range[MAX_VIRTUAL_ALLOCATED_RANGE];
 	uint32		num_kernel_args_ranges;
@@ -67,7 +67,7 @@ typedef struct kernel_args {
 	FixedWidthPointer<struct driver_settings_file> driver_settings;
 
 	struct {
-		phys_addr_range	physical_buffer;
+		addr_range	physical_buffer;
 		uint32	bytes_per_row;
 		uint16	width;
 		uint16	height;

src/system/boot/arch/m68k/mmu.cpp

@@ -503,9 +503,9 @@ mmu_init_for_kernel(void)
 	gKernelArgs.num_virtual_allocated_ranges = 1;
 
 	// sort the address ranges
-	sort_physical_address_ranges(gKernelArgs.physical_memory_range,
+	sort_address_ranges(gKernelArgs.physical_memory_range,
 		gKernelArgs.num_physical_memory_ranges);
-	sort_physical_address_ranges(gKernelArgs.physical_allocated_range,
+	sort_address_ranges(gKernelArgs.physical_allocated_range,
 		gKernelArgs.num_physical_allocated_ranges);
 	sort_address_ranges(gKernelArgs.virtual_allocated_range,
 		gKernelArgs.num_virtual_allocated_ranges);
@@ -516,17 +516,23 @@ mmu_init_for_kernel(void)
 
 		dprintf("phys memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
-			dprintf("    base 0x%08lx, length 0x%08lx\n", gKernelArgs.physical_memory_range[i].start, gKernelArgs.physical_memory_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.physical_memory_range[i].start,
+				gKernelArgs.physical_memory_range[i].size);
 		}
 
 		dprintf("allocated phys memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_physical_allocated_ranges; i++) {
-			dprintf("    base 0x%08lx, length 0x%08lx\n", gKernelArgs.physical_allocated_range[i].start, gKernelArgs.physical_allocated_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.physical_allocated_range[i].start,
+				gKernelArgs.physical_allocated_range[i].size);
 		}
 
 		dprintf("allocated virt memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_virtual_allocated_ranges; i++) {
-			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n", gKernelArgs.virtual_allocated_range[i].start, gKernelArgs.virtual_allocated_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.virtual_allocated_range[i].start,
+				gKernelArgs.virtual_allocated_range[i].size);
 		}
 	}
 #endif

src/system/boot/loader/kernel_args.cpp

@@ -26,9 +26,20 @@ static void* sLast;
 static size_t sFree = kChunkSize;
 
 
-template<typename RangeType>
+static status_t
+add_kernel_args_range(void* start, size_t size)
+{
+	return insert_address_range(gKernelArgs.kernel_args_range,
+		&gKernelArgs.num_kernel_args_ranges, MAX_KERNEL_ARGS_RANGE,
+		(addr_t)start, size);
+}
+
+
+// #pragma mark - addr_range utility functions
+
+
 static void
-remove_range_index(RangeType* ranges, uint32& numRanges, uint32 index)
+remove_range_index(addr_range* ranges, uint32& numRanges, uint32 index)
 {
 	if (index + 1 == numRanges) {
 		// remove last range
@@ -37,25 +48,31 @@ remove_range_index(RangeType* ranges, uint32& numRanges, uint32 index)
 	}
 
 	memmove(&ranges[index], &ranges[index + 1],
-		sizeof(RangeType) * (numRanges - 1 - index));
+		sizeof(addr_range) * (numRanges - 1 - index));
 	numRanges--;
 }
 
 
-template<typename RangeType, typename AddressType, typename SizeType>
+/*!	Inserts the specified (start, size) pair (aka range) in the
-static status_t
+	addr_range array.
-insert_range(RangeType* ranges, uint32* _numRanges, uint32 maxRanges,
+	It will extend existing ranges in order to have as little
-	AddressType start, SizeType size)
+	ranges in the array as possible.
+	Returns B_OK on success, or B_ENTRY_NOT_FOUND if there was
+	no free array entry available anymore.
+*/
+extern "C" status_t
+insert_address_range(addr_range* ranges, uint32* _numRanges, uint32 maxRanges,
+	uint64 start, uint64 size)
 {
 	uint32 numRanges = *_numRanges;
 
 	start = ROUNDDOWN(start, B_PAGE_SIZE);
 	size = ROUNDUP(size, B_PAGE_SIZE);
-	AddressType end = start + size;
+	uint64 end = start + size;
 
 	for (uint32 i = 0; i < numRanges; i++) {
-		AddressType rangeStart = ranges[i].start;
+		uint64 rangeStart = ranges[i].start;
-		AddressType rangeEnd = rangeStart + ranges[i].size;
+		uint64 rangeEnd = rangeStart + ranges[i].size;
 
 		if (end < rangeStart || start > rangeEnd) {
 			// ranges don't intersect or touch each other
@@ -84,8 +101,8 @@ insert_range(RangeType* ranges, uint32* _numRanges, uint32 maxRanges,
 
 			rangeStart = ranges[i].start;
 			rangeEnd = rangeStart + ranges[i].size;
-			AddressType joinStart = ranges[j].start;
+			uint64 joinStart = ranges[j].start;
-			AddressType joinEnd = joinStart + ranges[j].size;
+			uint64 joinEnd = joinStart + ranges[j].size;
 
 			if (rangeStart <= joinEnd && joinEnd <= rangeEnd) {
 				// join range that used to be before the current one, or
@@ -113,7 +130,7 @@ insert_range(RangeType* ranges, uint32* _numRanges, uint32 maxRanges,
 	if (numRanges >= maxRanges)
 		return B_ENTRY_NOT_FOUND;
 
-	ranges[numRanges].start = (AddressType)start;
+	ranges[numRanges].start = (uint64)start;
 	ranges[numRanges].size = size;
 	(*_numRanges)++;
 
@@ -121,19 +138,18 @@ insert_range(RangeType* ranges, uint32* _numRanges, uint32 maxRanges,
 }
 
 
-template<typename RangeType, typename AddressType, typename SizeType>
+extern "C" status_t
-static status_t
+remove_address_range(addr_range* ranges, uint32* _numRanges, uint32 maxRanges,
-remove_range(RangeType* ranges, uint32* _numRanges, uint32 maxRanges,
+	uint64 start, uint64 size)
-	AddressType start, SizeType size)
 {
 	uint32 numRanges = *_numRanges;
 
-	AddressType end = ROUNDUP(start + size, B_PAGE_SIZE);
+	uint64 end = ROUNDUP(start + size, B_PAGE_SIZE);
 	start = ROUNDDOWN(start, B_PAGE_SIZE);
 
 	for (uint32 i = 0; i < numRanges; i++) {
-		AddressType rangeStart = ranges[i].start;
+		uint64 rangeStart = ranges[i].start;
-		AddressType rangeEnd = rangeStart + ranges[i].size;
+		uint64 rangeEnd = rangeStart + ranges[i].size;
 
 		if (start <= rangeStart) {
 			if (end <= rangeStart) {
@@ -158,8 +174,8 @@ remove_range(RangeType* ranges, uint32* _numRanges, uint32 maxRanges,
 			// the range. We keep the head of the range and insert its tail
 			// as a new range.
 			ranges[i].size = start - rangeStart;
-			return insert_range<RangeType, AddressType, SizeType>(ranges,
+			return insert_address_range(ranges, _numRanges, maxRanges, end,
-				_numRanges, maxRanges, end, rangeEnd - end);
+				rangeEnd - end);
 		}
 	}
 
@@ -168,12 +184,11 @@ remove_range(RangeType* ranges, uint32* _numRanges, uint32 maxRanges,
 }
 
 
-template<typename RangeType, typename AddressType, typename SizeType>
+bool
-static bool
+get_free_address_range(addr_range* ranges, uint32 numRanges, uint64 base,
-get_free_range(RangeType* ranges, uint32 numRanges, AddressType base,
+	uint64 size, uint64* _rangeBase)
-	SizeType size, AddressType* _rangeBase)
 {
-	AddressType end = base + size - 1;
+	uint64 end = base + size - 1;
 	if (end < base)
 		return false;
 
@@ -182,8 +197,8 @@ get_free_range(RangeType* ranges, uint32 numRanges, AddressType base,
 	// intersects with an existing one.
 
 	for (uint32 i = 0; i < numRanges;) {
-		AddressType rangeStart = ranges[i].start;
+		uint64 rangeStart = ranges[i].start;
-		AddressType rangeEnd = ranges[i].start + ranges[i].size - 1;
+		uint64 rangeEnd = ranges[i].start + ranges[i].size - 1;
 
 		if (base <= rangeEnd && rangeStart <= end) {
 			base = rangeEnd + 1;
@@ -203,21 +218,20 @@ get_free_range(RangeType* ranges, uint32 numRanges, AddressType base,
 }
 
 
-template<typename RangeType, typename AddressType, typename SizeType>
+bool
-static bool
+is_address_range_covered(addr_range* ranges, uint32 numRanges, uint64 base,
-is_range_covered(RangeType* ranges, uint32 numRanges, AddressType base,
+	uint64 size)
-	SizeType size)
 {
 	// Note: We don't assume that the ranges are sorted, so we can't do this
 	// in a simple loop. Instead we restart the loop whenever the start of the
 	// given range intersects with an existing one.
 
 	for (uint32 i = 0; i < numRanges;) {
-		AddressType rangeStart = ranges[i].start;
+		uint64 rangeStart = ranges[i].start;
-		AddressType rangeSize = ranges[i].size;
+		uint64 rangeSize = ranges[i].size;
 
 		if (rangeStart <= base && rangeSize > base - rangeStart) {
-			SizeType intersect = std::min(rangeStart + rangeSize - base, size);
+			uint64 intersect = std::min(rangeStart + rangeSize - base, size);
 			base += intersect;
 			size -= intersect;
 			if (size == 0)
@@ -234,155 +248,43 @@ is_range_covered(RangeType* ranges, uint32 numRanges, AddressType base,
 }
 
 
-template<typename RangeType>
+void
-static void
+sort_address_ranges(addr_range* ranges, uint32 numRanges)
-sort_ranges(RangeType* ranges, uint32 count)
 {
 	// TODO: This is a pretty sucky bubble sort implementation!
 	bool done;
 
 	do {
 		done = true;
-		for (uint32 i = 1; i < count; i++) {
+		for (uint32 i = 1; i < numRanges; i++) {
 			if (ranges[i].start < ranges[i - 1].start) {
 				done = false;
-				RangeType tempRange;
+				addr_range tempRange;
-				memcpy(&tempRange, &ranges[i], sizeof(RangeType));
+				memcpy(&tempRange, &ranges[i], sizeof(addr_range));
-				memcpy(&ranges[i], &ranges[i - 1], sizeof(RangeType));
+				memcpy(&ranges[i], &ranges[i - 1], sizeof(addr_range));
-				memcpy(&ranges[i - 1], &tempRange, sizeof(RangeType));
+				memcpy(&ranges[i - 1], &tempRange, sizeof(addr_range));
 			}
 		}
 	} while (!done);
 }
 
 
-// #pragma mark -
-
-
-static status_t
-add_kernel_args_range(void* start, size_t size)
-{
-	return insert_address_range(gKernelArgs.kernel_args_range,
-		&gKernelArgs.num_kernel_args_ranges, MAX_KERNEL_ARGS_RANGE,
-		(addr_t)start, size);
-}
-
-
-// #pragma mark - addr_range utility functions
-
-
-/*!	Inserts the specified (start, size) pair (aka range) in the
-	addr_range array.
-	It will extend existing ranges in order to have as little
-	ranges in the array as possible.
-	Returns B_OK on success, or B_ENTRY_NOT_FOUND if there was
-	no free array entry available anymore.
-*/
-extern "C" status_t
-insert_address_range(addr_range* ranges, uint32* _numRanges, uint32 maxRanges,
-	uint64 start, uint64 size)
-{
-	return insert_range<addr_range, uint64, uint64>(ranges, _numRanges,
-		maxRanges, start, size);
-}
-
-
-extern "C" status_t
-remove_address_range(addr_range* ranges, uint32* _numRanges, uint32 maxRanges,
-	uint64 start, uint64 size)
-{
-	return remove_range<addr_range, uint64, uint64>(ranges, _numRanges,
-		maxRanges, start, size);
-}
-
-
-bool
-get_free_address_range(addr_range* ranges, uint32 numRanges, uint64 base,
-	uint64 size, uint64* _rangeBase)
-{
-	return get_free_range<addr_range, uint64, uint64>(ranges, numRanges, base,
-		size, _rangeBase);
-}
-
-
-bool
-is_address_range_covered(addr_range* ranges, uint32 numRanges, uint64 base,
-	uint64 size)
-{
-	return is_range_covered<addr_range, uint64, uint64>(ranges, numRanges, base,
-		size);
-}
-
-
-void
-sort_address_ranges(addr_range* ranges, uint32 numRanges)
-{
-	sort_ranges(ranges, numRanges);
-}
-
-
-// #pragma mark - phys_addr_range utility functions
-
-
-status_t
-insert_physical_address_range(phys_addr_range* ranges, uint32* _numRanges,
-	uint32 maxRanges, phys_addr_t start, phys_size_t size)
-{
-	return insert_range<phys_addr_range, phys_addr_t, phys_size_t>(ranges,
-		_numRanges, maxRanges, start, size);
-}
-
-
-status_t
-remove_physical_address_range(phys_addr_range* ranges, uint32* _numRanges,
-	uint32 maxRanges, phys_addr_t start, phys_size_t size)
-{
-	return remove_range<phys_addr_range, phys_addr_t, phys_size_t>(ranges,
-		_numRanges, maxRanges, start, size);
-}
-
-
-bool
-get_free_physical_address_range(phys_addr_range* ranges, uint32 numRanges,
-	phys_addr_t base, phys_size_t size, phys_addr_t* _rangeBase)
-{
-	return get_free_range<phys_addr_range, phys_addr_t, phys_size_t>(ranges,
-		numRanges, base, size, _rangeBase);
-}
-
-
-bool
-is_physical_address_range_covered(phys_addr_range* ranges, uint32 numRanges,
-	phys_addr_t base, phys_size_t size)
-{
-	return is_range_covered<phys_addr_range, phys_addr_t, phys_size_t>(ranges,
-		numRanges, base, size);
-}
-
-
-void
-sort_physical_address_ranges(phys_addr_range* ranges, uint32 numRanges)
-{
-	sort_ranges(ranges, numRanges);
-}
-
-
 // #pragma mark - kernel args range functions
 
 
 status_t
-insert_physical_memory_range(phys_addr_t start, phys_size_t size)
+insert_physical_memory_range(uint64 start, uint64 size)
 {
-	return insert_physical_address_range(gKernelArgs.physical_memory_range,
+	return insert_address_range(gKernelArgs.physical_memory_range,
 		&gKernelArgs.num_physical_memory_ranges, MAX_PHYSICAL_MEMORY_RANGE,
 		start, size);
 }
 
 
 status_t
-insert_physical_allocated_range(phys_addr_t start, phys_size_t size)
+insert_physical_allocated_range(uint64 start, uint64 size)
 {
-	return insert_physical_address_range(gKernelArgs.physical_allocated_range,
+	return insert_address_range(gKernelArgs.physical_allocated_range,
 		&gKernelArgs.num_physical_allocated_ranges,
 		MAX_PHYSICAL_ALLOCATED_RANGE, start, size);
 }
@@ -403,19 +305,19 @@ void
 ignore_physical_memory_ranges_beyond_4gb()
 {
 	// sort
-	sort_physical_address_ranges(gKernelArgs.physical_memory_range,
+	sort_address_ranges(gKernelArgs.physical_memory_range,
 		gKernelArgs.num_physical_memory_ranges);
 
-	static const phys_addr_t kLimit = (phys_addr_t)1 << 32;
+	static const uint64 kLimit = (uint64)1 << 32;
 
 	// remove everything past 4 GB
 	for (uint32 i = gKernelArgs.num_physical_memory_ranges; i > 0; i--) {
-		phys_addr_range& range = gKernelArgs.physical_memory_range[i - 1];
+		addr_range& range = gKernelArgs.physical_memory_range[i - 1];
 		if (range.start >= kLimit) {
 			// the complete range is beyond the limit
 			dprintf("ignore_physical_memory_ranges_beyond_4gb(): ignoring "
-				"range: %#" B_PRIxPHYSADDR " - %#" B_PRIxPHYSADDR "\n",
+				"range: %#" B_PRIx64 " - %#" B_PRIx64 "\n", range.start,
-				range.start, range.start + range.size);
+				range.start + range.size);
 			gKernelArgs.ignored_physical_memory += range.size;
 			gKernelArgs.num_physical_memory_ranges = i - 1;
 			continue;
@@ -424,7 +326,7 @@ ignore_physical_memory_ranges_beyond_4gb()
 		if (kLimit - range.start < range.size) {
 			// the range is partially beyond the limit
 			dprintf("ignore_physical_memory_ranges_beyond_4gb(): ignoring "
-				"range: %#" B_PRIxPHYSADDR " - %#" B_PRIxPHYSADDR "\n", kLimit,
+				"range: %#" B_PRIx64 " - %#" B_PRIx64 "\n", kLimit,
 				range.start + range.size);
 			gKernelArgs.ignored_physical_memory
 				+= range.size - (kLimit - range.start);

src/system/boot/loader/menu.cpp

@@ -747,8 +747,8 @@ add_safe_mode_menu()
 	// check whether we have memory beyond 4 GB
 	bool hasMemoryBeyond4GB = false;
 	for (uint32 i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
-		phys_addr_range& range = gKernelArgs.physical_memory_range[i];
+		addr_range& range = gKernelArgs.physical_memory_range[i];
-		if (range.start >= (phys_addr_t)1 << 32) {
+		if (range.start >= (uint64)1 << 32) {
 			hasMemoryBeyond4GB = true;
 			break;
 		}

src/system/boot/platform/amiga_m68k/mmu.cpp

@@ -503,9 +503,9 @@ mmu_init_for_kernel(void)
 	gKernelArgs.num_virtual_allocated_ranges = 1;
 
 	// sort the address ranges
-	sort_physical_address_ranges(gKernelArgs.physical_memory_range,
+	sort_address_ranges(gKernelArgs.physical_memory_range,
 		gKernelArgs.num_physical_memory_ranges);
-	sort_physical_address_ranges(gKernelArgs.physical_allocated_range,
+	sort_address_ranges(gKernelArgs.physical_allocated_range,
 		gKernelArgs.num_physical_allocated_ranges);
 	sort_address_ranges(gKernelArgs.virtual_allocated_range,
 		gKernelArgs.num_virtual_allocated_ranges);
@@ -516,17 +516,23 @@ mmu_init_for_kernel(void)
 
 		dprintf("phys memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
-			dprintf("    base 0x%08lx, length 0x%08lx\n", gKernelArgs.physical_memory_range[i].start, gKernelArgs.physical_memory_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.physical_memory_range[i].start,
+				gKernelArgs.physical_memory_range[i].size);
 		}
 
 		dprintf("allocated phys memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_physical_allocated_ranges; i++) {
-			dprintf("    base 0x%08lx, length 0x%08lx\n", gKernelArgs.physical_allocated_range[i].start, gKernelArgs.physical_allocated_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.physical_allocated_range[i].start,
+				gKernelArgs.physical_allocated_range[i].size);
 		}
 
 		dprintf("allocated virt memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_virtual_allocated_ranges; i++) {
-			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n", gKernelArgs.virtual_allocated_range[i].start, gKernelArgs.virtual_allocated_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.virtual_allocated_range[i].start,
+				gKernelArgs.virtual_allocated_range[i].size);
 		}
 	}
 #endif

src/system/boot/platform/atari_m68k/mmu.cpp

@@ -503,9 +503,9 @@ mmu_init_for_kernel(void)
 	gKernelArgs.num_virtual_allocated_ranges = 1;
 
 	// sort the address ranges
-	sort_physical_address_ranges(gKernelArgs.physical_memory_range,
+	sort_address_ranges(gKernelArgs.physical_memory_range,
 		gKernelArgs.num_physical_memory_ranges);
-	sort_physical_address_ranges(gKernelArgs.physical_allocated_range,
+	sort_address_ranges(gKernelArgs.physical_allocated_range,
 		gKernelArgs.num_physical_allocated_ranges);
 	sort_address_ranges(gKernelArgs.virtual_allocated_range,
 		gKernelArgs.num_virtual_allocated_ranges);
@@ -516,17 +516,23 @@ mmu_init_for_kernel(void)
 
 		dprintf("phys memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
-			dprintf("    base 0x%08lx, length 0x%08lx\n", gKernelArgs.physical_memory_range[i].start, gKernelArgs.physical_memory_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.physical_memory_range[i].start,
+				gKernelArgs.physical_memory_range[i].size);
 		}
 
 		dprintf("allocated phys memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_physical_allocated_ranges; i++) {
-			dprintf("    base 0x%08lx, length 0x%08lx\n", gKernelArgs.physical_allocated_range[i].start, gKernelArgs.physical_allocated_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.physical_allocated_range[i].start,
+				gKernelArgs.physical_allocated_range[i].size);
 		}
 
 		dprintf("allocated virt memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_virtual_allocated_ranges; i++) {
-			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n", gKernelArgs.virtual_allocated_range[i].start, gKernelArgs.virtual_allocated_range[i].size);
+			dprintf("    base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n",
+				gKernelArgs.virtual_allocated_range[i].start,
+				gKernelArgs.virtual_allocated_range[i].size);
 		}
 	}
 #endif

src/system/boot/platform/bios_ia32/mmu.cpp

@@ -108,8 +108,8 @@ get_next_virtual_address(size_t size)
 static addr_t
 get_next_physical_address(size_t size)
 {
-	phys_addr_t base;
+	uint64 base;
-	if (!get_free_physical_address_range(gKernelArgs.physical_allocated_range,
+	if (!get_free_address_range(gKernelArgs.physical_allocated_range,
 			gKernelArgs.num_physical_allocated_ranges, sNextPhysicalAddress,
 			size, &base)) {
 		panic("Out of physical memory!");
@@ -426,14 +426,14 @@ bool
 mmu_allocate_physical(addr_t base, size_t size)
 {
 	// check whether the physical memory range exists at all
-	if (!is_physical_address_range_covered(gKernelArgs.physical_memory_range,
+	if (!is_address_range_covered(gKernelArgs.physical_memory_range,
 			gKernelArgs.num_physical_memory_ranges, base, size)) {
 		return false;
 	}
 
 	// check whether the physical range is still free
-	phys_addr_t foundBase;
+	uint64 foundBase;
-	if (!get_free_physical_address_range(gKernelArgs.physical_allocated_range,
+	if (!get_free_address_range(gKernelArgs.physical_allocated_range,
 			gKernelArgs.num_physical_allocated_ranges, base, size, &foundBase)
 		|| foundBase != base) {
 		return false;
@@ -565,9 +565,9 @@ mmu_init_for_kernel(void)
 	gKernelArgs.num_virtual_allocated_ranges = 1;
 
 	// sort the address ranges
-	sort_physical_address_ranges(gKernelArgs.physical_memory_range,
+	sort_address_ranges(gKernelArgs.physical_memory_range,
 		gKernelArgs.num_physical_memory_ranges);
-	sort_physical_address_ranges(gKernelArgs.physical_allocated_range,
+	sort_address_ranges(gKernelArgs.physical_allocated_range,
 		gKernelArgs.num_physical_allocated_ranges);
 	sort_address_ranges(gKernelArgs.virtual_allocated_range,
 		gKernelArgs.num_virtual_allocated_ranges);
@@ -578,15 +578,14 @@ mmu_init_for_kernel(void)
 
 		dprintf("phys memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
-			dprintf("    base %#018" B_PRIxPHYSADDR ", length %#018"
+			dprintf("    base %#018" B_PRIx64 ", length %#018" B_PRIx64 "\n",
-				B_PRIxPHYSADDR "\n", gKernelArgs.physical_memory_range[i].start,
+				gKernelArgs.physical_memory_range[i].start,
 				gKernelArgs.physical_memory_range[i].size);
 		}
 
 		dprintf("allocated phys memory ranges:\n");
 		for (i = 0; i < gKernelArgs.num_physical_allocated_ranges; i++) {
-			dprintf("    base %#018" B_PRIxPHYSADDR ", length %#018"
+			dprintf("    base %#018" B_PRIx64 ", length %#018" B_PRIx64 "\n",
-				B_PRIxPHYSADDR "\n",
 				gKernelArgs.physical_allocated_range[i].start,
 				gKernelArgs.physical_allocated_range[i].size);
 		}
@@ -692,7 +691,7 @@ mmu_init(void)
 		}
 
 		// sort the ranges
-		sort_physical_address_ranges(gKernelArgs.physical_memory_range,
+		sort_address_ranges(gKernelArgs.physical_memory_range,
 			gKernelArgs.num_physical_memory_ranges);
 
 		// On some machines we get several ranges that contain only a few pages
@@ -701,10 +700,10 @@ mmu_init(void)
 		// leave us only with a few larger contiguous ranges (ideally one).
 		for (int32 i = gKernelArgs.num_physical_memory_ranges - 1; i >= 0;
 				i--) {
-			size_t size = gKernelArgs.physical_memory_range[i].size;
+			uint64 size = gKernelArgs.physical_memory_range[i].size;
 			if (size < 64 * 1024) {
-				addr_t start = gKernelArgs.physical_memory_range[i].start;
+				uint64 start = gKernelArgs.physical_memory_range[i].start;
-				remove_physical_address_range(gKernelArgs.physical_memory_range,
+				remove_address_range(gKernelArgs.physical_memory_range,
 					&gKernelArgs.num_physical_memory_ranges,
 					MAX_PHYSICAL_MEMORY_RANGE, start, size);
 			}

src/system/boot/platform/cfe/arch/ppc/mmu.cpp

@@ -98,9 +98,8 @@ is_virtual_allocated(void *address, size_t size)
 static bool
 is_physical_allocated(void *address, size_t size)
 {
-	phys_addr_t foundBase;
+	uint64 foundBase;
-	return !get_free_physical_address_range(
+	return !get_free_address_range(gKernelArgs.physical_allocated_range,
-		gKernelArgs.physical_allocated_range,
 		gKernelArgs.num_physical_allocated_ranges, (addr_t)address, size,
 		&foundBase) || foundBase != (addr_t)address;
 }
@@ -109,7 +108,7 @@ is_physical_allocated(void *address, size_t size)
 static bool
 is_physical_memory(void *address, size_t size)
 {
-	return is_physical_address_range_covered(gKernelArgs.physical_memory_range,
+	return is_address_range_covered(gKernelArgs.physical_memory_range,
 		gKernelArgs.num_physical_memory_ranges, (addr_t)address, size);
 }
 
@@ -243,7 +242,7 @@ find_physical_memory_range(size_t size)
 {
 	for (uint32 i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
 		if (gKernelArgs.physical_memory_range[i].size > size)
-			return (void *)gKernelArgs.physical_memory_range[i].start;
+			return (void *)(addr_t)gKernelArgs.physical_memory_range[i].start;
 	}
 	return PHYSINVAL;
 }
@@ -262,7 +261,8 @@ find_free_physical_range(size_t size)
 	}
 
 	for (uint32 i = 0; i < gKernelArgs.num_physical_allocated_ranges; i++) {
-		void *address = (void *)(gKernelArgs.physical_allocated_range[i].start
+		void *address =
+			(void *)(addr_t)(gKernelArgs.physical_allocated_range[i].start
 				+ gKernelArgs.physical_allocated_range[i].size);
 		if (!is_physical_allocated(address, size)
 			&& is_physical_memory(address, size))

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

@@ -180,9 +180,8 @@ is_virtual_allocated(void *address, size_t size)
 static bool
 is_physical_allocated(void *address, size_t size)
 {
-	phys_addr_t foundBase;
+	uint64 foundBase;
-	return !get_free_physical_address_range(
+	return !get_free_address_range(gKernelArgs.physical_allocated_range,
-		gKernelArgs.physical_allocated_range,
 		gKernelArgs.num_physical_allocated_ranges, (addr_t)address, size,
 		&foundBase) || foundBase != (addr_t)address;
 }
@@ -191,7 +190,7 @@ is_physical_allocated(void *address, size_t size)
 static bool
 is_physical_memory(void *address, size_t size)
 {
-	return is_physical_address_range_covered(gKernelArgs.physical_memory_range,
+	return is_address_range_covered(gKernelArgs.physical_memory_range,
 		gKernelArgs.num_physical_memory_ranges, (addr_t)address, size);
 }
 
@@ -424,7 +423,7 @@ find_physical_memory_range(size_t size)
 {
 	for (uint32 i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
 		if (gKernelArgs.physical_memory_range[i].size > size)
-			return (void *)gKernelArgs.physical_memory_range[i].start;
+			return (void *)(addr_t)gKernelArgs.physical_memory_range[i].start;
 	}
 	return PHYSINVAL;
 }
@@ -443,7 +442,8 @@ find_free_physical_range(size_t size)
 	}
 
 	for (uint32 i = 0; i < gKernelArgs.num_physical_allocated_ranges; i++) {
-		void *address = (void *)(gKernelArgs.physical_allocated_range[i].start
+		void *address =
+			(void *)(addr_t)(gKernelArgs.physical_allocated_range[i].start
 				+ gKernelArgs.physical_allocated_range[i].size);
 		if (!is_physical_allocated(address, size)
 			&& is_physical_memory(address, size))

src/system/kernel/arch/arm/arch_vm_translation_map.cpp

@@ -71,7 +71,7 @@ arch_vm_translation_map_init(kernel_args *args,
 	for (uint32 i = 0; i < args->num_virtual_allocated_ranges; i++) {
 		addr_t start = args->virtual_allocated_range[i].start;
 		addr_t end = start + args->virtual_allocated_range[i].size;
-		TRACE("  %#10" B_PRIx64 " - %#10" B_PRIx64 "\n", start, end);
+		TRACE("  %#10" B_PRIxADDR " - %#10" B_PRIxADDR "\n", start, end);
 	}
 	#endif
 

src/system/kernel/arch/m68k/arch_vm_translation_map.cpp

@@ -97,7 +97,7 @@ arch_vm_translation_map_init(kernel_args *args,
 	for (uint32 i = 0; i < args->num_virtual_allocated_ranges; i++) {
 		addr_t start = args->virtual_allocated_range[i].start;
 		addr_t end = start + args->virtual_allocated_range[i].size;
-		TRACE("  %#10" B_PRIx64 " - %#10" B_PRIx64 "\n", start, end);
+		TRACE("  %#10" B_PRIxADDR " - %#10" B_PRIxADDR "\n", start, end);
 	}
 #endif
 	switch (arch_mmu_type) {

src/system/kernel/arch/x86/arch_vm_translation_map.cpp

@@ -70,7 +70,7 @@ arch_vm_translation_map_init(kernel_args *args,
 	for (uint32 i = 0; i < args->num_virtual_allocated_ranges; i++) {
 		addr_t start = args->virtual_allocated_range[i].start;
 		addr_t end = start + args->virtual_allocated_range[i].size;
-		TRACE("  %#10" B_PRIx64 " - %#10" B_PRIx64 "\n", start, end);
+		TRACE("  %#10" B_PRIxADDR " - %#10" B_PRIxADDR "\n", start, end);
 	}
 #endif