template <MEMFLAGS F> void* CHeapObj<F>::operator new(size_t size,
      address caller_pc){
#ifdef ASSERT
    void* p = (void*)AllocateHeap(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC));
    if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p);
    return p;
#else
    return (void *) AllocateHeap(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC));
#endif
  }

 // Constructor
 AgentLibrary(const char* name, const char* options, bool is_absolute_path, void* os_lib) {
   _name = AllocateHeap(strlen(name)+1);
   strcpy(_name, name);
   if (options == NULL) {
     _options = NULL;
   } else {
     _options = AllocateHeap(strlen(options)+1);
     strcpy(_options, options);
   }
   _is_absolute_path = is_absolute_path;
   _os_lib = os_lib;
   _next = NULL;
 }

 // Constructor
 AgentLibrary(const char* name, const char* options, bool is_absolute_path, void* os_lib) {
   _name = AllocateHeap(strlen(name)+1, mtInternal);
   strcpy(_name, name);
   if (options == NULL) {
     _options = NULL;
   } else {
     _options = AllocateHeap(strlen(options)+1, mtInternal);
     strcpy(_options, options);
   }
   _is_absolute_path = is_absolute_path;
   _os_lib = os_lib;
   _next = NULL;
   _state = agent_invalid;
   _is_static_lib = false;
 }

  void CountCodePattern::initComparing() {
    // general count stub;
    //  0: lea   count_addr, %eax
    //  6: movl  (%eax), %edx
    //  8: leal  1(%edx), %edx
    // 11: movl  %edx, (%eax)
    // 13: cmpl  %edx, limit
    // ??: jne jump_addr
    //     call recompile_addr
 
    
    Assembler* oldAssembler = theAssembler;
    Assembler* a = theAssembler = new Assembler(100, 100, false, true);

    a->leal(no_reg, initial_count_addr, VMAddressOperand, edx);
    countAddr_offset = a->offset() - sizeof(int32);
    a->movl(edx, 0, NumberOperand,  eax);
    a->incl(eax);
    a->movl(eax,  edx, 0, NumberOperand);
    a->cmpl(0xabcdef01, NumberOperand,   eax); 
    limit_offset = a->offset() - sizeof(int32);
    a->jne(0x87654321, CodeAddressOperand);
    nmAddr_offset = a->offset() - sizeof(int32);
    a->call((int32)Recompile_stub, VMAddressOperand);
    recompileStub_offset = a->offset() - sizeof(int32);

    instsSize = a->offset();
    pattern = (pc_t)AllocateHeap(instsSize, "countStub pattern");
    copy_bytes(a->instsStart, pattern, instsSize);
    *(int32*)&pattern[recompileStub_offset] -= pattern - a->instsStart; // fixup the call
    a->finalize();
    theAssembler = oldAssembler;    
  }

void* operator new(size_t size){
  static bool warned = false;
  if (!warned && warn_new_operator) 
    warning("should not call global (default) operator new");
  warned = true;
  return (void *) AllocateHeap(size, "global operator new");
}

D3D12_CPU_DESCRIPTOR_HANDLE DescriptorHeapAllocator::AllocateHeapSlot(SIZE_T & outIndex)
{
	std::unique_lock<std::mutex> lock(m_AllocMutex);
	if (m_FreeHeaps.empty()) 
	{
		AllocateHeap();
	}
	SIZE_T head = m_FreeHeaps.front();
	outIndex = head;
	Entry &heapEntry = m_Heaps[outIndex];
	assert(!heapEntry.m_FreeList.empty());
	Node range = heapEntry.m_FreeList.front();
	D3D12_CPU_DESCRIPTOR_HANDLE ret = { range.Start };
	range.Start += m_DescriptorSize;
	if (range.Start == range.End)
	{
		Node freeNode = heapEntry.m_FreeList.front();
		heapEntry.m_FreeList.remove(freeNode);
		if (heapEntry.m_FreeList.empty()) 
		{
			m_FreeHeaps.remove(head);
		}
	}
	return ret;
}

E* ArrayAllocator<E, F>::allocate(size_t length) {
  assert(_addr == NULL, "Already in use");

  _size = sizeof(E) * length;
  _use_malloc = _size < ArrayAllocatorMallocLimit;

  if (_use_malloc) {
    _addr = AllocateHeap(_size, F);
    if (_addr == NULL && _size >=  (size_t)os::vm_allocation_granularity()) {
      // malloc failed let's try with mmap instead
      _use_malloc = false;
    } else {
      return (E*)_addr;
    }
  }

  int alignment = os::vm_allocation_granularity();
  _size = align_size_up(_size, alignment);

  _addr = os::reserve_memory(_size, NULL, alignment, F);
  if (_addr == NULL) {
    vm_exit_out_of_memory(_size, OOM_MMAP_ERROR, "Allocator (reserve)");
  }

  os::commit_memory_or_exit(_addr, _size, !ExecMem, "Allocator (commit)");

  return (E*)_addr;
}

void CountCodePattern::initCounting() {
    // general count stub; 7 instrs = 12 cycles on SS-2.  Could be reduced to
    // 6 insts / 10 cy if one additional register were available (e.g. could
    // use %o5 for sends with < 5 args).
    // 0: sethi count_addr, Temp1
    // 1: ld    [Temp1+lo(count_addr)], Temp2
    // 2: inc   Temp2
    // 3: st    Temp2, [Temp1+lo(count_addr)]
    // 4: sethi jump_addr, Temp1
    // 5: jmpl   Temp1 + low(jump_addr), g0
    // 6: nop
    instsSize = 7 * 4;
    countAddr_offset = 0;
    ld_offset = 1;
    st_offset = 3;
    nm_sethi_offset = 4;
    nm_jmp_offset = 5;
    limit_sethi_offset = countAddr_offset2 = recompile_offset = BadOffset;

    Assembler* a = new Assembler(instsSize, instsSize, false, true);
    a->SetHiA(0, Temp1);
    a->LoadI(Temp1, 0, Temp2);
    a->AddI(Temp2, 1, Temp2);
    a->StoreI(Temp1, 0, Temp2);
    a->SetHiX(0, CodeAddressOperand, Temp1);
    a->JmpLC(Temp1, 0, G0);
    a->Nop();

    pattern = (pc_t)AllocateHeap(instsSize, "countStub pattern");
    copy_words((int32*)a->instsStart, (int32*)pattern, instsSize / 4);
    a->finalize();
}

  void CountCodePattern::initCounting() {
    // general count stub; 8 instructions.
    // 0: lis     Temp1, high(count_addr)
    // 1: lwz     Temp2, [low(count_addr) + Temp1]
    // 2: addi    Temp2, Temp2, 1
    // 3: stw     Temp2, [low(count_addr) + Temp1]
    // 4: lis     Temp1, high(jump_addr)
    // 5: ori     Temp1, Temp1, low(jump_addr)
    // 6: mtctr   Temp1
    // 7: balwctr

    instsSize         = 8 * 4;
     countAddr_offset = 0;
           lwz_offset = 1;
           stw_offset = 3;
        nm_lis_offset = 4;
        nm_ori_offset = 5;
         limit_offset = recompile_lis_offset = recompile_ori_offset = BadOffset;

    Assembler* oldAssembler = theAssembler;
    Assembler* a = theAssembler = new Assembler(instsSize, instsSize, false, true);
    a->load_from_address(Temp2, 0, VMAddressOperand, Temp1);      // 2 instructions
    a->addi(Temp2, Temp2, 1, NumberOperand);
    a->stw(Temp2, 0, VMAddressOperand, Temp1);
    a->long_branch_to((pc_t)0, CodeAddressOperand, Temp1, false); // 4 instructions

    pattern = (pc_t)AllocateHeap(instsSize, "countStub pattern");
    copy_words((int32*)a->instsStart, (int32*)pattern, instsSize / 4);
    a->finalize();
    theAssembler = oldAssembler;
  }

 // Constructor
 SystemProperty(const char* key, const char* value, bool writeable) {
   if (key == NULL) {
     _key = NULL;
   } else {
     _key = AllocateHeap(strlen(key)+1, mtInternal);
     strcpy(_key, key);
   }
   if (value == NULL) {
     _value = NULL;
   } else {
     _value = AllocateHeap(strlen(value)+1, mtInternal);
     strcpy(_value, value);
   }
   _next = NULL;
   _writeable = writeable;
 }

template <MEMFLAGS F> void* CHeapObj<F>::operator new(size_t size,
      const NativeCallStack& stack) throw() {
  void* p = (void*)AllocateHeap(size, F, stack);
#ifdef ASSERT
  if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p);
#endif
  return p;
}

ResourceAreaChunk::ResourceAreaChunk(int min_capacity,
    ResourceAreaChunk* previous) {
  // lprintf("Resources cap=%d used=%d\n", resources.capacity(), resources.used());

  int size =
      max(min_capacity + min_resource_free_size, min_resource_chunk_size);
  bottom = (char*) AllocateHeap(size, "resourceAreaChunk");
  top = bottom + size;
  initialize(previous);
}

ResourceAreaChunk::ResourceAreaChunk(fint min_capacity,
                                     ResourceAreaChunk* previous) {
  if (PrintResourceChunkAllocation)
    lprintf("allocating new resource chunk %#lx\n", this);
  fint size = max(min_capacity + min_resource_free_size,
                  min_resource_chunk_size);
  bottom = (char*) AllocateHeap(size,"resourceAreaChunk");
  top    = bottom + size;
  initialize(previous);
}

ThreadProfiler::ThreadProfiler() {
  // Space for the ProfilerNodes
  const int area_size = 1 * ProfilerNodeSize * 1024;
  area_bottom = AllocateHeap(area_size, mtInternal);
  area_top    = area_bottom;
  area_limit  = area_bottom + area_size;

  // ProfilerNode pointer table
  table = NEW_C_HEAP_ARRAY(ProfilerNode*, table_size, mtInternal);
  initialize();
  engaged = false;
}

void* rSet::operator new(size_t size) {
  assert((int(Universe::new_gen.low_boundary) & (card_size - 1)) == 0,
	 "new must start at card boundary");
  assert((int(Universe::old_gen.low_boundary) & (card_size - 1)) == 0,
	 "old must start at card boundary");
  assert((int(Universe::old_gen.high_boundary) & (card_size - 1)) == 0,
	 "old must end at card boundary");
  assert(card_size >= 512, "card_size must be at least 512");
  int bmsize =
    (Universe::old_gen.high_boundary - Universe::new_gen.low_boundary)
      / card_size;
  return AllocateHeap(size + bmsize, "rSet");
}

 bool set_value(char *value) {
   if (writeable()) {
     if (_value != NULL) {
       FreeHeap(_value);
     }
     _value = AllocateHeap(strlen(value)+1, mtInternal);
     if (_value != NULL) {
       strcpy(_value, value);
     }
     return true;
   }
   return false;
 }

void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) throw() {
  address res;
  switch (type) {
   case C_HEAP:
    res = (address)AllocateHeap(size, flags, CALLER_PC);
    DEBUG_ONLY(set_allocation_type(res, C_HEAP);)
    break;
   case RESOURCE_AREA:
    // new(size) sets allocation type RESOURCE_AREA.
    res = (address)operator new(size);
    break;
   default:
    ShouldNotReachHere();
  }