1 //===-- echo.cpp - tool for testing libLLVM and llvm-c API ----------------===//
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 file implements the --echo command in llvm-c-test.
10 //
11 // This command uses the C API to read a module and output an exact copy of it
12 // as output. It is used to check that the resulting module matches the input
13 // to validate that the C API can read and write modules properly.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "llvm-c-test.h"
18 #include "llvm-c/DebugInfo.h"
19 #include "llvm-c/Target.h"
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/Hashing.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/Support/ErrorHandling.h"
24 
25 #include <stdio.h>
26 #include <stdlib.h>
27 
28 using namespace llvm;
29 
30 // Provide DenseMapInfo for C API opaque types.
31 template<typename T>
32 struct CAPIDenseMap {};
33 
34 // The default DenseMapInfo require to know about pointer alignment.
35 // Because the C API uses opaque pointer types, their alignment is unknown.
36 // As a result, we need to roll out our own implementation.
37 template<typename T>
38 struct CAPIDenseMap<T*> {
39   struct CAPIDenseMapInfo {
40     static inline T* getEmptyKey() {
41       uintptr_t Val = static_cast<uintptr_t>(-1);
42       return reinterpret_cast<T*>(Val);
43     }
44     static inline T* getTombstoneKey() {
45       uintptr_t Val = static_cast<uintptr_t>(-2);
46       return reinterpret_cast<T*>(Val);
47     }
48     static unsigned getHashValue(const T *PtrVal) {
49       return hash_value(PtrVal);
50     }
51     static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
52   };
53 
54   typedef DenseMap<T*, T*, CAPIDenseMapInfo> Map;
55 };
56 
57 typedef CAPIDenseMap<LLVMValueRef>::Map ValueMap;
58 typedef CAPIDenseMap<LLVMBasicBlockRef>::Map BasicBlockMap;
59 
60 struct TypeCloner {
61   LLVMModuleRef M;
62   LLVMContextRef Ctx;
63 
64   TypeCloner(LLVMModuleRef M): M(M), Ctx(LLVMGetModuleContext(M)) {}
65 
66   LLVMTypeRef Clone(LLVMValueRef Src) {
67     return Clone(LLVMTypeOf(Src));
68   }
69 
70   LLVMTypeRef Clone(LLVMTypeRef Src) {
71     LLVMTypeKind Kind = LLVMGetTypeKind(Src);
72     switch (Kind) {
73       case LLVMVoidTypeKind:
74         return LLVMVoidTypeInContext(Ctx);
75       case LLVMHalfTypeKind:
76         return LLVMHalfTypeInContext(Ctx);
77       case LLVMBFloatTypeKind:
78         return LLVMHalfTypeInContext(Ctx);
79       case LLVMFloatTypeKind:
80         return LLVMFloatTypeInContext(Ctx);
81       case LLVMDoubleTypeKind:
82         return LLVMDoubleTypeInContext(Ctx);
83       case LLVMX86_FP80TypeKind:
84         return LLVMX86FP80TypeInContext(Ctx);
85       case LLVMFP128TypeKind:
86         return LLVMFP128TypeInContext(Ctx);
87       case LLVMPPC_FP128TypeKind:
88         return LLVMPPCFP128TypeInContext(Ctx);
89       case LLVMLabelTypeKind:
90         return LLVMLabelTypeInContext(Ctx);
91       case LLVMIntegerTypeKind:
92         return LLVMIntTypeInContext(Ctx, LLVMGetIntTypeWidth(Src));
93       case LLVMFunctionTypeKind: {
94         unsigned ParamCount = LLVMCountParamTypes(Src);
95         LLVMTypeRef* Params = nullptr;
96         if (ParamCount > 0) {
97           Params = static_cast<LLVMTypeRef*>(
98               safe_malloc(ParamCount * sizeof(LLVMTypeRef)));
99           LLVMGetParamTypes(Src, Params);
100           for (unsigned i = 0; i < ParamCount; i++)
101             Params[i] = Clone(Params[i]);
102         }
103 
104         LLVMTypeRef FunTy = LLVMFunctionType(Clone(LLVMGetReturnType(Src)),
105                                              Params, ParamCount,
106                                              LLVMIsFunctionVarArg(Src));
107         if (ParamCount > 0)
108           free(Params);
109         return FunTy;
110       }
111       case LLVMStructTypeKind: {
112         LLVMTypeRef S = nullptr;
113         const char *Name = LLVMGetStructName(Src);
114         if (Name) {
115           S = LLVMGetTypeByName2(Ctx, Name);
116           if (S)
117             return S;
118           S = LLVMStructCreateNamed(Ctx, Name);
119           if (LLVMIsOpaqueStruct(Src))
120             return S;
121         }
122 
123         unsigned EltCount = LLVMCountStructElementTypes(Src);
124         SmallVector<LLVMTypeRef, 8> Elts;
125         for (unsigned i = 0; i < EltCount; i++)
126           Elts.push_back(Clone(LLVMStructGetTypeAtIndex(Src, i)));
127         if (Name)
128           LLVMStructSetBody(S, Elts.data(), EltCount, LLVMIsPackedStruct(Src));
129         else
130           S = LLVMStructTypeInContext(Ctx, Elts.data(), EltCount,
131                                       LLVMIsPackedStruct(Src));
132         return S;
133       }
134       case LLVMArrayTypeKind:
135         return LLVMArrayType(
136           Clone(LLVMGetElementType(Src)),
137           LLVMGetArrayLength(Src)
138         );
139       case LLVMPointerTypeKind:
140         return LLVMPointerType(
141           Clone(LLVMGetElementType(Src)),
142           LLVMGetPointerAddressSpace(Src)
143         );
144       case LLVMVectorTypeKind:
145         return LLVMVectorType(
146           Clone(LLVMGetElementType(Src)),
147           LLVMGetVectorSize(Src)
148         );
149       case LLVMScalableVectorTypeKind:
150         return LLVMScalableVectorType(Clone(LLVMGetElementType(Src)),
151                                       LLVMGetVectorSize(Src));
152       case LLVMMetadataTypeKind:
153         return LLVMMetadataTypeInContext(Ctx);
154       case LLVMX86_AMXTypeKind:
155         return LLVMX86AMXTypeInContext(Ctx);
156       case LLVMX86_MMXTypeKind:
157         return LLVMX86MMXTypeInContext(Ctx);
158       case LLVMTokenTypeKind:
159         return LLVMTokenTypeInContext(Ctx);
160     }
161 
162     fprintf(stderr, "%d is not a supported typekind\n", Kind);
163     exit(-1);
164   }
165 };
166 
167 static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
168   unsigned Count = LLVMCountParams(Src);
169   if (Count != LLVMCountParams(Dst))
170     report_fatal_error("Parameter count mismatch");
171 
172   ValueMap VMap;
173   if (Count == 0)
174     return VMap;
175 
176   LLVMValueRef SrcFirst = LLVMGetFirstParam(Src);
177   LLVMValueRef DstFirst = LLVMGetFirstParam(Dst);
178   LLVMValueRef SrcLast = LLVMGetLastParam(Src);
179   LLVMValueRef DstLast = LLVMGetLastParam(Dst);
180 
181   LLVMValueRef SrcCur = SrcFirst;
182   LLVMValueRef DstCur = DstFirst;
183   LLVMValueRef SrcNext = nullptr;
184   LLVMValueRef DstNext = nullptr;
185   while (true) {
186     size_t NameLen;
187     const char *Name = LLVMGetValueName2(SrcCur, &NameLen);
188     LLVMSetValueName2(DstCur, Name, NameLen);
189 
190     VMap[SrcCur] = DstCur;
191 
192     Count--;
193     SrcNext = LLVMGetNextParam(SrcCur);
194     DstNext = LLVMGetNextParam(DstCur);
195     if (SrcNext == nullptr && DstNext == nullptr) {
196       if (SrcCur != SrcLast)
197         report_fatal_error("SrcLast param does not match End");
198       if (DstCur != DstLast)
199         report_fatal_error("DstLast param does not match End");
200       break;
201     }
202 
203     if (SrcNext == nullptr)
204       report_fatal_error("SrcNext was unexpectedly null");
205     if (DstNext == nullptr)
206       report_fatal_error("DstNext was unexpectedly null");
207 
208     LLVMValueRef SrcPrev = LLVMGetPreviousParam(SrcNext);
209     if (SrcPrev != SrcCur)
210       report_fatal_error("SrcNext.Previous param is not Current");
211 
212     LLVMValueRef DstPrev = LLVMGetPreviousParam(DstNext);
213     if (DstPrev != DstCur)
214       report_fatal_error("DstNext.Previous param is not Current");
215 
216     SrcCur = SrcNext;
217     DstCur = DstNext;
218   }
219 
220   if (Count != 0)
221     report_fatal_error("Parameter count does not match iteration");
222 
223   return VMap;
224 }
225 
226 static void check_value_kind(LLVMValueRef V, LLVMValueKind K) {
227   if (LLVMGetValueKind(V) != K)
228     report_fatal_error("LLVMGetValueKind returned incorrect type");
229 }
230 
231 static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M);
232 
233 static LLVMValueRef clone_constant(LLVMValueRef Cst, LLVMModuleRef M) {
234   LLVMValueRef Ret = clone_constant_impl(Cst, M);
235   check_value_kind(Ret, LLVMGetValueKind(Cst));
236   return Ret;
237 }
238 
239 static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M) {
240   if (!LLVMIsAConstant(Cst))
241     report_fatal_error("Expected a constant");
242 
243   // Maybe it is a symbol
244   if (LLVMIsAGlobalValue(Cst)) {
245     size_t NameLen;
246     const char *Name = LLVMGetValueName2(Cst, &NameLen);
247 
248     // Try function
249     if (LLVMIsAFunction(Cst)) {
250       check_value_kind(Cst, LLVMFunctionValueKind);
251 
252       LLVMValueRef Dst = nullptr;
253       // Try an intrinsic
254       unsigned ID = LLVMGetIntrinsicID(Cst);
255       if (ID > 0 && !LLVMIntrinsicIsOverloaded(ID)) {
256         Dst = LLVMGetIntrinsicDeclaration(M, ID, nullptr, 0);
257       } else {
258         // Try a normal function
259         Dst = LLVMGetNamedFunction(M, Name);
260       }
261 
262       if (Dst)
263         return Dst;
264       report_fatal_error("Could not find function");
265     }
266 
267     // Try global variable
268     if (LLVMIsAGlobalVariable(Cst)) {
269       check_value_kind(Cst, LLVMGlobalVariableValueKind);
270       LLVMValueRef Dst = LLVMGetNamedGlobal(M, Name);
271       if (Dst)
272         return Dst;
273       report_fatal_error("Could not find variable");
274     }
275 
276     // Try global alias
277     if (LLVMIsAGlobalAlias(Cst)) {
278       check_value_kind(Cst, LLVMGlobalAliasValueKind);
279       LLVMValueRef Dst = LLVMGetNamedGlobalAlias(M, Name, NameLen);
280       if (Dst)
281         return Dst;
282       report_fatal_error("Could not find alias");
283     }
284 
285     fprintf(stderr, "Could not find @%s\n", Name);
286     exit(-1);
287   }
288 
289   // Try integer literal
290   if (LLVMIsAConstantInt(Cst)) {
291     check_value_kind(Cst, LLVMConstantIntValueKind);
292     return LLVMConstInt(TypeCloner(M).Clone(Cst),
293                         LLVMConstIntGetZExtValue(Cst), false);
294   }
295 
296   // Try zeroinitializer
297   if (LLVMIsAConstantAggregateZero(Cst)) {
298     check_value_kind(Cst, LLVMConstantAggregateZeroValueKind);
299     return LLVMConstNull(TypeCloner(M).Clone(Cst));
300   }
301 
302   // Try constant array
303   if (LLVMIsAConstantArray(Cst)) {
304     check_value_kind(Cst, LLVMConstantArrayValueKind);
305     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
306     unsigned EltCount = LLVMGetArrayLength(Ty);
307     SmallVector<LLVMValueRef, 8> Elts;
308     for (unsigned i = 0; i < EltCount; i++)
309       Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
310     return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
311   }
312 
313   // Try constant data array
314   if (LLVMIsAConstantDataArray(Cst)) {
315     check_value_kind(Cst, LLVMConstantDataArrayValueKind);
316     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
317     unsigned EltCount = LLVMGetArrayLength(Ty);
318     SmallVector<LLVMValueRef, 8> Elts;
319     for (unsigned i = 0; i < EltCount; i++)
320       Elts.push_back(clone_constant(LLVMGetElementAsConstant(Cst, i), M));
321     return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
322   }
323 
324   // Try constant struct
325   if (LLVMIsAConstantStruct(Cst)) {
326     check_value_kind(Cst, LLVMConstantStructValueKind);
327     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
328     unsigned EltCount = LLVMCountStructElementTypes(Ty);
329     SmallVector<LLVMValueRef, 8> Elts;
330     for (unsigned i = 0; i < EltCount; i++)
331       Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
332     if (LLVMGetStructName(Ty))
333       return LLVMConstNamedStruct(Ty, Elts.data(), EltCount);
334     return LLVMConstStructInContext(LLVMGetModuleContext(M), Elts.data(),
335                                     EltCount, LLVMIsPackedStruct(Ty));
336   }
337 
338   // Try ConstantPointerNull
339   if (LLVMIsAConstantPointerNull(Cst)) {
340     check_value_kind(Cst, LLVMConstantPointerNullValueKind);
341     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
342     return LLVMConstNull(Ty);
343   }
344 
345   // Try undef
346   if (LLVMIsUndef(Cst)) {
347     check_value_kind(Cst, LLVMUndefValueValueKind);
348     return LLVMGetUndef(TypeCloner(M).Clone(Cst));
349   }
350 
351   // Try poison
352   if (LLVMIsPoison(Cst)) {
353     check_value_kind(Cst, LLVMPoisonValueValueKind);
354     return LLVMGetPoison(TypeCloner(M).Clone(Cst));
355   }
356 
357   // Try null
358   if (LLVMIsNull(Cst)) {
359     check_value_kind(Cst, LLVMConstantTokenNoneValueKind);
360     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
361     return LLVMConstNull(Ty);
362   }
363 
364   // Try float literal
365   if (LLVMIsAConstantFP(Cst)) {
366     check_value_kind(Cst, LLVMConstantFPValueKind);
367     report_fatal_error("ConstantFP is not supported");
368   }
369 
370   // Try ConstantVector
371   if (LLVMIsAConstantVector(Cst)) {
372     check_value_kind(Cst, LLVMConstantVectorValueKind);
373     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
374     unsigned EltCount = LLVMGetVectorSize(Ty);
375     SmallVector<LLVMValueRef, 8> Elts;
376     for (unsigned i = 0; i < EltCount; i++)
377       Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
378     return LLVMConstVector(Elts.data(), EltCount);
379   }
380 
381   // Try ConstantDataVector
382   if (LLVMIsAConstantDataVector(Cst)) {
383     check_value_kind(Cst, LLVMConstantDataVectorValueKind);
384     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
385     unsigned EltCount = LLVMGetVectorSize(Ty);
386     SmallVector<LLVMValueRef, 8> Elts;
387     for (unsigned i = 0; i < EltCount; i++)
388       Elts.push_back(clone_constant(LLVMGetElementAsConstant(Cst, i), M));
389     return LLVMConstVector(Elts.data(), EltCount);
390   }
391 
392   // At this point, if it's not a constant expression, it's a kind of constant
393   // which is not supported
394   if (!LLVMIsAConstantExpr(Cst))
395     report_fatal_error("Unsupported constant kind");
396 
397   // At this point, it must be a constant expression
398   check_value_kind(Cst, LLVMConstantExprValueKind);
399 
400   LLVMOpcode Op = LLVMGetConstOpcode(Cst);
401   switch(Op) {
402     case LLVMBitCast:
403       return LLVMConstBitCast(clone_constant(LLVMGetOperand(Cst, 0), M),
404                               TypeCloner(M).Clone(Cst));
405     default:
406       fprintf(stderr, "%d is not a supported opcode for constant expressions\n",
407               Op);
408       exit(-1);
409   }
410 }
411 
412 struct FunCloner {
413   LLVMValueRef Fun;
414   LLVMModuleRef M;
415 
416   ValueMap VMap;
417   BasicBlockMap BBMap;
418 
419   FunCloner(LLVMValueRef Src, LLVMValueRef Dst): Fun(Dst),
420     M(LLVMGetGlobalParent(Fun)), VMap(clone_params(Src, Dst)) {}
421 
422   LLVMTypeRef CloneType(LLVMTypeRef Src) {
423     return TypeCloner(M).Clone(Src);
424   }
425 
426   LLVMTypeRef CloneType(LLVMValueRef Src) {
427     return TypeCloner(M).Clone(Src);
428   }
429 
430   // Try to clone everything in the llvm::Value hierarchy.
431   LLVMValueRef CloneValue(LLVMValueRef Src) {
432     // First, the value may be constant.
433     if (LLVMIsAConstant(Src))
434       return clone_constant(Src, M);
435 
436     // Function argument should always be in the map already.
437     auto i = VMap.find(Src);
438     if (i != VMap.end())
439       return i->second;
440 
441     if (!LLVMIsAInstruction(Src))
442       report_fatal_error("Expected an instruction");
443 
444     auto Ctx = LLVMGetModuleContext(M);
445     auto Builder = LLVMCreateBuilderInContext(Ctx);
446     auto BB = DeclareBB(LLVMGetInstructionParent(Src));
447     LLVMPositionBuilderAtEnd(Builder, BB);
448     auto Dst = CloneInstruction(Src, Builder);
449     LLVMDisposeBuilder(Builder);
450     return Dst;
451   }
452 
453   void CloneAttrs(LLVMValueRef Src, LLVMValueRef Dst) {
454     auto Ctx = LLVMGetModuleContext(M);
455     int ArgCount = LLVMGetNumArgOperands(Src);
456     for (int i = LLVMAttributeReturnIndex; i <= ArgCount; i++) {
457       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
458         if (auto SrcA = LLVMGetCallSiteEnumAttribute(Src, i, k)) {
459           auto Val = LLVMGetEnumAttributeValue(SrcA);
460           auto A = LLVMCreateEnumAttribute(Ctx, k, Val);
461           LLVMAddCallSiteAttribute(Dst, i, A);
462         }
463       }
464     }
465   }
466 
467   LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
468     check_value_kind(Src, LLVMInstructionValueKind);
469     if (!LLVMIsAInstruction(Src))
470       report_fatal_error("Expected an instruction");
471 
472     size_t NameLen;
473     const char *Name = LLVMGetValueName2(Src, &NameLen);
474 
475     // Check if this is something we already computed.
476     {
477       auto i = VMap.find(Src);
478       if (i != VMap.end()) {
479         // If we have a hit, it means we already generated the instruction
480         // as a dependency to something else. We need to make sure
481         // it is ordered properly.
482         auto I = i->second;
483         LLVMInstructionRemoveFromParent(I);
484         LLVMInsertIntoBuilderWithName(Builder, I, Name);
485         return I;
486       }
487     }
488 
489     // We tried everything, it must be an instruction
490     // that hasn't been generated already.
491     LLVMValueRef Dst = nullptr;
492 
493     LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
494     switch(Op) {
495       case LLVMRet: {
496         int OpCount = LLVMGetNumOperands(Src);
497         if (OpCount == 0)
498           Dst = LLVMBuildRetVoid(Builder);
499         else
500           Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0)));
501         break;
502       }
503       case LLVMBr: {
504         if (!LLVMIsConditional(Src)) {
505           LLVMValueRef SrcOp = LLVMGetOperand(Src, 0);
506           LLVMBasicBlockRef SrcBB = LLVMValueAsBasicBlock(SrcOp);
507           Dst = LLVMBuildBr(Builder, DeclareBB(SrcBB));
508           break;
509         }
510 
511         LLVMValueRef Cond = LLVMGetCondition(Src);
512         LLVMValueRef Else = LLVMGetOperand(Src, 1);
513         LLVMBasicBlockRef ElseBB = DeclareBB(LLVMValueAsBasicBlock(Else));
514         LLVMValueRef Then = LLVMGetOperand(Src, 2);
515         LLVMBasicBlockRef ThenBB = DeclareBB(LLVMValueAsBasicBlock(Then));
516         Dst = LLVMBuildCondBr(Builder, CloneValue(Cond), ThenBB, ElseBB);
517         break;
518       }
519       case LLVMSwitch:
520       case LLVMIndirectBr:
521         break;
522       case LLVMInvoke: {
523         SmallVector<LLVMValueRef, 8> Args;
524         int ArgCount = LLVMGetNumArgOperands(Src);
525         for (int i = 0; i < ArgCount; i++)
526           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
527         LLVMTypeRef FnTy = CloneType(LLVMGetCalledFunctionType(Src));
528         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
529         LLVMBasicBlockRef Then = DeclareBB(LLVMGetNormalDest(Src));
530         LLVMBasicBlockRef Unwind = DeclareBB(LLVMGetUnwindDest(Src));
531         Dst = LLVMBuildInvoke2(Builder, FnTy, Fn, Args.data(), ArgCount,
532                                Then, Unwind, Name);
533         CloneAttrs(Src, Dst);
534         break;
535       }
536       case LLVMUnreachable:
537         Dst = LLVMBuildUnreachable(Builder);
538         break;
539       case LLVMAdd: {
540         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
541         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
542         Dst = LLVMBuildAdd(Builder, LHS, RHS, Name);
543         break;
544       }
545       case LLVMSub: {
546         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
547         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
548         Dst = LLVMBuildSub(Builder, LHS, RHS, Name);
549         break;
550       }
551       case LLVMMul: {
552         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
553         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
554         Dst = LLVMBuildMul(Builder, LHS, RHS, Name);
555         break;
556       }
557       case LLVMUDiv: {
558         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
559         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
560         Dst = LLVMBuildUDiv(Builder, LHS, RHS, Name);
561         break;
562       }
563       case LLVMSDiv: {
564         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
565         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
566         Dst = LLVMBuildSDiv(Builder, LHS, RHS, Name);
567         break;
568       }
569       case LLVMURem: {
570         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
571         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
572         Dst = LLVMBuildURem(Builder, LHS, RHS, Name);
573         break;
574       }
575       case LLVMSRem: {
576         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
577         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
578         Dst = LLVMBuildSRem(Builder, LHS, RHS, Name);
579         break;
580       }
581       case LLVMShl: {
582         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
583         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
584         Dst = LLVMBuildShl(Builder, LHS, RHS, Name);
585         break;
586       }
587       case LLVMLShr: {
588         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
589         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
590         Dst = LLVMBuildLShr(Builder, LHS, RHS, Name);
591         break;
592       }
593       case LLVMAShr: {
594         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
595         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
596         Dst = LLVMBuildAShr(Builder, LHS, RHS, Name);
597         break;
598       }
599       case LLVMAnd: {
600         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
601         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
602         Dst = LLVMBuildAnd(Builder, LHS, RHS, Name);
603         break;
604       }
605       case LLVMOr: {
606         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
607         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
608         Dst = LLVMBuildOr(Builder, LHS, RHS, Name);
609         break;
610       }
611       case LLVMXor: {
612         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
613         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
614         Dst = LLVMBuildXor(Builder, LHS, RHS, Name);
615         break;
616       }
617       case LLVMAlloca: {
618         LLVMTypeRef Ty = CloneType(LLVMGetAllocatedType(Src));
619         Dst = LLVMBuildAlloca(Builder, Ty, Name);
620         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
621         break;
622       }
623       case LLVMLoad: {
624         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
625         Dst = LLVMBuildLoad2(Builder, CloneType(Src), Ptr, Name);
626         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
627         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
628         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
629         break;
630       }
631       case LLVMStore: {
632         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
633         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 1));
634         Dst = LLVMBuildStore(Builder, Val, Ptr);
635         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
636         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
637         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
638         break;
639       }
640       case LLVMGetElementPtr: {
641         LLVMTypeRef ElemTy = CloneType(LLVMGetGEPSourceElementType(Src));
642         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
643         SmallVector<LLVMValueRef, 8> Idx;
644         int NumIdx = LLVMGetNumIndices(Src);
645         for (int i = 1; i <= NumIdx; i++)
646           Idx.push_back(CloneValue(LLVMGetOperand(Src, i)));
647         if (LLVMIsInBounds(Src))
648           Dst = LLVMBuildInBoundsGEP2(Builder, ElemTy, Ptr, Idx.data(), NumIdx,
649                                       Name);
650         else
651           Dst = LLVMBuildGEP2(Builder, ElemTy, Ptr, Idx.data(), NumIdx, Name);
652         break;
653       }
654       case LLVMAtomicRMW: {
655         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
656         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 1));
657         LLVMAtomicRMWBinOp BinOp = LLVMGetAtomicRMWBinOp(Src);
658         LLVMAtomicOrdering Ord = LLVMGetOrdering(Src);
659         LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
660         Dst = LLVMBuildAtomicRMW(Builder, BinOp, Ptr, Val, Ord, SingleThread);
661         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
662         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
663         LLVMSetValueName2(Dst, Name, NameLen);
664         break;
665       }
666       case LLVMAtomicCmpXchg: {
667         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
668         LLVMValueRef Cmp = CloneValue(LLVMGetOperand(Src, 1));
669         LLVMValueRef New = CloneValue(LLVMGetOperand(Src, 2));
670         LLVMAtomicOrdering Succ = LLVMGetCmpXchgSuccessOrdering(Src);
671         LLVMAtomicOrdering Fail = LLVMGetCmpXchgFailureOrdering(Src);
672         LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
673 
674         Dst = LLVMBuildAtomicCmpXchg(Builder, Ptr, Cmp, New, Succ, Fail,
675                                      SingleThread);
676         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
677         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
678         LLVMSetWeak(Dst, LLVMGetWeak(Src));
679         LLVMSetValueName2(Dst, Name, NameLen);
680         break;
681       }
682       case LLVMBitCast: {
683         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 0));
684         Dst = LLVMBuildBitCast(Builder, V, CloneType(Src), Name);
685         break;
686       }
687       case LLVMICmp: {
688         LLVMIntPredicate Pred = LLVMGetICmpPredicate(Src);
689         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
690         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
691         Dst = LLVMBuildICmp(Builder, Pred, LHS, RHS, Name);
692         break;
693       }
694       case LLVMPHI: {
695         // We need to aggressively set things here because of loops.
696         VMap[Src] = Dst = LLVMBuildPhi(Builder, CloneType(Src), Name);
697 
698         SmallVector<LLVMValueRef, 8> Values;
699         SmallVector<LLVMBasicBlockRef, 8> Blocks;
700 
701         unsigned IncomingCount = LLVMCountIncoming(Src);
702         for (unsigned i = 0; i < IncomingCount; ++i) {
703           Blocks.push_back(DeclareBB(LLVMGetIncomingBlock(Src, i)));
704           Values.push_back(CloneValue(LLVMGetIncomingValue(Src, i)));
705         }
706 
707         LLVMAddIncoming(Dst, Values.data(), Blocks.data(), IncomingCount);
708         return Dst;
709       }
710       case LLVMCall: {
711         SmallVector<LLVMValueRef, 8> Args;
712         int ArgCount = LLVMGetNumArgOperands(Src);
713         for (int i = 0; i < ArgCount; i++)
714           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
715         LLVMTypeRef FnTy = CloneType(LLVMGetCalledFunctionType(Src));
716         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
717         Dst = LLVMBuildCall2(Builder, FnTy, Fn, Args.data(), ArgCount, Name);
718         LLVMSetTailCall(Dst, LLVMIsTailCall(Src));
719         CloneAttrs(Src, Dst);
720         break;
721       }
722       case LLVMResume: {
723         Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
724         break;
725       }
726       case LLVMLandingPad: {
727         // The landing pad API is a bit screwed up for historical reasons.
728         Dst = LLVMBuildLandingPad(Builder, CloneType(Src), nullptr, 0, Name);
729         unsigned NumClauses = LLVMGetNumClauses(Src);
730         for (unsigned i = 0; i < NumClauses; ++i)
731           LLVMAddClause(Dst, CloneValue(LLVMGetClause(Src, i)));
732         LLVMSetCleanup(Dst, LLVMIsCleanup(Src));
733         break;
734       }
735       case LLVMCleanupRet: {
736         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
737         LLVMBasicBlockRef Unwind = nullptr;
738         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src))
739           Unwind = DeclareBB(UDest);
740         Dst = LLVMBuildCleanupRet(Builder, CatchPad, Unwind);
741         break;
742       }
743       case LLVMCatchRet: {
744         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
745         LLVMBasicBlockRef SuccBB = DeclareBB(LLVMGetSuccessor(Src, 0));
746         Dst = LLVMBuildCatchRet(Builder, CatchPad, SuccBB);
747         break;
748       }
749       case LLVMCatchPad: {
750         LLVMValueRef ParentPad = CloneValue(LLVMGetParentCatchSwitch(Src));
751         SmallVector<LLVMValueRef, 8> Args;
752         int ArgCount = LLVMGetNumArgOperands(Src);
753         for (int i = 0; i < ArgCount; i++)
754           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
755         Dst = LLVMBuildCatchPad(Builder, ParentPad,
756                                 Args.data(), ArgCount, Name);
757         break;
758       }
759       case LLVMCleanupPad: {
760         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
761         SmallVector<LLVMValueRef, 8> Args;
762         int ArgCount = LLVMGetNumArgOperands(Src);
763         for (int i = 0; i < ArgCount; i++)
764           Args.push_back(CloneValue(LLVMGetArgOperand(Src, i)));
765         Dst = LLVMBuildCleanupPad(Builder, ParentPad,
766                                   Args.data(), ArgCount, Name);
767         break;
768       }
769       case LLVMCatchSwitch: {
770         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
771         LLVMBasicBlockRef UnwindBB = nullptr;
772         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src)) {
773           UnwindBB = DeclareBB(UDest);
774         }
775         unsigned NumHandlers = LLVMGetNumHandlers(Src);
776         Dst = LLVMBuildCatchSwitch(Builder, ParentPad, UnwindBB, NumHandlers, Name);
777         if (NumHandlers > 0) {
778           LLVMBasicBlockRef *Handlers = static_cast<LLVMBasicBlockRef*>(
779                        safe_malloc(NumHandlers * sizeof(LLVMBasicBlockRef)));
780           LLVMGetHandlers(Src, Handlers);
781           for (unsigned i = 0; i < NumHandlers; i++)
782             LLVMAddHandler(Dst, DeclareBB(Handlers[i]));
783           free(Handlers);
784         }
785         break;
786       }
787       case LLVMExtractValue: {
788         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
789         if (LLVMGetNumIndices(Src) > 1)
790           report_fatal_error("ExtractValue: Expected only one index");
791         else if (LLVMGetNumIndices(Src) < 1)
792           report_fatal_error("ExtractValue: Expected an index");
793         auto I = LLVMGetIndices(Src)[0];
794         Dst = LLVMBuildExtractValue(Builder, Agg, I, Name);
795         break;
796       }
797       case LLVMInsertValue: {
798         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
799         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
800         if (LLVMGetNumIndices(Src) > 1)
801           report_fatal_error("InsertValue: Expected only one index");
802         else if (LLVMGetNumIndices(Src) < 1)
803           report_fatal_error("InsertValue: Expected an index");
804         auto I = LLVMGetIndices(Src)[0];
805         Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
806         break;
807       }
808       case LLVMExtractElement: {
809         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
810         LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 1));
811         Dst = LLVMBuildExtractElement(Builder, Agg, Index, Name);
812         break;
813       }
814       case LLVMInsertElement: {
815         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
816         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
817         LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 2));
818         Dst = LLVMBuildInsertElement(Builder, Agg, V, Index, Name);
819         break;
820       }
821       case LLVMShuffleVector: {
822         LLVMValueRef Agg0 = CloneValue(LLVMGetOperand(Src, 0));
823         LLVMValueRef Agg1 = CloneValue(LLVMGetOperand(Src, 1));
824         SmallVector<LLVMValueRef, 8> MaskElts;
825         unsigned NumMaskElts = LLVMGetNumMaskElements(Src);
826         for (unsigned i = 0; i < NumMaskElts; i++) {
827           int Val = LLVMGetMaskValue(Src, i);
828           if (Val == LLVMGetUndefMaskElem()) {
829             MaskElts.push_back(LLVMGetUndef(LLVMInt64Type()));
830           } else {
831             MaskElts.push_back(LLVMConstInt(LLVMInt64Type(), Val, true));
832           }
833         }
834         LLVMValueRef Mask = LLVMConstVector(MaskElts.data(), NumMaskElts);
835         Dst = LLVMBuildShuffleVector(Builder, Agg0, Agg1, Mask, Name);
836         break;
837       }
838       case LLVMFreeze: {
839         LLVMValueRef Arg = CloneValue(LLVMGetOperand(Src, 0));
840         Dst = LLVMBuildFreeze(Builder, Arg, Name);
841         break;
842       }
843       default:
844         break;
845     }
846 
847     if (Dst == nullptr) {
848       fprintf(stderr, "%d is not a supported opcode\n", Op);
849       exit(-1);
850     }
851 
852     auto Ctx = LLVMGetModuleContext(M);
853     size_t NumMetadataEntries;
854     auto *AllMetadata =
855         LLVMInstructionGetAllMetadataOtherThanDebugLoc(Src,
856                                                        &NumMetadataEntries);
857     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
858       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
859       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
860       LLVMSetMetadata(Dst, Kind, LLVMMetadataAsValue(Ctx, MD));
861     }
862     LLVMDisposeValueMetadataEntries(AllMetadata);
863     LLVMAddMetadataToInst(Builder, Dst);
864 
865     check_value_kind(Dst, LLVMInstructionValueKind);
866     return VMap[Src] = Dst;
867   }
868 
869   LLVMBasicBlockRef DeclareBB(LLVMBasicBlockRef Src) {
870     // Check if this is something we already computed.
871     {
872       auto i = BBMap.find(Src);
873       if (i != BBMap.end()) {
874         return i->second;
875       }
876     }
877 
878     LLVMValueRef V = LLVMBasicBlockAsValue(Src);
879     if (!LLVMValueIsBasicBlock(V) || LLVMValueAsBasicBlock(V) != Src)
880       report_fatal_error("Basic block is not a basic block");
881 
882     const char *Name = LLVMGetBasicBlockName(Src);
883     size_t NameLen;
884     const char *VName = LLVMGetValueName2(V, &NameLen);
885     if (Name != VName)
886       report_fatal_error("Basic block name mismatch");
887 
888     LLVMBasicBlockRef BB = LLVMAppendBasicBlock(Fun, Name);
889     return BBMap[Src] = BB;
890   }
891 
892   LLVMBasicBlockRef CloneBB(LLVMBasicBlockRef Src) {
893     LLVMBasicBlockRef BB = DeclareBB(Src);
894 
895     // Make sure ordering is correct.
896     LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Src);
897     if (Prev)
898       LLVMMoveBasicBlockAfter(BB, DeclareBB(Prev));
899 
900     LLVMValueRef First = LLVMGetFirstInstruction(Src);
901     LLVMValueRef Last = LLVMGetLastInstruction(Src);
902 
903     if (First == nullptr) {
904       if (Last != nullptr)
905         report_fatal_error("Has no first instruction, but last one");
906       return BB;
907     }
908 
909     auto Ctx = LLVMGetModuleContext(M);
910     LLVMBuilderRef Builder = LLVMCreateBuilderInContext(Ctx);
911     LLVMPositionBuilderAtEnd(Builder, BB);
912 
913     LLVMValueRef Cur = First;
914     LLVMValueRef Next = nullptr;
915     while(true) {
916       CloneInstruction(Cur, Builder);
917       Next = LLVMGetNextInstruction(Cur);
918       if (Next == nullptr) {
919         if (Cur != Last)
920           report_fatal_error("Final instruction does not match Last");
921         break;
922       }
923 
924       LLVMValueRef Prev = LLVMGetPreviousInstruction(Next);
925       if (Prev != Cur)
926         report_fatal_error("Next.Previous instruction is not Current");
927 
928       Cur = Next;
929     }
930 
931     LLVMDisposeBuilder(Builder);
932     return BB;
933   }
934 
935   void CloneBBs(LLVMValueRef Src) {
936     unsigned Count = LLVMCountBasicBlocks(Src);
937     if (Count == 0)
938       return;
939 
940     LLVMBasicBlockRef First = LLVMGetFirstBasicBlock(Src);
941     LLVMBasicBlockRef Last = LLVMGetLastBasicBlock(Src);
942 
943     LLVMBasicBlockRef Cur = First;
944     LLVMBasicBlockRef Next = nullptr;
945     while(true) {
946       CloneBB(Cur);
947       Count--;
948       Next = LLVMGetNextBasicBlock(Cur);
949       if (Next == nullptr) {
950         if (Cur != Last)
951           report_fatal_error("Final basic block does not match Last");
952         break;
953       }
954 
955       LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Next);
956       if (Prev != Cur)
957         report_fatal_error("Next.Previous basic bloc is not Current");
958 
959       Cur = Next;
960     }
961 
962     if (Count != 0)
963       report_fatal_error("Basic block count does not match iterration");
964   }
965 };
966 
967 static void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
968   auto Ctx = LLVMGetModuleContext(M);
969 
970   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
971   LLVMValueRef End = LLVMGetLastGlobal(Src);
972 
973   LLVMValueRef Cur = Begin;
974   LLVMValueRef Next = nullptr;
975   if (!Begin) {
976     if (End != nullptr)
977       report_fatal_error("Range has an end but no beginning");
978     goto FunDecl;
979   }
980 
981   while (true) {
982     size_t NameLen;
983     const char *Name = LLVMGetValueName2(Cur, &NameLen);
984     if (LLVMGetNamedGlobal(M, Name))
985       report_fatal_error("GlobalVariable already cloned");
986     LLVMAddGlobal(M, LLVMGetElementType(TypeCloner(M).Clone(Cur)), Name);
987 
988     Next = LLVMGetNextGlobal(Cur);
989     if (Next == nullptr) {
990       if (Cur != End)
991         report_fatal_error("");
992       break;
993     }
994 
995     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
996     if (Prev != Cur)
997       report_fatal_error("Next.Previous global is not Current");
998 
999     Cur = Next;
1000   }
1001 
1002 FunDecl:
1003   Begin = LLVMGetFirstFunction(Src);
1004   End = LLVMGetLastFunction(Src);
1005   if (!Begin) {
1006     if (End != nullptr)
1007       report_fatal_error("Range has an end but no beginning");
1008     goto AliasDecl;
1009   }
1010 
1011   Cur = Begin;
1012   Next = nullptr;
1013   while (true) {
1014     size_t NameLen;
1015     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1016     if (LLVMGetNamedFunction(M, Name))
1017       report_fatal_error("Function already cloned");
1018     auto Ty = LLVMGetElementType(TypeCloner(M).Clone(Cur));
1019     auto F = LLVMAddFunction(M, Name, Ty);
1020 
1021     // Copy attributes
1022     for (int i = LLVMAttributeFunctionIndex, c = LLVMCountParams(F);
1023          i <= c; ++i) {
1024       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
1025         if (auto SrcA = LLVMGetEnumAttributeAtIndex(Cur, i, k)) {
1026           auto Val = LLVMGetEnumAttributeValue(SrcA);
1027           auto DstA = LLVMCreateEnumAttribute(Ctx, k, Val);
1028           LLVMAddAttributeAtIndex(F, i, DstA);
1029         }
1030       }
1031     }
1032 
1033     Next = LLVMGetNextFunction(Cur);
1034     if (Next == nullptr) {
1035       if (Cur != End)
1036         report_fatal_error("Last function does not match End");
1037       break;
1038     }
1039 
1040     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1041     if (Prev != Cur)
1042       report_fatal_error("Next.Previous function is not Current");
1043 
1044     Cur = Next;
1045   }
1046 
1047 AliasDecl:
1048   Begin = LLVMGetFirstGlobalAlias(Src);
1049   End = LLVMGetLastGlobalAlias(Src);
1050   if (!Begin) {
1051     if (End != nullptr)
1052       report_fatal_error("Range has an end but no beginning");
1053     goto GlobalIFuncDecl;
1054   }
1055 
1056   Cur = Begin;
1057   Next = nullptr;
1058   while (true) {
1059     size_t NameLen;
1060     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1061     if (LLVMGetNamedGlobalAlias(M, Name, NameLen))
1062       report_fatal_error("Global alias already cloned");
1063     LLVMTypeRef PtrType = TypeCloner(M).Clone(Cur);
1064     LLVMTypeRef ValType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1065     unsigned AddrSpace = LLVMGetPointerAddressSpace(PtrType);
1066     // FIXME: Allow NULL aliasee.
1067     LLVMAddAlias2(M, ValType, AddrSpace, LLVMGetUndef(PtrType), Name);
1068 
1069     Next = LLVMGetNextGlobalAlias(Cur);
1070     if (Next == nullptr) {
1071       if (Cur != End)
1072         report_fatal_error("");
1073       break;
1074     }
1075 
1076     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1077     if (Prev != Cur)
1078       report_fatal_error("Next.Previous global is not Current");
1079 
1080     Cur = Next;
1081   }
1082 
1083 GlobalIFuncDecl:
1084   Begin = LLVMGetFirstGlobalIFunc(Src);
1085   End = LLVMGetLastGlobalIFunc(Src);
1086   if (!Begin) {
1087     if (End != nullptr)
1088       report_fatal_error("Range has an end but no beginning");
1089     goto NamedMDDecl;
1090   }
1091 
1092   Cur = Begin;
1093   Next = nullptr;
1094   while (true) {
1095     size_t NameLen;
1096     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1097     if (LLVMGetNamedGlobalIFunc(M, Name, NameLen))
1098       report_fatal_error("Global ifunc already cloned");
1099     LLVMTypeRef CurType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1100     // FIXME: Allow NULL resolver.
1101     LLVMAddGlobalIFunc(M, Name, NameLen,
1102                        CurType, /*addressSpace*/ 0, LLVMGetUndef(CurType));
1103 
1104     Next = LLVMGetNextGlobalIFunc(Cur);
1105     if (Next == nullptr) {
1106       if (Cur != End)
1107         report_fatal_error("");
1108       break;
1109     }
1110 
1111     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1112     if (Prev != Cur)
1113       report_fatal_error("Next.Previous global is not Current");
1114 
1115     Cur = Next;
1116   }
1117 
1118 NamedMDDecl:
1119   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1120   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1121   if (!BeginMD) {
1122     if (EndMD != nullptr)
1123       report_fatal_error("Range has an end but no beginning");
1124     return;
1125   }
1126 
1127   LLVMNamedMDNodeRef CurMD = BeginMD;
1128   LLVMNamedMDNodeRef NextMD = nullptr;
1129   while (true) {
1130     size_t NameLen;
1131     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1132     if (LLVMGetNamedMetadata(M, Name, NameLen))
1133       report_fatal_error("Named Metadata Node already cloned");
1134     LLVMGetOrInsertNamedMetadata(M, Name, NameLen);
1135 
1136     NextMD = LLVMGetNextNamedMetadata(CurMD);
1137     if (NextMD == nullptr) {
1138       if (CurMD != EndMD)
1139         report_fatal_error("");
1140       break;
1141     }
1142 
1143     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1144     if (PrevMD != CurMD)
1145       report_fatal_error("Next.Previous global is not Current");
1146 
1147     CurMD = NextMD;
1148   }
1149 }
1150 
1151 static void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
1152   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
1153   LLVMValueRef End = LLVMGetLastGlobal(Src);
1154 
1155   LLVMValueRef Cur = Begin;
1156   LLVMValueRef Next = nullptr;
1157   if (!Begin) {
1158     if (End != nullptr)
1159       report_fatal_error("Range has an end but no beginning");
1160     goto FunClone;
1161   }
1162 
1163   while (true) {
1164     size_t NameLen;
1165     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1166     LLVMValueRef G = LLVMGetNamedGlobal(M, Name);
1167     if (!G)
1168       report_fatal_error("GlobalVariable must have been declared already");
1169 
1170     if (auto I = LLVMGetInitializer(Cur))
1171       LLVMSetInitializer(G, clone_constant(I, M));
1172 
1173     size_t NumMetadataEntries;
1174     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1175     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1176       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1177       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1178       LLVMGlobalSetMetadata(G, Kind, MD);
1179     }
1180     LLVMDisposeValueMetadataEntries(AllMetadata);
1181 
1182     LLVMSetGlobalConstant(G, LLVMIsGlobalConstant(Cur));
1183     LLVMSetThreadLocal(G, LLVMIsThreadLocal(Cur));
1184     LLVMSetExternallyInitialized(G, LLVMIsExternallyInitialized(Cur));
1185     LLVMSetLinkage(G, LLVMGetLinkage(Cur));
1186     LLVMSetSection(G, LLVMGetSection(Cur));
1187     LLVMSetVisibility(G, LLVMGetVisibility(Cur));
1188     LLVMSetUnnamedAddress(G, LLVMGetUnnamedAddress(Cur));
1189     LLVMSetAlignment(G, LLVMGetAlignment(Cur));
1190 
1191     Next = LLVMGetNextGlobal(Cur);
1192     if (Next == nullptr) {
1193       if (Cur != End)
1194         report_fatal_error("");
1195       break;
1196     }
1197 
1198     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
1199     if (Prev != Cur)
1200       report_fatal_error("Next.Previous global is not Current");
1201 
1202     Cur = Next;
1203   }
1204 
1205 FunClone:
1206   Begin = LLVMGetFirstFunction(Src);
1207   End = LLVMGetLastFunction(Src);
1208   if (!Begin) {
1209     if (End != nullptr)
1210       report_fatal_error("Range has an end but no beginning");
1211     goto AliasClone;
1212   }
1213 
1214   Cur = Begin;
1215   Next = nullptr;
1216   while (true) {
1217     size_t NameLen;
1218     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1219     LLVMValueRef Fun = LLVMGetNamedFunction(M, Name);
1220     if (!Fun)
1221       report_fatal_error("Function must have been declared already");
1222 
1223     if (LLVMHasPersonalityFn(Cur)) {
1224       size_t FNameLen;
1225       const char *FName = LLVMGetValueName2(LLVMGetPersonalityFn(Cur),
1226                                            &FNameLen);
1227       LLVMValueRef P = LLVMGetNamedFunction(M, FName);
1228       if (!P)
1229         report_fatal_error("Could not find personality function");
1230       LLVMSetPersonalityFn(Fun, P);
1231     }
1232 
1233     size_t NumMetadataEntries;
1234     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1235     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1236       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1237       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1238       LLVMGlobalSetMetadata(Fun, Kind, MD);
1239     }
1240     LLVMDisposeValueMetadataEntries(AllMetadata);
1241 
1242     FunCloner FC(Cur, Fun);
1243     FC.CloneBBs(Cur);
1244 
1245     Next = LLVMGetNextFunction(Cur);
1246     if (Next == nullptr) {
1247       if (Cur != End)
1248         report_fatal_error("Last function does not match End");
1249       break;
1250     }
1251 
1252     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1253     if (Prev != Cur)
1254       report_fatal_error("Next.Previous function is not Current");
1255 
1256     Cur = Next;
1257   }
1258 
1259 AliasClone:
1260   Begin = LLVMGetFirstGlobalAlias(Src);
1261   End = LLVMGetLastGlobalAlias(Src);
1262   if (!Begin) {
1263     if (End != nullptr)
1264       report_fatal_error("Range has an end but no beginning");
1265     goto GlobalIFuncClone;
1266   }
1267 
1268   Cur = Begin;
1269   Next = nullptr;
1270   while (true) {
1271     size_t NameLen;
1272     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1273     LLVMValueRef Alias = LLVMGetNamedGlobalAlias(M, Name, NameLen);
1274     if (!Alias)
1275       report_fatal_error("Global alias must have been declared already");
1276 
1277     if (LLVMValueRef Aliasee = LLVMAliasGetAliasee(Cur)) {
1278       LLVMAliasSetAliasee(Alias, clone_constant(Aliasee, M));
1279     }
1280 
1281     LLVMSetLinkage(Alias, LLVMGetLinkage(Cur));
1282     LLVMSetUnnamedAddress(Alias, LLVMGetUnnamedAddress(Cur));
1283 
1284     Next = LLVMGetNextGlobalAlias(Cur);
1285     if (Next == nullptr) {
1286       if (Cur != End)
1287         report_fatal_error("Last global alias does not match End");
1288       break;
1289     }
1290 
1291     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1292     if (Prev != Cur)
1293       report_fatal_error("Next.Previous global alias is not Current");
1294 
1295     Cur = Next;
1296   }
1297 
1298 GlobalIFuncClone:
1299   Begin = LLVMGetFirstGlobalIFunc(Src);
1300   End = LLVMGetLastGlobalIFunc(Src);
1301   if (!Begin) {
1302     if (End != nullptr)
1303       report_fatal_error("Range has an end but no beginning");
1304     goto NamedMDClone;
1305   }
1306 
1307   Cur = Begin;
1308   Next = nullptr;
1309   while (true) {
1310     size_t NameLen;
1311     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1312     LLVMValueRef IFunc = LLVMGetNamedGlobalIFunc(M, Name, NameLen);
1313     if (!IFunc)
1314       report_fatal_error("Global ifunc must have been declared already");
1315 
1316     if (LLVMValueRef Resolver = LLVMGetGlobalIFuncResolver(Cur)) {
1317       LLVMSetGlobalIFuncResolver(IFunc, clone_constant(Resolver, M));
1318     }
1319 
1320     LLVMSetLinkage(IFunc, LLVMGetLinkage(Cur));
1321     LLVMSetUnnamedAddress(IFunc, LLVMGetUnnamedAddress(Cur));
1322 
1323     Next = LLVMGetNextGlobalIFunc(Cur);
1324     if (Next == nullptr) {
1325       if (Cur != End)
1326         report_fatal_error("Last global alias does not match End");
1327       break;
1328     }
1329 
1330     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1331     if (Prev != Cur)
1332       report_fatal_error("Next.Previous global alias is not Current");
1333 
1334     Cur = Next;
1335   }
1336 
1337 NamedMDClone:
1338   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1339   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1340   if (!BeginMD) {
1341     if (EndMD != nullptr)
1342       report_fatal_error("Range has an end but no beginning");
1343     return;
1344   }
1345 
1346   LLVMNamedMDNodeRef CurMD = BeginMD;
1347   LLVMNamedMDNodeRef NextMD = nullptr;
1348   while (true) {
1349     size_t NameLen;
1350     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1351     LLVMNamedMDNodeRef NamedMD = LLVMGetNamedMetadata(M, Name, NameLen);
1352     if (!NamedMD)
1353       report_fatal_error("Named MD Node must have been declared already");
1354 
1355     unsigned OperandCount = LLVMGetNamedMetadataNumOperands(Src, Name);
1356     LLVMValueRef *OperandBuf = static_cast<LLVMValueRef *>(
1357               safe_malloc(OperandCount * sizeof(LLVMValueRef)));
1358     LLVMGetNamedMetadataOperands(Src, Name, OperandBuf);
1359     for (unsigned i = 0, e = OperandCount; i != e; ++i) {
1360       LLVMAddNamedMetadataOperand(M, Name, OperandBuf[i]);
1361     }
1362     free(OperandBuf);
1363 
1364     NextMD = LLVMGetNextNamedMetadata(CurMD);
1365     if (NextMD == nullptr) {
1366       if (CurMD != EndMD)
1367         report_fatal_error("Last Named MD Node does not match End");
1368       break;
1369     }
1370 
1371     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1372     if (PrevMD != CurMD)
1373       report_fatal_error("Next.Previous Named MD Node is not Current");
1374 
1375     CurMD = NextMD;
1376   }
1377 }
1378 
1379 int llvm_echo(void) {
1380   LLVMEnablePrettyStackTrace();
1381 
1382   LLVMModuleRef Src = llvm_load_module(false, true);
1383   size_t SourceFileLen;
1384   const char *SourceFileName = LLVMGetSourceFileName(Src, &SourceFileLen);
1385   size_t ModuleIdentLen;
1386   const char *ModuleName = LLVMGetModuleIdentifier(Src, &ModuleIdentLen);
1387   LLVMContextRef Ctx = LLVMContextCreate();
1388   LLVMModuleRef M = LLVMModuleCreateWithNameInContext(ModuleName, Ctx);
1389 
1390   LLVMSetSourceFileName(M, SourceFileName, SourceFileLen);
1391   LLVMSetModuleIdentifier(M, ModuleName, ModuleIdentLen);
1392 
1393   LLVMSetTarget(M, LLVMGetTarget(Src));
1394   LLVMSetModuleDataLayout(M, LLVMGetModuleDataLayout(Src));
1395   if (strcmp(LLVMGetDataLayoutStr(M), LLVMGetDataLayoutStr(Src)))
1396     report_fatal_error("Inconsistent DataLayout string representation");
1397 
1398   size_t ModuleInlineAsmLen;
1399   const char *ModuleAsm = LLVMGetModuleInlineAsm(Src, &ModuleInlineAsmLen);
1400   LLVMSetModuleInlineAsm2(M, ModuleAsm, ModuleInlineAsmLen);
1401 
1402   declare_symbols(Src, M);
1403   clone_symbols(Src, M);
1404   char *Str = LLVMPrintModuleToString(M);
1405   fputs(Str, stdout);
1406 
1407   LLVMDisposeMessage(Str);
1408   LLVMDisposeModule(Src);
1409   LLVMDisposeModule(M);
1410   LLVMContextDispose(Ctx);
1411 
1412   return 0;
1413 }
1414