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