src/compiler/compiler_utility.cc

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "compiler_internals.h"

namespace art {

#ifdef WITH_MEMSTATS
struct Memstats {
  uint32_t allocStats[kNumAllocKinds];
  int listSizes[kNumListKinds];
  int listWasted[kNumListKinds];
  int listGrows[kNumListKinds];
  int listMaxElems[kNumListKinds];
  int bitMapSizes[kNumBitMapKinds];
  int bitMapWasted[kNumBitMapKinds];
  int bitMapGrows[kNumBitMapKinds];
};

const char* allocNames[kNumAllocKinds] = {
  "Misc       ",
  "BasicBlock ",
  "LIR        ",
  "MIR        ",
  "DataFlow   ",
  "GrowList   ",
  "GrowBitMap ",
  "Dalvik2SSA ",
  "DebugInfo  ",
  "Successor  ",
  "RegAlloc   ",
  "Data       ",
  "Preds      ",
};

const char* listNames[kNumListKinds] = {
  "Misc                  ",
  "blockList             ",
  "SSAtoDalvik           ",
  "dfsOrder              ",
  "dfsPostOrder          ",
  "domPostOrderTraversal ",
  "throwLaunchPads       ",
  "suspendLaunchPads     ",
  "switchTables          ",
  "fillArrayData         ",
  "SuccessorBlocks       ",
  "Predecessors          ",
};

const char* bitMapNames[kNumBitMapKinds] = {
  "Misc                  ",
  "Use                   ",
  "Def                   ",
  "LiveIn                ",
  "BlockMatrix           ",
  "Dominators            ",
  "IDominated            ",
  "DomFrontier           ",
  "Phi                   ",
  "TmpBlocks             ",
  "InputBlocks           ",
  "RegisterV             ",
  "TempSSARegisterV      ",
  "Null Check            ",
  "TmpBlockV             ",
  "Predecessors          ",
};
#endif

#define kArenaBitVectorGrowth    4   /* increase by 4 uint32_ts when limit hit */

/* Allocate the initial memory block for arena-based allocation */
bool oatHeapInit(CompilationUnit* cUnit)
{
  DCHECK(cUnit->arenaHead == NULL);
  cUnit->arenaHead =
      (ArenaMemBlock *) malloc(sizeof(ArenaMemBlock) + ARENA_DEFAULT_SIZE);
  if (cUnit->arenaHead == NULL) {
    LOG(FATAL) << "No memory left to create compiler heap memory";
  }
  cUnit->arenaHead->blockSize = ARENA_DEFAULT_SIZE;
  cUnit->currentArena = cUnit->arenaHead;
  cUnit->currentArena->bytesAllocated = 0;
  cUnit->currentArena->next = NULL;
  cUnit->numArenaBlocks = 1;
#ifdef WITH_MEMSTATS
  cUnit->mstats = (Memstats*) oatNew(cUnit, sizeof(Memstats), true,
                   kAllocDebugInfo);
#endif
  return true;
}

/* Arena-based malloc for compilation tasks */
void* oatNew(CompilationUnit* cUnit, size_t size, bool zero, oatAllocKind kind)
{
  size = (size + 3) & ~3;
#ifdef WITH_MEMSTATS
  if (cUnit->mstats != NULL) {
    cUnit->mstats->allocStats[kind] += size;
  }
#endif
retry:
  /* Normal case - space is available in the current page */
  if (size + cUnit->currentArena->bytesAllocated <=
    cUnit->currentArena->blockSize) {
    void *ptr;
    ptr = &cUnit->currentArena->ptr[cUnit->currentArena->bytesAllocated];
    cUnit->currentArena->bytesAllocated += size;
    if (zero) {
      memset(ptr, 0, size);
    }
    return ptr;
  } else {
    /*
     * See if there are previously allocated arena blocks before the last
     * reset
     */
    if (cUnit->currentArena->next) {
        cUnit->currentArena = cUnit->currentArena->next;
        cUnit->currentArena->bytesAllocated = 0;
        goto retry;
    }

    size_t blockSize = (size < ARENA_DEFAULT_SIZE) ?  ARENA_DEFAULT_SIZE : size;
    /* Time to allocate a new arena */
    ArenaMemBlock *newArena = (ArenaMemBlock *)
        malloc(sizeof(ArenaMemBlock) + blockSize);
    if (newArena == NULL) {
      LOG(FATAL) << "Arena allocation failure";
    }
    newArena->blockSize = blockSize;
    newArena->bytesAllocated = 0;
    newArena->next = NULL;
    cUnit->currentArena->next = newArena;
    cUnit->currentArena = newArena;
    cUnit->numArenaBlocks++;
    if (cUnit->numArenaBlocks > 20000) {
      LOG(INFO) << "Total arena pages: " << cUnit->numArenaBlocks;
    }
    goto retry;
  }
}

/* Reclaim all the arena blocks allocated so far */
void oatArenaReset(CompilationUnit* cUnit)
{
  ArenaMemBlock* head = cUnit->arenaHead;
  while (head != NULL) {
    ArenaMemBlock* p = head;
    head = head->next;
    free(p);
  }
  cUnit->arenaHead = NULL;
  cUnit->currentArena = NULL;
}

/* Growable List initialization */
void oatInitGrowableList(CompilationUnit* cUnit, GrowableList* gList,
                       size_t initLength, oatListKind kind)
{
  gList->numAllocated = initLength;
  gList->numUsed = 0;
  gList->elemList = (intptr_t *) oatNew(cUnit, sizeof(intptr_t) * initLength,
                                        true, kAllocGrowableList);
#ifdef WITH_MEMSTATS
  cUnit->mstats->listSizes[kind] += sizeof(intptr_t) * initLength;
  gList->kind = kind;
  if ((int)initLength > cUnit->mstats->listMaxElems[kind]) {
    cUnit->mstats->listMaxElems[kind] = initLength;
  }
#endif
}

/* Expand the capacity of a growable list */
void expandGrowableList(CompilationUnit* cUnit, GrowableList* gList)
{
  int newLength = gList->numAllocated;
  if (newLength < 128) {
    newLength <<= 1;
  } else {
    newLength += 128;
  }
  intptr_t *newArray =
      (intptr_t *) oatNew(cUnit, sizeof(intptr_t) * newLength, true,
                          kAllocGrowableList);
  memcpy(newArray, gList->elemList, sizeof(intptr_t) * gList->numAllocated);
#ifdef WITH_MEMSTATS
  cUnit->mstats->listSizes[gList->kind] += sizeof(intptr_t) * newLength;
  cUnit->mstats->listWasted[gList->kind] +=
      sizeof(intptr_t) * gList->numAllocated;
  cUnit->mstats->listGrows[gList->kind]++;
  if (newLength > cUnit->mstats->listMaxElems[gList->kind]) {
    cUnit->mstats->listMaxElems[gList->kind] = newLength;
  }
#endif
  gList->numAllocated = newLength;
  gList->elemList = newArray;
}

/* Insert a new element into the growable list */
void oatInsertGrowableList(CompilationUnit* cUnit, GrowableList* gList,
                         intptr_t elem)
{
  DCHECK_NE(gList->numAllocated, 0U);
  if (gList->numUsed == gList->numAllocated) {
    expandGrowableList(cUnit, gList);
  }
  gList->elemList[gList->numUsed++] = elem;
}

/* Delete an element from a growable list. Element must be present */
void oatDeleteGrowableList(GrowableList* gList, intptr_t elem)
{
  bool found = false;
  for (unsigned int i = 0; i < gList->numUsed; i++) {
    if (!found && gList->elemList[i] == elem) {
      found = true;
    }
    if (found) {
      gList->elemList[i] = gList->elemList[i+1];
    }
  }
  DCHECK_EQ(found, true);
  gList->numUsed--;
}

void oatGrowableListIteratorInit(GrowableList* gList,
                               GrowableListIterator* iterator)
{
  iterator->list = gList;
  iterator->idx = 0;
  iterator->size = gList->numUsed;
}

intptr_t oatGrowableListIteratorNext(GrowableListIterator* iterator)
{
  DCHECK_EQ(iterator->size, iterator->list->numUsed);
  if (iterator->idx == iterator->size) return 0;
  return iterator->list->elemList[iterator->idx++];
}

intptr_t oatGrowableListGetElement(const GrowableList* gList, size_t idx)
{
  DCHECK_LT(idx, gList->numUsed);
  return gList->elemList[idx];
}

#ifdef WITH_MEMSTATS
/* Dump memory usage stats */
void oatDumpMemStats(CompilationUnit* cUnit)
{
  uint32_t total = 0;
  for (int i = 0; i < kNumAllocKinds; i++) {
    total += cUnit->mstats->allocStats[i];
  }
  if (total > (10 * 1024 * 1024)) {
    LOG(INFO) << "MEMUSAGE: " << total << " : "
        << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
    LOG(INFO) << "insnsSize: " << cUnit->insnsSize;
    if (cUnit->disableDataflow) {
        LOG(INFO) << " ** Dataflow disabled ** ";
    }
    LOG(INFO) << "===== Overall allocations";
    for (int i = 0; i < kNumAllocKinds; i++) {
        LOG(INFO) << allocNames[i] << std::setw(10) <<
        cUnit->mstats->allocStats[i];
    }
    LOG(INFO) << "===== GrowableList allocations";
    for (int i = 0; i < kNumListKinds; i++) {
      LOG(INFO) << listNames[i]
                << " S:" << cUnit->mstats->listSizes[i]
                << ", W:" << cUnit->mstats->listWasted[i]
                << ", G:" << cUnit->mstats->listGrows[i]
                << ", E:" << cUnit->mstats->listMaxElems[i];
    }
    LOG(INFO) << "===== GrowableBitMap allocations";
    for (int i = 0; i < kNumBitMapKinds; i++) {
      LOG(INFO) << bitMapNames[i]
                << " S:" << cUnit->mstats->bitMapSizes[i]
                << ", W:" << cUnit->mstats->bitMapWasted[i]
                << ", G:" << cUnit->mstats->bitMapGrows[i];
    }
  }
}
#endif

/* Debug Utility - dump a compilation unit */
void oatDumpCompilationUnit(CompilationUnit* cUnit)
{
  BasicBlock* bb;
  const char* blockTypeNames[] = {
    "Entry Block",
    "Code Block",
    "Exit Block",
    "Exception Handling",
    "Catch Block"
  };

  LOG(INFO) << "Compiling " << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
  LOG(INFO) << cUnit->insns << " insns";
  LOG(INFO) << cUnit->numBlocks << " blocks in total";
  GrowableListIterator iterator;

  oatGrowableListIteratorInit(&cUnit->blockList, &iterator);

  while (true) {
    bb = (BasicBlock *) oatGrowableListIteratorNext(&iterator);
    if (bb == NULL) break;
    LOG(INFO) << StringPrintf("Block %d (%s) (insn %04x - %04x%s)",
        bb->id,
        blockTypeNames[bb->blockType],
        bb->startOffset,
        bb->lastMIRInsn ? bb->lastMIRInsn->offset : bb->startOffset,
        bb->lastMIRInsn ? "" : " empty");
    if (bb->taken) {
      LOG(INFO) << "  Taken branch: block " << bb->taken->id
                << "(0x" << std::hex << bb->taken->startOffset << ")";
    }
    if (bb->fallThrough) {
      LOG(INFO) << "  Fallthrough : block " << bb->fallThrough->id
                << " (0x" << std::hex << bb->fallThrough->startOffset << ")";
    }
  }
}

static uint32_t checkMasks[32] = {
  0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010,
  0x00000020, 0x00000040, 0x00000080, 0x00000100, 0x00000200,
  0x00000400, 0x00000800, 0x00001000, 0x00002000, 0x00004000,
  0x00008000, 0x00010000, 0x00020000, 0x00040000, 0x00080000,
  0x00100000, 0x00200000, 0x00400000, 0x00800000, 0x01000000,
  0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000,
  0x40000000, 0x80000000 };

/*
 * Allocate a bit vector with enough space to hold at least the specified
 * number of bits.
 *
 * NOTE: memory is allocated from the compiler arena.
 */
ArenaBitVector* oatAllocBitVector(CompilationUnit* cUnit,
                                unsigned int startBits, bool expandable,
                                oatBitMapKind kind)
{
  ArenaBitVector* bv;
  unsigned int count;

  DCHECK_EQ(sizeof(bv->storage[0]), 4U);        /* assuming 32-bit units */

  bv = (ArenaBitVector*) oatNew(cUnit, sizeof(ArenaBitVector), false,
                                kAllocGrowableBitMap);

  count = (startBits + 31) >> 5;

  bv->storageSize = count;
  bv->expandable = expandable;
  bv->storage = static_cast<uint32_t*>(oatNew(cUnit, count * sizeof(uint32_t), true,
                                              kAllocGrowableBitMap));
#ifdef WITH_MEMSTATS
  bv->kind = kind;
  cUnit->mstats->bitMapSizes[kind] += count * sizeof(uint32_t);
#endif
  return bv;
}

/*
 * Determine whether or not the specified bit is set.
 */
bool oatIsBitSet(const ArenaBitVector* pBits, unsigned int num)
{
  DCHECK_LT(num, pBits->storageSize * sizeof(uint32_t) * 8);

  unsigned int val = pBits->storage[num >> 5] & checkMasks[num & 0x1f];
  return (val != 0);
}

/*
 * Mark all bits bit as "clear".
 */
void oatClearAllBits(ArenaBitVector* pBits)
{
  unsigned int count = pBits->storageSize;
  memset(pBits->storage, 0, count * sizeof(uint32_t));
}

/*
 * Mark the specified bit as "set".
 *
 * Returns "false" if the bit is outside the range of the vector and we're
 * not allowed to expand.
 *
 * NOTE: memory is allocated from the compiler arena.
 */
bool oatSetBit(CompilationUnit* cUnit, ArenaBitVector* pBits, unsigned int num)
{
  if (num >= pBits->storageSize * sizeof(uint32_t) * 8) {
    if (!pBits->expandable) {
      LOG(FATAL) << "Can't expand";
    }

    /* Round up to word boundaries for "num+1" bits */
    unsigned int newSize = (num + 1 + 31) >> 5;
    DCHECK_GT(newSize, pBits->storageSize);
    uint32_t *newStorage = static_cast<uint32_t*>(oatNew(cUnit, newSize * sizeof(uint32_t), false,
                                                         kAllocGrowableBitMap));
    memcpy(newStorage, pBits->storage, pBits->storageSize * sizeof(uint32_t));
    memset(&newStorage[pBits->storageSize], 0,
           (newSize - pBits->storageSize) * sizeof(uint32_t));
#ifdef WITH_MEMSTATS
    cUnit->mstats->bitMapWasted[pBits->kind] +=
        pBits->storageSize * sizeof(uint32_t);
    cUnit->mstats->bitMapSizes[pBits->kind] += newSize * sizeof(uint32_t);
    cUnit->mstats->bitMapGrows[pBits->kind]++;
#endif
    pBits->storage = newStorage;
    pBits->storageSize = newSize;
  }

  pBits->storage[num >> 5] |= checkMasks[num & 0x1f];
  return true;
}

/*
 * Mark the specified bit as "unset".
 *
 * Returns "false" if the bit is outside the range of the vector and we're
 * not allowed to expand.
 *
 * NOTE: memory is allocated from the compiler arena.
 */
bool oatClearBit(ArenaBitVector* pBits, unsigned int num)
{
  if (num >= pBits->storageSize * sizeof(uint32_t) * 8) {
    LOG(FATAL) << "Attempt to clear a bit not set in the vector yet";;
  }

  pBits->storage[num >> 5] &= ~checkMasks[num & 0x1f];
  return true;
}

/*
 * If set is true, mark all bits as 1. Otherwise mark all bits as 0.
 */
void oatMarkAllBits(ArenaBitVector* pBits, bool set)
{
  int value = set ? -1 : 0;
  memset(pBits->storage, value, pBits->storageSize * static_cast<int>(sizeof(uint32_t)));
}

void oatDebugBitVector(char* msg, const ArenaBitVector* bv, int length)
{
  int i;

  LOG(INFO) <<  msg;
  for (i = 0; i < length; i++) {
    if (oatIsBitSet(bv, i)) {
      LOG(INFO) << "    Bit " << i << " is set";
    }
  }
}

void oatAbort(CompilationUnit* cUnit)
{
  LOG(FATAL) << "Compiler aborting";
}

void oatDumpBlockBitVector(const GrowableList* blocks, char* msg,
                         const ArenaBitVector* bv, int length)
{
  int i;

  LOG(INFO) <<  msg;
  for (i = 0; i < length; i++) {
    if (oatIsBitSet(bv, i)) {
      BasicBlock *bb = (BasicBlock *) oatGrowableListGetElement(blocks, i);
      char blockName[BLOCK_NAME_LEN];
      oatGetBlockName(bb, blockName);
      LOG(INFO) << "Bit " << i << " / " << blockName << " is set";
    }
  }
}
/* Initialize the iterator structure */
void oatBitVectorIteratorInit(ArenaBitVector* pBits,
                            ArenaBitVectorIterator* iterator)
{
  iterator->pBits = pBits;
  iterator->bitSize = pBits->storageSize * sizeof(uint32_t) * 8;
  iterator->idx = 0;
}

/*
 * If the vector sizes don't match, log an error and abort.
 */
void checkSizes(const ArenaBitVector* bv1, const ArenaBitVector* bv2)
{
  if (bv1->storageSize != bv2->storageSize) {
    LOG(FATAL) << "Mismatched vector sizes (" << bv1->storageSize
               << ", " << bv2->storageSize << ")";
  }
}

/*
 * Copy a whole vector to the other. Only do that when the both vectors have
 * the same size.
 */
void oatCopyBitVector(ArenaBitVector* dest, const ArenaBitVector* src)
{
  /* if dest is expandable and < src, we could expand dest to match */
  checkSizes(dest, src);

  memcpy(dest->storage, src->storage, sizeof(uint32_t) * dest->storageSize);
}

/*
 * Intersect two bit vectors and store the result to the dest vector.
 */

bool oatIntersectBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
                          const ArenaBitVector* src2)
{
  DCHECK(src1 != NULL);
  DCHECK(src2 != NULL);
  if (dest->storageSize != src1->storageSize ||
      dest->storageSize != src2->storageSize ||
      dest->expandable != src1->expandable ||
      dest->expandable != src2->expandable)
    return false;

  unsigned int idx;
  for (idx = 0; idx < dest->storageSize; idx++) {
    dest->storage[idx] = src1->storage[idx] & src2->storage[idx];
  }
  return true;
}

/*
 * Unify two bit vectors and store the result to the dest vector.
 */
bool oatUnifyBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
                      const ArenaBitVector* src2)
{
  DCHECK(src1 != NULL);
  DCHECK(src2 != NULL);
  if (dest->storageSize != src1->storageSize ||
      dest->storageSize != src2->storageSize ||
      dest->expandable != src1->expandable ||
      dest->expandable != src2->expandable)
    return false;

  unsigned int idx;
  for (idx = 0; idx < dest->storageSize; idx++) {
    dest->storage[idx] = src1->storage[idx] | src2->storage[idx];
  }
  return true;
}

/*
 * Return true if any bits collide.  Vectors must be same size.
 */
bool oatTestBitVectors(const ArenaBitVector* src1,
                     const ArenaBitVector* src2)
{
  DCHECK_EQ(src1->storageSize, src2->storageSize);
  for (uint32_t idx = 0; idx < src1->storageSize; idx++) {
    if (src1->storage[idx] & src2->storage[idx]) return true;
  }
  return false;
}

/*
 * Compare two bit vectors and return true if difference is seen.
 */
bool oatCompareBitVectors(const ArenaBitVector* src1,
                        const ArenaBitVector* src2)
{
  if (src1->storageSize != src2->storageSize ||
      src1->expandable != src2->expandable)
    return true;

  unsigned int idx;
  for (idx = 0; idx < src1->storageSize; idx++) {
    if (src1->storage[idx] != src2->storage[idx]) return true;
  }
  return false;
}

/*
 * Count the number of bits that are set.
 */
int oatCountSetBits(const ArenaBitVector* pBits)
{
  unsigned int word;
  unsigned int count = 0;

  for (word = 0; word < pBits->storageSize; word++) {
    uint32_t val = pBits->storage[word];

    if (val != 0) {
      if (val == 0xffffffff) {
        count += 32;
      } else {
        /* count the number of '1' bits */
        while (val != 0) {
          val &= val - 1;
          count++;
        }
      }
    }
  }

  return count;
}

/* Return the next position set to 1. -1 means end-of-element reached */
int oatBitVectorIteratorNext(ArenaBitVectorIterator* iterator)
{
  ArenaBitVector* pBits = iterator->pBits;
  uint32_t bitIndex = iterator->idx;
  uint32_t bitSize = iterator->bitSize;

  DCHECK_EQ(bitSize, pBits->storageSize * sizeof(uint32_t) * 8);

  if (bitIndex >= bitSize) return -1;

  uint32_t wordIndex = bitIndex >> 5;
  uint32_t endWordIndex = bitSize >> 5;
  uint32_t* storage = pBits->storage;
  uint32_t word = storage[wordIndex++];

  // Mask out any bits in the first word we've already considered
  word &= ~((1 << (bitIndex & 0x1f))-1);

  for (; wordIndex <= endWordIndex;) {
    uint32_t bitPos = bitIndex & 0x1f;
    if (word == 0) {
      bitIndex += (32 - bitPos);
      word = storage[wordIndex++];
      continue;
    }
    for (; bitPos < 32; bitPos++) {
      if (word & (1 << bitPos)) {
        iterator->idx = bitIndex + 1;
        return bitIndex;
      }
      bitIndex++;
    }
    word = storage[wordIndex++];
  }
  iterator->idx = iterator->bitSize;
  return -1;
}

/*
 * Mark specified number of bits as "set". Cannot set all bits like ClearAll
 * since there might be unused bits - setting those to one will confuse the
 * iterator.
 */
void oatSetInitialBits(ArenaBitVector* pBits, unsigned int numBits)
{
  unsigned int idx;
  DCHECK_LE(((numBits + 31) >> 5), pBits->storageSize);
  for (idx = 0; idx < (numBits >> 5); idx++) {
    pBits->storage[idx] = -1;
  }
  unsigned int remNumBits = numBits & 0x1f;
  if (remNumBits) {
    pBits->storage[idx] = (1 << remNumBits) - 1;
  }
}

void oatGetBlockName(BasicBlock* bb, char* name)
{
  switch (bb->blockType) {
    case kEntryBlock:
      snprintf(name, BLOCK_NAME_LEN, "entry_%d", bb->id);
      break;
    case kExitBlock:
      snprintf(name, BLOCK_NAME_LEN, "exit_%d", bb->id);
      break;
    case kDalvikByteCode:
      snprintf(name, BLOCK_NAME_LEN, "block%04x_%d", bb->startOffset, bb->id);
      break;
    case kExceptionHandling:
      snprintf(name, BLOCK_NAME_LEN, "exception%04x_%d", bb->startOffset,
               bb->id);
      break;
    default:
      snprintf(name, BLOCK_NAME_LEN, "??_%d", bb->id);
      break;
  }
}

const char* oatGetShortyFromTargetIdx(CompilationUnit *cUnit, int targetIdx)
{
  const DexFile::MethodId& methodId = cUnit->dex_file->GetMethodId(targetIdx);
  return cUnit->dex_file->GetShorty(methodId.proto_idx_);
}

}  // namespace art