remove lots of unnecessary sizeof computations with a convenient 'operator new' overload

Author: Joshua Warner

src/allocator.h

@@ -57,4 +57,8 @@ copy(Allocator* allocator, const char* a)
 
 } // namespace vm
 
+inline void* operator new (size_t size, vm::Allocator* allocator) {
+  return allocator->allocate(size);
+}
+
 #endif//ALLOCATOR_H

src/arm.cpp

@@ -228,7 +228,7 @@ class Context {
  public:
   Context(System* s, Allocator* a, Zone* zone):
     s(s), zone(zone), client(0), code(s, a, 1024), tasks(0), result(0),
-    firstBlock(new (zone->allocate(sizeof(MyBlock))) MyBlock(this, 0)),
+    firstBlock(new(zone) MyBlock(this, 0)),
     lastBlock(firstBlock), poolOffsetHead(0), poolOffsetTail(0),
     constantPool(0), constantPoolCount(0)
   { }
@@ -346,8 +346,7 @@ class Offset: public Promise {
 Promise*
 offset(Context* c, bool forTrace = false)
 {
-  return new (c->zone->allocate(sizeof(Offset)))
-    Offset(c, c->lastBlock, c->code.length(), forTrace);
+  return new(c->zone) Offset(c, c->lastBlock, c->code.length(), forTrace);
 }
 
 bool
@@ -414,8 +413,7 @@ class OffsetTask: public Task {
 void
 appendOffsetTask(Context* c, Promise* promise, Promise* instructionOffset)
 {
-  c->tasks = new (c->zone->allocate(sizeof(OffsetTask))) OffsetTask
-    (c->tasks, promise, instructionOffset);
+  c->tasks = new(c->zone) OffsetTask(c->tasks, promise, instructionOffset);
 }
 
 inline unsigned
@@ -628,17 +626,14 @@ appendConstantPoolEntry(Context* c, Promise* constant, Promise* callOffset)
   if (constant->resolved()) {
     // make a copy, since the original might be allocated on the
     // stack, and we need our copy to live until assembly is complete
-    constant = new (c->zone->allocate(sizeof(ResolvedPromise)))
-      ResolvedPromise(constant->value());
+    constant = new(c->zone) ResolvedPromise(constant->value());
   }
 
-  c->constantPool = new (c->zone->allocate(sizeof(ConstantPoolEntry)))
-    ConstantPoolEntry(c, constant, c->constantPool, callOffset);
+  c->constantPool = new(c->zone) ConstantPoolEntry(c, constant, c->constantPool, callOffset);
 
   ++ c->constantPoolCount;
 
-  PoolOffset* o = new (c->zone->allocate(sizeof(PoolOffset))) PoolOffset
-    (c->lastBlock, c->constantPool, c->code.length() - c->lastBlock->offset);
+  PoolOffset* o = new(c->zone) PoolOffset(c->lastBlock, c->constantPool, c->code.length() - c->lastBlock->offset);
 
   if (DebugPool) {
     fprintf(stderr, "add pool offset %p %d to block %p\n",
@@ -657,8 +652,7 @@ void
 appendPoolEvent(Context* c, MyBlock* b, unsigned offset, PoolOffset* head,
                 PoolOffset* tail)
 {
-  PoolEvent* e = new (c->zone->allocate(sizeof(PoolEvent))) PoolEvent
-    (head, tail, offset);
+  PoolEvent* e = new(c->zone) PoolEvent(head, tail, offset);
 
   if (b->poolEventTail) {
     b->poolEventTail->next = e;
@@ -1522,8 +1516,7 @@ branchCM(Context* c, TernaryOperation op, unsigned size,
 ShiftMaskPromise*
 shiftMaskPromise(Context* c, Promise* base, unsigned shift, int64_t mask)
 {
-  return new (c->zone->allocate(sizeof(ShiftMaskPromise)))
-    ShiftMaskPromise(base, shift, mask);
+  return new(c->zone) ShiftMaskPromise(base, shift, mask);
 }
 
 void
@@ -2158,9 +2151,7 @@ class MyAssembler: public Assembler {
   {
     Register stack(StackRegister);
     Memory stackLimit(ThreadRegister, stackLimitOffsetFromThread);
-    Constant handlerConstant
-      (new (c.zone->allocate(sizeof(ResolvedPromise)))
-       ResolvedPromise(handler));
+    Constant handlerConstant(new(c.zone) ResolvedPromise(handler));
     branchRM(&c, JumpIfGreaterOrEqual, TargetBytesPerWord, &stack, &stackLimit,
              &handlerConstant);
   }
@@ -2465,8 +2456,7 @@ class MyAssembler: public Assembler {
     MyBlock* b = c.lastBlock;
     b->size = c.code.length() - b->offset;
     if (startNew) {
-      c.lastBlock = new (c.zone->allocate(sizeof(MyBlock)))
-        MyBlock(&c, c.code.length());
+      c.lastBlock = new (c.zone) MyBlock(&c, c.code.length());
     } else {
       c.lastBlock = 0;
     }
@@ -2537,8 +2527,7 @@ Assembler*
 makeAssembler(System* system, Allocator* allocator, Zone* zone,
               Assembler::Architecture* architecture)
 {
-  return new (zone->allocate(sizeof(MyAssembler)))
-    MyAssembler(system, allocator, zone,
+  return new(zone) MyAssembler(system, allocator, zone,
                 static_cast<MyArchitecture*>(architecture));
 }
 

src/compile.cpp

@@ -1389,8 +1389,7 @@ class Frame {
   Compiler::Operand* append(object o) {
     BootContext* bc = context->bootContext;
     if (bc) {
-      Promise* p = new (bc->zone->allocate(sizeof(ListenPromise)))
-        ListenPromise(t->m->system, bc->zone);
+      Promise* p = new (bc->zone) ListenPromise(t->m->system, bc->zone);
 
       PROTECT(t, o);
       object pointer = makePointer(t, p);
@@ -1408,9 +1407,7 @@ class Frame {
         }
       }
 
-      context->objectPool = new
-        (context->zone.allocate(sizeof(PoolElement)))
-        PoolElement(t, o, context->objectPool);
+      context->objectPool = new(&context->zone) PoolElement(t, o, context->objectPool);
 
       ++ context->objectPoolCount;
 
@@ -1615,8 +1612,7 @@ class Frame {
   Promise* addressPromise(Promise* p) {
     BootContext* bc = context->bootContext;
     if (bc) {
-      bc->addresses = new (bc->zone->allocate(sizeof(DelayedPromise)))
-        DelayedPromise(t->m->system, bc->zone, p, bc->addresses);
+      bc->addresses = new(bc->zone) DelayedPromise(t->m->system, bc->zone, p, bc->addresses);
       return bc->addresses;
     } else {
       return p;
@@ -1633,7 +1629,7 @@ class Frame {
         (TargetBytesPerWord, c->memory
          (c->register_(t->arch->thread()), Compiler::AddressType,
           TargetThreadCodeImage), c->promiseConstant
-         (new (context->zone.allocate(sizeof(OffsetPromise)))
+         (new(&context->zone)
           OffsetPromise
           (p, - reinterpret_cast<intptr_t>(codeAllocator(t)->base)),
           Compiler::AddressType))
@@ -3417,8 +3413,7 @@ compileDirectInvoke(MyThread* t, Frame* frame, object target, bool tailCall)
           and (not (TailCalls and tailCall
                     and (methodFlags(t, target) & ACC_NATIVE))))
       {
-        Promise* p = new (bc->zone->allocate(sizeof(ListenPromise)))
-          ListenPromise(t->m->system, bc->zone);
+        Promise* p = new(bc->zone) ListenPromise(t->m->system, bc->zone);
 
         PROTECT(t, target);
         object pointer = makePointer(t, p);
@@ -6636,7 +6631,7 @@ calculateFrameMaps(MyThread* t, Context* context, uintptr_t* originalRoots,
       }
 
       if (path == 0) {
-        path = new (context->zone.allocate(sizeof(SubroutinePath)))
+        path = new(&context->zone)
           SubroutinePath(call, subroutinePath,
                          makeRootTable(t, &(context->zone), context->method));
       }
@@ -7061,8 +7056,7 @@ finish(MyThread* t, FixedAllocator* allocator, Context* context)
          p != bc->addressSentinal;
          p = p->next)
     {
-      p->basis = new (bc->zone->allocate(sizeof(ResolvedPromise)))
-        ResolvedPromise(p->basis->value());
+      p->basis = new(bc->zone) ResolvedPromise(p->basis->value());
     }
   }
 
@@ -9724,8 +9718,7 @@ compileCall(MyThread* t, Context* c, ThunkIndex index, bool call = true)
       (call ? Call : Jump, TargetBytesPerWord, RegisterOperand, &scratch);
   } else {
     Assembler::Constant proc
-      (new (c->zone.allocate(sizeof(ResolvedPromise)))
-       ResolvedPromise(reinterpret_cast<intptr_t>(t->thunkTable[index])));
+      (new(&c->zone) ResolvedPromise(reinterpret_cast<intptr_t>(t->thunkTable[index])));
 
     a->apply
       (call ? LongCall : LongJump, TargetBytesPerWord, ConstantOperand, &proc);