Home | History | Annotate | Download | only in llvm-diff 
      1 //===-- DiffConsumer.cpp - Difference Consumer ------------------*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This files implements the the LLVM difference Consumer
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "DiffConsumer.h"
     15 
     16 #include "llvm/Module.h"
     17 #include "llvm/Instructions.h"
     18 #include "llvm/Support/ErrorHandling.h"
     19 
     20 using namespace llvm;
     21 
     22 static void ComputeNumbering(Function *F, DenseMap<Value*,unsigned> &Numbering){
     23   unsigned IN = 0;
     24 
     25   // Arguments get the first numbers.
     26   for (Function::arg_iterator
     27          AI = F->arg_begin(), AE = F->arg_end(); AI != AE; ++AI)
     28     if (!AI->hasName())
     29       Numbering[&*AI] = IN++;
     30 
     31   // Walk the basic blocks in order.
     32   for (Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) {
     33     if (!FI->hasName())
     34       Numbering[&*FI] = IN++;
     35 
     36     // Walk the instructions in order.
     37     for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE; ++BI)
     38       // void instructions don't get numbers.
     39       if (!BI->hasName() && !BI->getType()->isVoidTy())
     40         Numbering[&*BI] = IN++;
     41   }
     42 
     43   assert(!Numbering.empty() && "asked for numbering but numbering was no-op");
     44 }
     45 
     46 
     47 void Consumer::anchor() { }
     48 
     49 void DiffConsumer::printValue(Value *V, bool isL) {
     50   if (V->hasName()) {
     51     out << (isa<GlobalValue>(V) ? '@' : '%') << V->getName();
     52     return;
     53   }
     54   if (V->getType()->isVoidTy()) {
     55     if (isa<StoreInst>(V)) {
     56       out << "store to ";
     57       printValue(cast<StoreInst>(V)->getPointerOperand(), isL);
     58     } else if (isa<CallInst>(V)) {
     59       out << "call to ";
     60       printValue(cast<CallInst>(V)->getCalledValue(), isL);
     61     } else if (isa<InvokeInst>(V)) {
     62       out << "invoke to ";
     63       printValue(cast<InvokeInst>(V)->getCalledValue(), isL);
     64     } else {
     65       out << *V;
     66     }
     67     return;
     68   }
     69   if (isa<Constant>(V)) {
     70     out << *V;
     71     return;
     72   }
     73 
     74   unsigned N = contexts.size();
     75   while (N > 0) {
     76     --N;
     77     DiffContext &ctxt = contexts[N];
     78     if (!ctxt.IsFunction) continue;
     79     if (isL) {
     80       if (ctxt.LNumbering.empty())
     81         ComputeNumbering(cast<Function>(ctxt.L), ctxt.LNumbering);
     82       out << '%' << ctxt.LNumbering[V];
     83       return;
     84     } else {
     85       if (ctxt.RNumbering.empty())
     86         ComputeNumbering(cast<Function>(ctxt.R), ctxt.RNumbering);
     87       out << '%' << ctxt.RNumbering[V];
     88       return;
     89     }
     90   }
     91 
     92   out << "<anonymous>";
     93 }
     94 
     95 void DiffConsumer::header() {
     96   if (contexts.empty()) return;
     97   for (SmallVectorImpl<DiffContext>::iterator
     98          I = contexts.begin(), E = contexts.end(); I != E; ++I) {
     99     if (I->Differences) continue;
    100     if (isa<Function>(I->L)) {
    101       // Extra newline between functions.
    102       if (Differences) out << "\n";
    103 
    104       Function *L = cast<Function>(I->L);
    105       Function *R = cast<Function>(I->R);
    106       if (L->getName() != R->getName())
    107         out << "in function " << L->getName()
    108             << " / " << R->getName() << ":\n";
    109       else
    110         out << "in function " << L->getName() << ":\n";
    111     } else if (isa<BasicBlock>(I->L)) {
    112       BasicBlock *L = cast<BasicBlock>(I->L);
    113       BasicBlock *R = cast<BasicBlock>(I->R);
    114       if (L->hasName() && R->hasName() && L->getName() == R->getName())
    115         out << "  in block %" << L->getName() << ":\n";
    116       else {
    117         out << "  in block ";
    118         printValue(L, true);
    119         out << " / ";
    120         printValue(R, false);
    121         out << ":\n";
    122       }
    123     } else if (isa<Instruction>(I->L)) {
    124       out << "    in instruction ";
    125       printValue(I->L, true);
    126       out << " / ";
    127       printValue(I->R, false);
    128       out << ":\n";
    129     }
    130 
    131     I->Differences = true;
    132   }
    133 }
    134 
    135 void DiffConsumer::indent() {
    136   unsigned N = Indent;
    137   while (N--) out << ' ';
    138 }
    139 
    140 bool DiffConsumer::hadDifferences() const {
    141   return Differences;
    142 }
    143 
    144 void DiffConsumer::enterContext(Value *L, Value *R) {
    145   contexts.push_back(DiffContext(L, R));
    146   Indent += 2;
    147 }
    148 
    149 void DiffConsumer::exitContext() {
    150   Differences |= contexts.back().Differences;
    151   contexts.pop_back();
    152   Indent -= 2;
    153 }
    154 
    155 void DiffConsumer::log(StringRef text) {
    156   header();
    157   indent();
    158   out << text << '\n';
    159 }
    160 
    161 void DiffConsumer::logf(const LogBuilder &Log) {
    162   header();
    163   indent();
    164 
    165   unsigned arg = 0;
    166 
    167   StringRef format = Log.getFormat();
    168   while (true) {
    169     size_t percent = format.find('%');
    170     if (percent == StringRef::npos) {
    171       out << format;
    172       break;
    173     }
    174     assert(format[percent] == '%');
    175 
    176     if (percent > 0) out << format.substr(0, percent);
    177 
    178     switch (format[percent+1]) {
    179     case '%': out << '%'; break;
    180     case 'l': printValue(Log.getArgument(arg++), true); break;
    181     case 'r': printValue(Log.getArgument(arg++), false); break;
    182     default: llvm_unreachable("unknown format character");
    183     }
    184 
    185     format = format.substr(percent+2);
    186   }
    187 
    188   out << '\n';
    189 }
    190 
    191 void DiffConsumer::logd(const DiffLogBuilder &Log) {
    192   header();
    193 
    194   for (unsigned I = 0, E = Log.getNumLines(); I != E; ++I) {
    195     indent();
    196     switch (Log.getLineKind(I)) {
    197     case DC_match:
    198       out << "  ";
    199       Log.getLeft(I)->dump();
    200       //printValue(Log.getLeft(I), true);
    201       break;
    202     case DC_left:
    203       out << "< ";
    204       Log.getLeft(I)->dump();
    205       //printValue(Log.getLeft(I), true);
    206       break;
    207     case DC_right:
    208       out << "> ";
    209       Log.getRight(I)->dump();
    210       //printValue(Log.getRight(I), false);
    211       break;
    212     }
    213     //out << "\n";
    214   }
    215 }
    216