xref: /llvm-project/llvm/tools/llvm-diff/llvm-diff.cpp (revision 5e6a16d71fbfa7b8f31f278639952ca3454305f5) 
1 #include <string>
2 #include <utility>
3 
4 #include <llvm/ADT/StringRef.h>
5 #include <llvm/ADT/SmallVector.h>
6 #include <llvm/ADT/DenseMap.h>
7 
8 // Required to parse .ll files.
9 #include <llvm/Support/SourceMgr.h>
10 #include <llvm/Assembly/Parser.h>
11 
12 // Required to parse .bc files.
13 #include <llvm/Support/MemoryBuffer.h>
14 #include <llvm/Bitcode/ReaderWriter.h>
15 
16 #include <llvm/Support/raw_ostream.h>
17 #include <llvm/LLVMContext.h>
18 #include <llvm/Module.h>
19 #include <llvm/Type.h>
20 #include <llvm/Instructions.h>
21 
22 #include "DifferenceEngine.h"
23 
24 using namespace llvm;
25 
26 /// Reads a module from a file.  If the filename ends in .ll, it is
27 /// interpreted as an assembly file;  otherwise, it is interpreted as
28 /// bitcode.  On error, messages are written to stderr and null is
29 /// returned.
30 static Module *ReadModule(LLVMContext &Context, StringRef Name) {
31   // LLVM assembly path.
32   if (Name.endswith(".ll")) {
33     SMDiagnostic Diag;
34     Module *M = ParseAssemblyFile(Name, Diag, Context);
35     if (M) return M;
36 
37     Diag.Print("llvmdiff", errs());
38     return 0;
39   }
40 
41   // Bitcode path.
42   MemoryBuffer *Buffer = MemoryBuffer::getFile(Name);
43 
44   // ParseBitcodeFile takes ownership of the buffer if it succeeds.
45   std::string Error;
46   Module *M = ParseBitcodeFile(Buffer, Context, &Error);
47   if (M) return M;
48 
49   errs() << "error parsing " << Name << ": " << Error;
50   delete Buffer;
51   return 0;
52 }
53 
54 static int usage() {
55   errs() << "expected usage:\n";
56   errs() << "  llvm-diff oldmodule.ll newmodule.ll [function list]\n";
57   errs() << "Assembly or bitcode modules may be used interchangeably.\n";
58   errs() << "If no functions are provided, all functions will be compared.\n";
59   return 1;
60 }
61 
62 namespace {
63 struct DiffContext {
64   DiffContext(Value *L, Value *R)
65     : L(L), R(R), Differences(false), IsFunction(isa<Function>(L)) {}
66   Value *L;
67   Value *R;
68   bool Differences;
69   bool IsFunction;
70   DenseMap<Value*,unsigned> LNumbering;
71   DenseMap<Value*,unsigned> RNumbering;
72 };
73 
74 void ComputeNumbering(Function *F, DenseMap<Value*,unsigned> &Numbering) {
75   unsigned BBN = 0;
76   unsigned IN = 0;
77 
78   // Arguments get the first numbers.
79   for (Function::arg_iterator
80          AI = F->arg_begin(), AE = F->arg_end(); AI != AE; ++AI)
81     if (!AI->hasName())
82       Numbering[&*AI] = IN++;
83 
84   // Walk the basic blocks in order.
85   for (Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) {
86     // Basic blocks have their own 'namespace'.
87     if (!FI->hasName())
88       Numbering[&*FI] = BBN++;
89 
90     // Walk the instructions in order.
91     for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE; ++BI)
92       // void instructions don't get numbers.
93       if (!BI->hasName() && !BI->getType()->isVoidTy())
94         Numbering[&*BI] = IN++;
95   }
96 
97   assert(!Numbering.empty() && "asked for numbering but numbering was no-op");
98 }
99 
100 class DiffConsumer : public DifferenceEngine::Consumer {
101 private:
102   Module *LModule;
103   Module *RModule;
104   SmallVector<DiffContext, 5> contexts;
105   bool Differences;
106   unsigned Indent;
107 
108   void printValue(Value *V, bool isL) {
109     if (V->hasName()) {
110       errs() << (isa<GlobalValue>(V) ? '@' : '%') << V->getName();
111       return;
112     }
113     if (V->getType()->isVoidTy()) {
114       if (isa<StoreInst>(V)) {
115         errs() << "store to ";
116         printValue(cast<StoreInst>(V)->getPointerOperand(), isL);
117       } else if (isa<CallInst>(V)) {
118         errs() << "call to ";
119         printValue(cast<CallInst>(V)->getCalledValue(), isL);
120       } else if (isa<InvokeInst>(V)) {
121         errs() << "invoke to ";
122         printValue(cast<InvokeInst>(V)->getCalledValue(), isL);
123       } else {
124         errs() << *V;
125       }
126       return;
127     }
128 
129     unsigned N = contexts.size();
130     while (N > 0) {
131       --N;
132       DiffContext &ctxt = contexts[N];
133       if (!ctxt.IsFunction) continue;
134       if (isL) {
135         if (ctxt.LNumbering.empty())
136           ComputeNumbering(cast<Function>(ctxt.L), ctxt.LNumbering);
137         errs() << '%' << ctxt.LNumbering[V];
138         return;
139       } else {
140         if (ctxt.RNumbering.empty())
141           ComputeNumbering(cast<Function>(ctxt.R), ctxt.RNumbering);
142         errs() << '%' << ctxt.RNumbering[V];
143         return;
144       }
145     }
146 
147     errs() << "<anonymous>";
148   }
149 
150   void header() {
151     if (contexts.empty()) return;
152     for (SmallVectorImpl<DiffContext>::iterator
153            I = contexts.begin(), E = contexts.end(); I != E; ++I) {
154       if (I->Differences) continue;
155       if (isa<Function>(I->L)) {
156         // Extra newline between functions.
157         if (Differences) errs() << "\n";
158 
159         Function *L = cast<Function>(I->L);
160         Function *R = cast<Function>(I->R);
161         if (L->getName() != R->getName())
162           errs() << "in function " << L->getName() << " / " << R->getName() << ":\n";
163         else
164           errs() << "in function " << L->getName() << ":\n";
165       } else if (isa<BasicBlock>(I->L)) {
166         BasicBlock *L = cast<BasicBlock>(I->L);
167         BasicBlock *R = cast<BasicBlock>(I->R);
168         errs() << "  in block ";
169         printValue(L, true);
170         errs() << " / ";
171         printValue(R, false);
172         errs() << ":\n";
173       } else if (isa<Instruction>(I->L)) {
174         errs() << "    in instruction ";
175         printValue(I->L, true);
176         errs() << " / ";
177         printValue(I->R, false);
178         errs() << ":\n";
179       }
180 
181       I->Differences = true;
182     }
183   }
184 
185   void indent() {
186     unsigned N = Indent;
187     while (N--) errs() << ' ';
188   }
189 
190 public:
191   DiffConsumer(Module *L, Module *R)
192     : LModule(L), RModule(R), Differences(false), Indent(0) {}
193 
194   bool hadDifferences() const { return Differences; }
195 
196   void enterContext(Value *L, Value *R) {
197     contexts.push_back(DiffContext(L, R));
198     Indent += 2;
199   }
200   void exitContext() {
201     Differences |= contexts.back().Differences;
202     contexts.pop_back();
203     Indent -= 2;
204   }
205 
206   void log(StringRef text) {
207     header();
208     indent();
209     errs() << text << "\n";
210   }
211 
212   void logf(const DifferenceEngine::LogBuilder &Log) {
213     header();
214     indent();
215 
216     // FIXME: we don't know whether these are l-values or r-values (ha!)
217     // Print them in some saner way!
218     errs() << Log.getFormat() << "\n";
219     for (unsigned I = 0, E = Log.getNumArguments(); I != E; ++I)
220       Log.getArgument(I)->dump();
221   }
222 
223   void logd(const DifferenceEngine::DiffLogBuilder &Log) {
224     header();
225 
226     for (unsigned I = 0, E = Log.getNumLines(); I != E; ++I) {
227       indent();
228       switch (Log.getLineKind(I)) {
229       case DifferenceEngine::DC_match:
230         errs() << "  ";
231         Log.getLeft(I)->dump();
232         //printValue(Log.getLeft(I), true);
233         break;
234       case DifferenceEngine::DC_left:
235         errs() << "< ";
236         Log.getLeft(I)->dump();
237         //printValue(Log.getLeft(I), true);
238         break;
239       case DifferenceEngine::DC_right:
240         errs() << "> ";
241         Log.getRight(I)->dump();
242         //printValue(Log.getRight(I), false);
243         break;
244       }
245       //errs() << "\n";
246     }
247   }
248 
249 };
250 }
251 
252 int main(int argc, const char **argv) {
253   if (argc < 3) return usage();
254 
255   // Don't make StringRef locals like this at home.
256   StringRef LModuleFile = argv[1];
257   StringRef RModuleFile = argv[2];
258 
259   LLVMContext Context;
260 
261   // Load both modules.  Die if that fails.
262   Module *LModule = ReadModule(Context, LModuleFile);
263   Module *RModule = ReadModule(Context, RModuleFile);
264   if (!LModule || !RModule) return 1;
265 
266   DiffConsumer Consumer(LModule, RModule);
267   DifferenceEngine Engine(Context, Consumer);
268 
269   // If any function names were given, just diff those.
270   const char **FnNames = argv + 3;
271   unsigned NumFnNames = argc - 3;
272   if (NumFnNames) {
273     for (unsigned I = 0; I != NumFnNames; ++I) {
274       StringRef FnName = FnNames[I];
275 
276       // Drop leading sigils from the function name.
277       if (FnName.startswith("@")) FnName = FnName.substr(1);
278 
279       Function *LFn = LModule->getFunction(FnName);
280       Function *RFn = RModule->getFunction(FnName);
281       if (LFn && RFn)
282         Engine.diff(LFn, RFn);
283       else {
284         if (!LFn && !RFn)
285           errs() << "No function named @" << FnName << " in either module\n";
286         else if (!LFn)
287           errs() << "No function named @" << FnName << " in left module\n";
288         else
289           errs() << "No function named @" << FnName << " in right module\n";
290       }
291     }
292   } else {
293     // Otherwise, diff all functions in the modules.
294     Engine.diff(LModule, RModule);
295   }
296 
297   delete LModule;
298   delete RModule;
299 
300   return Consumer.hadDifferences();
301 }
302