Name locally allocated variables by their real name.

If an array is allocated locally in a function (rather than globally or
passed via function arguments), LLVM may emit IR that does not use the
original source name, as in:

    float elems[4];

becomes:

    %13 = alloca float, i64 %12, align 16, !dbg !1416
    tail call void @llvm.dbg.declare(metadata !{float* %13}, metadata
        !495), !dbg !1416

Originally, the variable could only be identified by the slot number
13, but the actual name (elems) is stored in debug information. This
patch will identify this case, search for the debug declare call,
extract the name of the variable, and store it for future usage.

In the past, a load from elems would generate the following output for a
GEP in the dynamic trace:

    0,54,func_name,43,50,29,824880
    2,64,0,1,indvars.iv,
    1,64,140727758711584,1,13,
    r,64,140727758711584,1,50,

And now, the third line becomes:

    1,64,140727758711584,1,elems,

Change-Id: I07e8ddc3f12cdaeeee6a3d41e8a39816eab8fa57

Author: xyzsam

full-trace/full_trace.cpp

@@ -193,6 +193,7 @@ bool Tracer::runOnBasicBlock(BasicBlock &BB) {
     st->purgeFunction();
     st->incorporateFunction(func);
     curr_function = func;
+    slotToVarName.clear();
   }
 
   if (!is_toplevel_mode && !is_tracking_function(funcName))
@@ -247,6 +248,10 @@ bool Tracer::runOnBasicBlock(BasicBlock &BB) {
     if (!itr->getType()->isVoidTy()) {
       handleInstructionResult(itr, nextitr, &env);
     }
+
+    if (isa<AllocaInst>(itr)) {
+      processAllocaInstruction(itr);
+    }
   }
   return false;
 }
@@ -410,18 +415,21 @@ bool Tracer::setOperandNameAndReg(Instruction *I, InstOperandParams *params) {
 }
 
 bool Tracer::getInstId(Instruction *I, char *bbid, char *instid, int *instc) {
-  int id = st->getLocalSlot(I);
-  bool has_name = I->hasName();
   assert(instid != nullptr);
-  if (has_name) {
-    strcpy(instid, (char *)I->getName().str().c_str());
+  if (I->hasName()) {
+    strcpy(instid, I->getName().str().c_str());
     return true;
   }
-  if (!has_name && id >= 0) {
+  int id = st->getLocalSlot(I);
+  if (slotToVarName.find(id) != slotToVarName.end()) {
+    strcpy(instid, slotToVarName[id].c_str());
+    return true;
+  }
+  if (id >= 0) {
     sprintf(instid, "%d", id);
     return true;
   }
-  if (!has_name && id == -1) {
+  if (id == -1) {
     // This instruction does not produce a value in a new register.
     // Examples include branches, stores, calls, returns.
     // instid is constructed using the bbid and a monotonically increasing
@@ -434,6 +442,38 @@ bool Tracer::getInstId(Instruction *I, char *bbid, char *instid, int *instc) {
   return false;
 }
 
+void Tracer::processAllocaInstruction(BasicBlock::iterator it) {
+  AllocaInst *alloca = dyn_cast<AllocaInst>(it);
+  // If this instruction's output register is already named, then we don't need
+  // to do any more searching.
+  if (!alloca->hasName()) {
+    int alloca_id = st->getLocalSlot(alloca);
+    bool found_debug_declare = false;
+    // The debug declare call is not guaranteed to come right after the alloca.
+    while (!found_debug_declare && !it->isTerminator()) {
+      it++;
+      Instruction *I = it;
+      DbgDeclareInst *di = dyn_cast<DbgDeclareInst>(I);
+      if (di) {
+        Value *wrapping_arg = di->getAddress();
+        int id = st->getLocalSlot(wrapping_arg);
+        // Ensure we've found the RIGHT debug declare call by comparing the
+        // variable whose debug information is being declared with the variable
+        // we're looking for.
+        if (id != alloca_id)
+          continue;
+
+        MDNode *md = di->getVariable();
+        // The name of the variable is the third operand of the metadata node.
+        Value *name_operand = md->getOperand(2);
+        std::string name = name_operand->getName().str();
+        slotToVarName[id] = name;
+        found_debug_declare = true;
+      }
+    }
+  }
+}
+
 void Tracer::getBBId(Value *BB, char *bbid) {
   int id;
   id = st->getLocalSlot(BB);

full-trace/full_trace.h

@@ -130,9 +130,9 @@ class Tracer : public BasicBlockPass {
     //
     // If the instruction does not produce a value, an artificial ID is
     // constructed by concatenating the given bbid, which both must not be NULL
-    // and the current instc.
+    // and the current instc, and this function returns false.
     //
-    // The ID is returned as a string in instid.
+    // The ID is stored in instid.
     bool getInstId(Instruction *I, char *bbid, char *instid, int *instc);
 
     // Construct an ID using the given instruction and environment.
@@ -141,6 +141,17 @@ class Tracer : public BasicBlockPass {
     // Get and set the operand name for this instruction.
     bool setOperandNameAndReg(Instruction *I, InstOperandParams *params);
 
+    // Get the variable name for this locally allocated variable.
+    //
+    // An alloca instruction allocates a certain amount of memory on the stack.
+    // This instruction will name the register that stores the pointer
+    // with the original source name if it is not locally allocated on the
+    // stack. If it is a local variable, it may just store it to a temporary
+    // register and name it with a slot number. In this latter case, track down
+    // the original variable name using debug information and store it in the
+    // slotToVarName map.
+    void processAllocaInstruction(BasicBlock::iterator it);
+
     // Construct an ID for the given basic block.
     //
     // This ID is either the name of the basic block (e.g. ".lr.ph",
@@ -170,6 +181,16 @@ class Tracer : public BasicBlockPass {
     // True if WORKLOAD specifies a single function, in which case the tracer
     // will track all functions called by it (the top-level function).
     bool is_toplevel_mode;
+
+  private:
+    // Stores names of local variables allocated by alloca.
+    //
+    // For alloca instructions that allocate local memory, this maps the
+    // register name (aka slot number) to the name of the variable itself.
+    //
+    // Since slot numbers are reused across functions, this has to be cleared
+    // when we switch to a new function.
+    std::map<unsigned, std::string> slotToVarName;
 };
 
 /* Reads a labelmap file and inserts it into the dynamic trace.