base: const-correctness of Allocator interface

This patch adds const qualifiers to the functions Allocator::consumed,
Allocator::overhead, Allocator::avail, and Range_allocator::valid_addr.

Fixes #1481

repos/base-hw/src/core/include/cpu_thread_allocator.h

@@ -43,19 +43,19 @@ namespace Genode
 			 ** Allocator interface **
 			 *************************/
 
-			bool alloc(size_t size, void **out_addr) {
+			bool alloc(size_t size, void **out_addr) override {
 				return _alloc->alloc(size, out_addr); }
 
-			void free(void *addr, size_t size) {
+			void free(void *addr, size_t size) override {
 				_alloc->free(addr, size); }
 
-			size_t consumed() {
+			size_t consumed() const override {
 				PDBG("Unexpected call");
 				while (1) ;
 				return 0;
 			}
 
-			size_t overhead(size_t size) {
+			size_t overhead(size_t size) const override {
 				PDBG("Unexpected call");
 				while (1) ;
 				return 0;

repos/base-hw/src/core/include/kernel/early_translations.h

@@ -44,18 +44,18 @@ class Genode::Early_translations_allocator : public Genode::Core_mem_translator
 	public:
 
 		Early_translations_allocator() { }
-		int add_range(addr_t base, size_t size) { return -1; }
-		int remove_range(addr_t base, size_t size) { return -1; }
-		Alloc_return alloc_aligned(size_t, void **, int, addr_t, addr_t) {
+		int add_range(addr_t base, size_t size) override { return -1; }
+		int remove_range(addr_t base, size_t size) override { return -1; }
+		Alloc_return alloc_aligned(size_t, void **, int, addr_t, addr_t) override {
 			return Alloc_return::RANGE_CONFLICT; }
-		Alloc_return alloc_addr(size_t size, addr_t addr) {
+		Alloc_return alloc_addr(size_t size, addr_t addr) override {
 			return Alloc_return::RANGE_CONFLICT; }
-		void   free(void *addr) {}
-		size_t avail() { return 0; }
-		bool valid_addr(addr_t addr) { return false; }
-		bool alloc(size_t size, void **out_addr) { return false; }
-		void free(void *addr, size_t) {  }
-		size_t overhead(size_t size) { return 0; }
+		void   free(void *addr) override { }
+		size_t avail() const override { return 0; }
+		bool valid_addr(addr_t addr) const override { return false; }
+		bool alloc(size_t size, void **out_addr) override { return false; }
+		void free(void *addr, size_t) override { }
+		size_t overhead(size_t size) const override { return 0; }
 		bool need_size_for_free() const override { return false; }
 		void * phys_addr(void * addr) { return addr; }
 		void * virt_addr(void * addr) { return addr; }

repos/base-hw/src/core/include/page_slab.h

@@ -102,10 +102,10 @@ class Genode::Page_slab : public Genode::Allocator
 		/**
 		 * Returns number of used slab blocks
 		 */
-		size_t _slab_blocks_in_use()
+		size_t _slab_blocks_in_use() const
 		{
 			size_t cnt = 0;
-			for (List_element<Slab_block> *le = _b_list.first();
+			for (List_element<Slab_block> const *le = _b_list.first();
 			     le; le = le->next(), cnt++) ;
 			return cnt;
 		}
@@ -220,10 +220,10 @@ class Genode::Page_slab : public Genode::Allocator
 		 * Allocator interface **
 		 ************************/
 
-		bool   alloc(size_t, void **addr) { return (*addr = alloc()); }
-		void   free(void *addr, size_t) { free(addr); }
-		size_t consumed() { return SLAB_BLOCK_SIZE * _slab_blocks_in_use(); }
-		size_t overhead(size_t) { return SLAB_BLOCK_SIZE/SLABS_PER_BLOCK; }
+		bool   alloc(size_t, void **addr) override { return (*addr = alloc()); }
+		void   free(void *addr, size_t) override { free(addr); }
+		size_t consumed() const override { return SLAB_BLOCK_SIZE * _slab_blocks_in_use(); }
+		size_t overhead(size_t) const override { return SLAB_BLOCK_SIZE/SLABS_PER_BLOCK; }
 		bool   need_size_for_free() const override { return false; }
 };
 

repos/base-linux/src/core/include/platform.h

@@ -59,15 +59,14 @@ namespace Genode {
 					return Alloc_return::OK;;
 				}
 
-				int    add_range(addr_t, size_t)    { return 0; }
-				int    remove_range(addr_t, size_t) { return 0; }
-				void   free(void *)                 { }
-				void   free(void *, size_t)         { }
-				size_t avail()                      { return ~0; }
-				bool   valid_addr(addr_t)           { return true; }
-				size_t overhead(size_t)             { return 0; }
-
-				bool need_size_for_free() const override { return true; }
+				int    add_range(addr_t, size_t)    override { return 0; }
+				int    remove_range(addr_t, size_t) override { return 0; }
+				void   free(void *) override                 { }
+				void   free(void *, size_t) override         { }
+				size_t avail() const override                { return ~0; }
+				bool   valid_addr(addr_t) const override     { return true; }
+				size_t overhead(size_t) const override       { return 0; }
+				bool   need_size_for_free() const override   { return true; }
 			};
 
 			Pseudo_ram_allocator _ram_alloc;

repos/base/include/base/allocator.h

@@ -95,12 +95,12 @@ struct Genode::Allocator : Deallocator
 	/**
 	 * Return total amount of backing store consumed by the allocator
 	 */
-	virtual size_t consumed() { return 0; }
+	virtual size_t consumed() const { return 0; }
 
 	/**
 	 * Return meta-data overhead per block
 	 */
-	virtual size_t overhead(size_t size) = 0;
+	virtual size_t overhead(size_t size) const = 0;
 
 	/**
 	 * Allocate block and signal error as an exception
@@ -193,7 +193,7 @@ struct Genode::Range_allocator : Allocator
 	 * Note that the returned value is not neccessarily allocatable
 	 * because the memory may be fragmented.
 	 */
-	virtual size_t avail() = 0;
+	virtual size_t avail() const = 0;
 
 	/**
 	 * Check if address is inside an allocated block
@@ -203,7 +203,7 @@ struct Genode::Range_allocator : Allocator
 	 * \return      true if address is inside an allocated block, false
 	 *              otherwise
 	 */
-	virtual bool valid_addr(addr_t addr) = 0;
+	virtual bool valid_addr(addr_t addr) const = 0;
 };
 
 

repos/base/include/base/allocator_avl.h

@@ -250,18 +250,18 @@ class Genode::Allocator_avl_base : public Range_allocator
 		                           addr_t from = 0, addr_t to = ~0UL) override;
 		Alloc_return alloc_addr(size_t size, addr_t addr) override;
 		void         free(void *addr) override;
-		size_t       avail() override;
-		bool         valid_addr(addr_t addr) override;
+		size_t       avail() const override;
+		bool         valid_addr(addr_t addr) const override;
 
 
 		/*************************
 		 ** Allocator interface **
 		 *************************/
 
-		bool alloc(size_t size, void **out_addr) {
+		bool alloc(size_t size, void **out_addr) override {
 			return (Allocator_avl_base::alloc_aligned(size, out_addr).is_ok()); }
 
-		void free(void *addr, size_t) { free(addr); }
+		void free(void *addr, size_t) override { free(addr); }
 
 		/**
 		 * Return size of block at specified address
@@ -278,7 +278,7 @@ class Genode::Allocator_avl_base : public Range_allocator
 		 * The 'sizeof(umword_t)' represents the overhead of the meta-data
 		 * slab allocator.
 		 */
-		size_t overhead(size_t) { return sizeof(Block) + sizeof(umword_t); }
+		size_t overhead(size_t) const override { return sizeof(Block) + sizeof(umword_t); }
 
 		bool need_size_for_free() const override { return false; }
 };

repos/base/include/base/allocator_guard.h

@@ -93,7 +93,7 @@ class Genode::Allocator_guard : public Allocator
 		/**
 		 * Return amount of backing store consumed by the allocator
 		 */
-		size_t consumed() override { return _consumed; }
+		size_t consumed() const override { return _consumed; }
 
 		/**
 		 * Return allocation limit
@@ -103,7 +103,7 @@ class Genode::Allocator_guard : public Allocator
 		/**
 		 * Return meta-data overhead per block
 		 */
-		size_t overhead(size_t size) override { return _allocator->overhead(size); }
+		size_t overhead(size_t size) const override { return _allocator->overhead(size); }
 
 		bool need_size_for_free() const override {
 			return _allocator->need_size_for_free(); }

repos/base/include/base/heap.h

@@ -170,8 +170,8 @@ class Genode::Heap : public Allocator
 
 		bool   alloc(size_t, void **) override;
 		void   free(void *, size_t) override;
-		size_t consumed() override { return _quota_used; }
-		size_t overhead(size_t size) override { return _alloc.overhead(size); }
+		size_t consumed() const override { return _quota_used; }
+		size_t overhead(size_t size) const override { return _alloc.overhead(size); }
 		bool   need_size_for_free() const override { return false; }
 };
 
@@ -210,8 +210,8 @@ class Genode::Sliced_heap : public Allocator
 
 		bool   alloc(size_t, void **);
 		void   free(void *, size_t);
-		size_t consumed() { return _consumed; }
-		size_t overhead(size_t size);
+		size_t consumed() const { return _consumed; }
+		size_t overhead(size_t size) const;
 		bool   need_size_for_free() const override { return false; }
 };
 

repos/base/include/base/slab.h

@@ -265,10 +265,10 @@ class Genode::Slab : public Allocator
 		 * The 'size' parameter is ignored as only slab entries with
 		 * preconfigured slab-entry size are allocated.
 		 */
-		bool   alloc(size_t size, void **addr);
-		void   free(void *addr, size_t) { free(addr); }
-		size_t consumed();
-		size_t overhead(size_t) { return _block_size/_num_elem; }
+		bool   alloc(size_t size, void **addr) override;
+		void   free(void *addr, size_t) override { free(addr); }
+		size_t consumed() const override;
+		size_t overhead(size_t) const override { return _block_size/_num_elem; }
 		bool   need_size_for_free() const override { return false; }
 };
 

repos/base/include/base/sync_allocator.h

@@ -86,13 +86,13 @@ class Genode::Synchronized_allocator : public Allocator
 			_alloc.free(addr, size);
 		}
 
-		size_t consumed() override
+		size_t consumed() const override
 		{
 			Lock::Guard lock_guard(*_lock);
 			return _alloc.consumed();
 		}
 
-		size_t overhead(size_t size) override
+		size_t overhead(size_t size) const override
 		{
 			Lock::Guard lock_guard(*_lock);
 			return _alloc.overhead(size);
@@ -191,13 +191,13 @@ class Genode::Synchronized_range_allocator : public Range_allocator
 			_alloc.free(addr, size);
 		}
 
-		size_t consumed() override
+		size_t consumed() const override
 		{
 			Lock::Guard lock_guard(*_lock);
 			return _alloc.consumed();
 		}
 
-		size_t overhead(size_t size) override
+		size_t overhead(size_t size) const override
 		{
 			Lock::Guard lock_guard(*_lock);
 			return _alloc.overhead(size);
@@ -245,13 +245,13 @@ class Genode::Synchronized_range_allocator : public Range_allocator
 			_alloc.free(addr);
 		}
 
-		size_t avail() override
+		size_t avail() const override
 		{
 			Lock::Guard lock_guard(*_lock);
 			return _alloc.avail();
 		}
 
-		bool valid_addr(addr_t addr) override
+		bool valid_addr(addr_t addr) const override
 		{
 			Lock::Guard lock_guard(*_lock);
 			return _alloc.valid_addr(addr);

repos/base/src/base/allocator/allocator_avl.cc

@@ -358,14 +358,14 @@ bool Allocator_avl_base::any_block_addr(addr_t *out_addr)
 }
 
 
-size_t Allocator_avl_base::avail()
+size_t Allocator_avl_base::avail() const
 {
 	Block *b = static_cast<Block *>(_addr_tree.first());
 	return b ? b->avail_in_subtree() : 0;
 }
 
 
-bool Allocator_avl_base::valid_addr(addr_t addr)
+bool Allocator_avl_base::valid_addr(addr_t addr) const
 {
 	Block *b = _find_by_address(addr);
 	return b ? true : false;

repos/base/src/base/allocator/slab.cc

@@ -285,7 +285,7 @@ void *Slab::first_used_elem()
 }
 
 
-size_t Slab::consumed()
+size_t Slab::consumed() const
 {
 	/* count number of slab blocks */
 	unsigned sb_cnt = 0;

repos/base/src/base/heap/sliced_heap.cc

@@ -120,4 +120,7 @@ void Sliced_heap::free(void *addr, size_t size)
 }
 
 
-size_t Sliced_heap::overhead(size_t size) { return align_addr(size + sizeof(Block), 12) - size; }
+size_t Sliced_heap::overhead(size_t size) const
+{
+	return align_addr(size + sizeof(Block), 12) - size;
+}

repos/base/src/core/include/core_mem_alloc.h

@@ -159,15 +159,16 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator
 				 ** Range allocator interface **
 				 *******************************/
 
-				int add_range(addr_t base, size_t size)    { return -1; }
-				int remove_range(addr_t base, size_t size) { return -1; }
+				int add_range(addr_t base, size_t size) override { return -1; }
+				int remove_range(addr_t base, size_t size) override { return -1; }
 				Alloc_return alloc_aligned(size_t size, void **out_addr,
-				                           int align = 0, addr_t from = 0, addr_t to = ~0UL);
-				Alloc_return alloc_addr(size_t size, addr_t addr) {
+				                           int align = 0, addr_t from = 0,
+				                           addr_t to = ~0UL) override;
+				Alloc_return alloc_addr(size_t size, addr_t addr) override {
 					return Alloc_return::RANGE_CONFLICT; }
-				void         free(void *addr) {}
-				size_t       avail() { return _phys_alloc->avail(); }
-				bool         valid_addr(addr_t addr) {
+				void         free(void *addr) override { }
+				size_t       avail() const override { return _phys_alloc->avail(); }
+				bool         valid_addr(addr_t addr) const override {
 					return _virt_alloc->valid_addr(addr); }
 
 
@@ -175,11 +176,11 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator
 				 ** Allocator interface **
 				 *************************/
 
-				bool   alloc(size_t size, void **out_addr) {
+				bool   alloc(size_t size, void **out_addr) override {
 					return alloc_aligned(size, out_addr).is_ok(); }
-				void   free(void *addr, size_t) { free(addr); }
-				size_t consumed() { return _phys_alloc->consumed(); }
-				size_t overhead(size_t size) {
+				void   free(void *addr, size_t) override { free(addr); }
+				size_t consumed() const override { return _phys_alloc->consumed(); }
+				size_t overhead(size_t size) const override {
 					return _phys_alloc->overhead(size); }
 				bool   need_size_for_free() const override {
 					return _phys_alloc->need_size_for_free(); }
@@ -269,39 +270,40 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator
 		 ** Range allocator interface **
 		 *******************************/
 
-		int          add_range(addr_t base, size_t size) { return -1; }
-		int          remove_range(addr_t base, size_t size) { return -1; }
-		Alloc_return alloc_addr(size_t size, addr_t addr) {
+		int          add_range(addr_t base, size_t size) override { return -1; }
+		int          remove_range(addr_t base, size_t size) override { return -1; }
+		Alloc_return alloc_addr(size_t size, addr_t addr) override {
 			return Alloc_return::RANGE_CONFLICT; }
 
-		Alloc_return alloc_aligned(size_t size, void **out_addr, int align = 0, addr_t from = 0, addr_t to = ~0UL)
+		Alloc_return alloc_aligned(size_t size, void **out_addr, int align = 0,
+		                           addr_t from = 0, addr_t to = ~0UL) override
 		{
 			Lock::Guard lock_guard(_lock);
 			return _mem_alloc.alloc_aligned(size, out_addr, align, from, to);
 		}
 
-		void free(void *addr)
+		void free(void *addr) override
 		{
 			Lock::Guard lock_guard(_lock);
 			return _mem_alloc.free(addr);
 		}
 
-		size_t avail() { return _phys_alloc.avail(); }
+		size_t avail() const override { return _phys_alloc.avail(); }
 
-		bool valid_addr(addr_t addr) { return _virt_alloc.valid_addr(addr); }
+		bool valid_addr(addr_t addr) const override { return _virt_alloc.valid_addr(addr); }
 
 
 		/*************************
 		 ** Allocator interface **
 		 *************************/
 
-		bool alloc(size_t size, void **out_addr) {
+		bool alloc(size_t size, void **out_addr) override {
 			return alloc_aligned(size, out_addr).is_ok(); }
 
-		void free(void *addr, size_t) { free(addr); }
+		void free(void *addr, size_t) override { free(addr); }
 
-		size_t consumed() { return _phys_alloc.consumed(); }
-		size_t overhead(size_t size) { return _phys_alloc.overhead(size); }
+		size_t consumed()            const override { return _phys_alloc.consumed(); }
+		size_t overhead(size_t size) const override { return _phys_alloc.overhead(size); }
 
 		bool need_size_for_free() const override {
 			return _phys_alloc.need_size_for_free(); }

repos/base/src/test/new_delete/main.cc

@@ -45,12 +45,12 @@ struct Allocator : Genode::Allocator
 	Allocator() { }
 	virtual ~Allocator() { }
 
-	Genode::size_t consumed() override
+	Genode::size_t consumed() const override
 	{
 		return heap.consumed();
 	}
 
-	Genode::size_t overhead(Genode::size_t size) override
+	Genode::size_t overhead(Genode::size_t size) const override
 	{
 		return heap.overhead(size);
 	}

repos/dde_linux/src/lib/lxip/lxcc_emul.cc

@@ -99,7 +99,7 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
 		/**
 		 * Allocate 
 		 */
-		bool alloc(size_t size, void **out_addr)
+		bool alloc(size_t size, void **out_addr) override
 		{
 				bool done = _range.alloc(size, out_addr);
 
@@ -115,8 +115,8 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
 				return _range.alloc(size, out_addr);
 		}
 
-		void   free(void *addr, size_t /* size */) { }
-		size_t overhead(size_t size) { return  0; }
+		void   free(void *addr, size_t /* size */) override { }
+		size_t overhead(size_t size) const override { return  0; }
 		bool need_size_for_free() const override { return false; }
 
 		/**

repos/dde_linux/src/lib/usb/lx_emul.cc

@@ -102,7 +102,7 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
 		/**
 		 * Allocate 
 		 */
-		bool alloc(size_t size, void **out_addr)
+		bool alloc(size_t size, void **out_addr) override
 		{
 				bool done = _range.alloc(size, out_addr);
 
@@ -118,8 +118,8 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
 				return _range.alloc(size, out_addr);
 		}
 
-		void   free(void *addr, size_t /* size */) { }
-		size_t overhead(size_t size) { return  0; }
+		void   free(void *addr, size_t /* size */) override { }
+		size_t overhead(size_t size) const override { return  0; }
 		bool need_size_for_free() const override { return false; }
 
 		/**

repos/dde_linux/src/lib/wifi/lxcc_emul.cc

@@ -103,7 +103,7 @@ class Lx::Slab_backend_alloc : public Genode::Allocator,
 		/**
 		 * Allocate
 		 */
-		bool alloc(size_t size, void **out_addr)
+		bool alloc(size_t size, void **out_addr) override
 		{
 			bool done = _range.alloc(size, out_addr);
 
@@ -119,8 +119,8 @@ class Lx::Slab_backend_alloc : public Genode::Allocator,
 			return _range.alloc(size, out_addr);
 		}
 
-		void   free(void *addr, size_t /* size */) { }
-		size_t overhead(size_t size) { return  0; }
+		void   free(void *addr, size_t /* size */) override { }
+		size_t overhead(size_t size) const override { return  0; }
 		bool need_size_for_free() const override { return false; }
 
 		/**

repos/dde_rump/include/util/allocator_fap.h

@@ -151,8 +151,8 @@ namespace Allocator {
 				return addr;
 			}
 
-			void   free(void *addr, size_t size) { _range.free(addr, size); }
-			size_t overhead(size_t size) { return  0; }
+			void   free(void *addr, size_t size) override { _range.free(addr, size); }
+			size_t overhead(size_t size) const override { return  0; }
 			bool need_size_for_free() const override { return false; }
 
 			/**

repos/libports/src/lib/libc/malloc.cc

@@ -70,7 +70,7 @@ class Malloc : public Genode::Allocator
 		Genode::Slab_alloc *_allocator[NUM_SLABS]; /* slab allocators */
 		Genode::Lock        _lock;
 
-		unsigned long _slab_log2(unsigned long size)
+		unsigned long _slab_log2(unsigned long size) const
 		{
 			unsigned msb = Genode::log2(size);
 			/* size is greater than msb */
@@ -100,7 +100,7 @@ class Malloc : public Genode::Allocator
 		 * Allocator interface
 		 */
 
-		bool alloc(size_t size, void **out_addr)
+		bool alloc(size_t size, void **out_addr) override
 		{
 			Genode::Lock::Guard lock_guard(_lock);
 
@@ -132,7 +132,7 @@ class Malloc : public Genode::Allocator
 			return true;
 		}
 
-		void free(void *ptr, size_t /* size */)
+		void free(void *ptr, size_t /* size */) override
 		{
 			Genode::Lock::Guard lock_guard(_lock);
 
@@ -147,7 +147,7 @@ class Malloc : public Genode::Allocator
 			}
 		}
 
-		size_t overhead(size_t size)
+		size_t overhead(size_t size) const override
 		{
 			size += sizeof(Block_header);
 

repos/os/include/os/packet_allocator.h

@@ -67,7 +67,7 @@ class Genode::Packet_allocator : public Genode::Range_allocator
 		 ** Range-allocator interface **
 		 *******************************/
 
-		int add_range(addr_t base, size_t size)
+		int add_range(addr_t base, size_t size) override
 		{
 			if (_base || _array) return -1;
 
@@ -79,7 +79,7 @@ class Genode::Packet_allocator : public Genode::Range_allocator
 			return 0;
 		}
 
-		int remove_range(addr_t base, size_t size)
+		int remove_range(addr_t base, size_t size) override
 		{
 			if (_base != base) return -1;
 
@@ -89,13 +89,13 @@ class Genode::Packet_allocator : public Genode::Range_allocator
 		}
 
 		Alloc_return alloc_aligned(size_t size, void **out_addr, int, addr_t,
-			                       addr_t)
+			                       addr_t) override
 		{
 			return alloc(size, out_addr) ? Alloc_return::OK
 			                             : Alloc_return::RANGE_CONFLICT;
 		}
 
-		bool alloc(size_t size, void **out_addr)
+		bool alloc(size_t size, void **out_addr) override
 		{
 			addr_t const cnt = (size % _block_size) ? size / _block_size + 1
 			                                        : size / _block_size;
@@ -124,7 +124,7 @@ class Genode::Packet_allocator : public Genode::Range_allocator
 			return false;
 		}
 
-		void free(void *addr, size_t size)
+		void free(void *addr, size_t size) override
 		{
 			addr_t i   = (((addr_t)addr) - _base) / _block_size;
 			size_t cnt = (size % _block_size) ? size / _block_size + 1
@@ -139,11 +139,11 @@ class Genode::Packet_allocator : public Genode::Range_allocator
 		 *************/
 
 		bool need_size_for_free() const override { return false; }
-		void free(void *addr) { }
-		size_t overhead(size_t) {  return 0;}
-		size_t avail() { return 0; }
-		bool valid_addr(addr_t) { return 0; }
-		Alloc_return alloc_addr(size_t, addr_t) {
+		void free(void *addr) override { }
+		size_t overhead(size_t) const override {  return 0;}
+		size_t avail() const override { return 0; }
+		bool valid_addr(addr_t) const override { return 0; }
+		Alloc_return alloc_addr(size_t, addr_t) override {
 			return Alloc_return(Alloc_return::OUT_OF_METADATA); }
 };
 

repos/os/src/lib/dde_kit/memory.cc

@@ -152,9 +152,9 @@ class Backing_store_allocator : public Allocator
 			destroy(env()->heap(), b);
 		}
 
-		size_t consumed() { return _consumed; }
+		size_t consumed() const { return _consumed; }
 
-		size_t overhead(size_t size) { return 0; }
+		size_t overhead(size_t size) const { return 0; }
 
 		bool need_size_for_free() const override { return false; }
 };

repos/os/src/test/ram_fs_chunk/main.cc

@@ -42,8 +42,8 @@ namespace Genode {
 			_wrapped.free(addr, size);
 		}
 
-		size_t overhead(size_t size)    override { return _wrapped.overhead(size); }
-		bool need_size_for_free() const override { return _wrapped.need_size_for_free(); }
+		size_t overhead(size_t size) const override { return _wrapped.overhead(size); }
+		bool    need_size_for_free() const override { return _wrapped.need_size_for_free(); }
 	};
 };