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     case LLVMGetElementPtr: {
406       LLVMTypeRef ElemTy =
407           TypeCloner(M).Clone(LLVMGetGEPSourceElementType(Cst));
408       LLVMValueRef Ptr = clone_constant(LLVMGetOperand(Cst, 0), M);
409       int NumIdx = LLVMGetNumIndices(Cst);
410       SmallVector<LLVMValueRef, 8> Idx;
411       for (int i = 1; i <= NumIdx; i++)
412         Idx.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
413       if (LLVMIsInBounds(Cst))
414         return LLVMConstInBoundsGEP2(ElemTy, Ptr, Idx.data(), NumIdx);
415       else
416         return LLVMConstGEP2(ElemTy, Ptr, Idx.data(), NumIdx);
417     }
418     default:
419       fprintf(stderr, "%d is not a supported opcode for constant expressions\n",
420               Op);
421       exit(-1);
422   }
423 }
424 
425 struct FunCloner {
426   LLVMValueRef Fun;
427   LLVMModuleRef M;
428 
429   ValueMap VMap;
430   BasicBlockMap BBMap;
431 
432   FunCloner(LLVMValueRef Src, LLVMValueRef Dst): Fun(Dst),
433     M(LLVMGetGlobalParent(Fun)), VMap(clone_params(Src, Dst)) {}
434 
435   LLVMTypeRef CloneType(LLVMTypeRef Src) {
436     return TypeCloner(M).Clone(Src);
437   }
438 
439   LLVMTypeRef CloneType(LLVMValueRef Src) {
440     return TypeCloner(M).Clone(Src);
441   }
442 
443   // Try to clone everything in the llvm::Value hierarchy.
444   LLVMValueRef CloneValue(LLVMValueRef Src) {
445     // First, the value may be constant.
446     if (LLVMIsAConstant(Src))
447       return clone_constant(Src, M);
448 
449     // Function argument should always be in the map already.
450     auto i = VMap.find(Src);
451     if (i != VMap.end())
452       return i->second;
453 
454     if (!LLVMIsAInstruction(Src))
455       report_fatal_error("Expected an instruction");
456 
457     auto Ctx = LLVMGetModuleContext(M);
458     auto Builder = LLVMCreateBuilderInContext(Ctx);
459     auto BB = DeclareBB(LLVMGetInstructionParent(Src));
460     LLVMPositionBuilderAtEnd(Builder, BB);
461     auto Dst = CloneInstruction(Src, Builder);
462     LLVMDisposeBuilder(Builder);
463     return Dst;
464   }
465 
466   void CloneAttrs(LLVMValueRef Src, LLVMValueRef Dst) {
467     auto Ctx = LLVMGetModuleContext(M);
468     int ArgCount = LLVMGetNumArgOperands(Src);
469     for (int i = LLVMAttributeReturnIndex; i <= ArgCount; i++) {
470       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
471         if (auto SrcA = LLVMGetCallSiteEnumAttribute(Src, i, k)) {
472           auto Val = LLVMGetEnumAttributeValue(SrcA);
473           auto A = LLVMCreateEnumAttribute(Ctx, k, Val);
474           LLVMAddCallSiteAttribute(Dst, i, A);
475         }
476       }
477     }
478   }
479 
480   LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
481     check_value_kind(Src, LLVMInstructionValueKind);
482     if (!LLVMIsAInstruction(Src))
483       report_fatal_error("Expected an instruction");
484 
485     size_t NameLen;
486     const char *Name = LLVMGetValueName2(Src, &NameLen);
487 
488     // Check if this is something we already computed.
489     {
490       auto i = VMap.find(Src);
491       if (i != VMap.end()) {
492         // If we have a hit, it means we already generated the instruction
493         // as a dependency to something else. We need to make sure
494         // it is ordered properly.
495         auto I = i->second;
496         LLVMInstructionRemoveFromParent(I);
497         LLVMInsertIntoBuilderWithName(Builder, I, Name);
498         return I;
499       }
500     }
501 
502     // We tried everything, it must be an instruction
503     // that hasn't been generated already.
504     LLVMValueRef Dst = nullptr;
505 
506     LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
507     switch(Op) {
508       case LLVMRet: {
509         int OpCount = LLVMGetNumOperands(Src);
510         if (OpCount == 0)
511           Dst = LLVMBuildRetVoid(Builder);
512         else
513           Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0)));
514         break;
515       }
516       case LLVMBr: {
517         if (!LLVMIsConditional(Src)) {
518           LLVMValueRef SrcOp = LLVMGetOperand(Src, 0);
519           LLVMBasicBlockRef SrcBB = LLVMValueAsBasicBlock(SrcOp);
520           Dst = LLVMBuildBr(Builder, DeclareBB(SrcBB));
521           break;
522         }
523 
524         LLVMValueRef Cond = LLVMGetCondition(Src);
525         LLVMValueRef Else = LLVMGetOperand(Src, 1);
526         LLVMBasicBlockRef ElseBB = DeclareBB(LLVMValueAsBasicBlock(Else));
527         LLVMValueRef Then = LLVMGetOperand(Src, 2);
528         LLVMBasicBlockRef ThenBB = DeclareBB(LLVMValueAsBasicBlock(Then));
529         Dst = LLVMBuildCondBr(Builder, CloneValue(Cond), ThenBB, ElseBB);
530         break;
531       }
532       case LLVMSwitch:
533       case LLVMIndirectBr:
534         break;
535       case LLVMInvoke: {
536         SmallVector<LLVMValueRef, 8> Args;
537         int ArgCount = LLVMGetNumArgOperands(Src);
538         for (int i = 0; i < ArgCount; i++)
539           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
540         LLVMTypeRef FnTy = CloneType(LLVMGetCalledFunctionType(Src));
541         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
542         LLVMBasicBlockRef Then = DeclareBB(LLVMGetNormalDest(Src));
543         LLVMBasicBlockRef Unwind = DeclareBB(LLVMGetUnwindDest(Src));
544         Dst = LLVMBuildInvoke2(Builder, FnTy, Fn, Args.data(), ArgCount,
545                                Then, Unwind, Name);
546         CloneAttrs(Src, Dst);
547         break;
548       }
549       case LLVMUnreachable:
550         Dst = LLVMBuildUnreachable(Builder);
551         break;
552       case LLVMAdd: {
553         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
554         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
555         Dst = LLVMBuildAdd(Builder, LHS, RHS, Name);
556         break;
557       }
558       case LLVMSub: {
559         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
560         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
561         Dst = LLVMBuildSub(Builder, LHS, RHS, Name);
562         break;
563       }
564       case LLVMMul: {
565         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
566         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
567         Dst = LLVMBuildMul(Builder, LHS, RHS, Name);
568         break;
569       }
570       case LLVMUDiv: {
571         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
572         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
573         Dst = LLVMBuildUDiv(Builder, LHS, RHS, Name);
574         break;
575       }
576       case LLVMSDiv: {
577         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
578         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
579         Dst = LLVMBuildSDiv(Builder, LHS, RHS, Name);
580         break;
581       }
582       case LLVMURem: {
583         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
584         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
585         Dst = LLVMBuildURem(Builder, LHS, RHS, Name);
586         break;
587       }
588       case LLVMSRem: {
589         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
590         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
591         Dst = LLVMBuildSRem(Builder, LHS, RHS, Name);
592         break;
593       }
594       case LLVMShl: {
595         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
596         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
597         Dst = LLVMBuildShl(Builder, LHS, RHS, Name);
598         break;
599       }
600       case LLVMLShr: {
601         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
602         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
603         Dst = LLVMBuildLShr(Builder, LHS, RHS, Name);
604         break;
605       }
606       case LLVMAShr: {
607         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
608         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
609         Dst = LLVMBuildAShr(Builder, LHS, RHS, Name);
610         break;
611       }
612       case LLVMAnd: {
613         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
614         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
615         Dst = LLVMBuildAnd(Builder, LHS, RHS, Name);
616         break;
617       }
618       case LLVMOr: {
619         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
620         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
621         Dst = LLVMBuildOr(Builder, LHS, RHS, Name);
622         break;
623       }
624       case LLVMXor: {
625         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
626         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
627         Dst = LLVMBuildXor(Builder, LHS, RHS, Name);
628         break;
629       }
630       case LLVMAlloca: {
631         LLVMTypeRef Ty = CloneType(LLVMGetAllocatedType(Src));
632         Dst = LLVMBuildAlloca(Builder, Ty, Name);
633         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
634         break;
635       }
636       case LLVMLoad: {
637         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
638         Dst = LLVMBuildLoad2(Builder, CloneType(Src), Ptr, Name);
639         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
640         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
641         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
642         break;
643       }
644       case LLVMStore: {
645         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
646         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 1));
647         Dst = LLVMBuildStore(Builder, Val, Ptr);
648         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
649         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
650         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
651         break;
652       }
653       case LLVMGetElementPtr: {
654         LLVMTypeRef ElemTy = CloneType(LLVMGetGEPSourceElementType(Src));
655         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
656         SmallVector<LLVMValueRef, 8> Idx;
657         int NumIdx = LLVMGetNumIndices(Src);
658         for (int i = 1; i <= NumIdx; i++)
659           Idx.push_back(CloneValue(LLVMGetOperand(Src, i)));
660         if (LLVMIsInBounds(Src))
661           Dst = LLVMBuildInBoundsGEP2(Builder, ElemTy, Ptr, Idx.data(), NumIdx,
662                                       Name);
663         else
664           Dst = LLVMBuildGEP2(Builder, ElemTy, Ptr, Idx.data(), NumIdx, Name);
665         break;
666       }
667       case LLVMAtomicRMW: {
668         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
669         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 1));
670         LLVMAtomicRMWBinOp BinOp = LLVMGetAtomicRMWBinOp(Src);
671         LLVMAtomicOrdering Ord = LLVMGetOrdering(Src);
672         LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
673         Dst = LLVMBuildAtomicRMW(Builder, BinOp, Ptr, Val, Ord, SingleThread);
674         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
675         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
676         LLVMSetValueName2(Dst, Name, NameLen);
677         break;
678       }
679       case LLVMAtomicCmpXchg: {
680         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
681         LLVMValueRef Cmp = CloneValue(LLVMGetOperand(Src, 1));
682         LLVMValueRef New = CloneValue(LLVMGetOperand(Src, 2));
683         LLVMAtomicOrdering Succ = LLVMGetCmpXchgSuccessOrdering(Src);
684         LLVMAtomicOrdering Fail = LLVMGetCmpXchgFailureOrdering(Src);
685         LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
686 
687         Dst = LLVMBuildAtomicCmpXchg(Builder, Ptr, Cmp, New, Succ, Fail,
688                                      SingleThread);
689         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
690         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
691         LLVMSetWeak(Dst, LLVMGetWeak(Src));
692         LLVMSetValueName2(Dst, Name, NameLen);
693         break;
694       }
695       case LLVMBitCast: {
696         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 0));
697         Dst = LLVMBuildBitCast(Builder, V, CloneType(Src), Name);
698         break;
699       }
700       case LLVMICmp: {
701         LLVMIntPredicate Pred = LLVMGetICmpPredicate(Src);
702         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
703         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
704         Dst = LLVMBuildICmp(Builder, Pred, LHS, RHS, Name);
705         break;
706       }
707       case LLVMPHI: {
708         // We need to aggressively set things here because of loops.
709         VMap[Src] = Dst = LLVMBuildPhi(Builder, CloneType(Src), Name);
710 
711         SmallVector<LLVMValueRef, 8> Values;
712         SmallVector<LLVMBasicBlockRef, 8> Blocks;
713 
714         unsigned IncomingCount = LLVMCountIncoming(Src);
715         for (unsigned i = 0; i < IncomingCount; ++i) {
716           Blocks.push_back(DeclareBB(LLVMGetIncomingBlock(Src, i)));
717           Values.push_back(CloneValue(LLVMGetIncomingValue(Src, i)));
718         }
719 
720         LLVMAddIncoming(Dst, Values.data(), Blocks.data(), IncomingCount);
721         return Dst;
722       }
723       case LLVMCall: {
724         SmallVector<LLVMValueRef, 8> Args;
725         int ArgCount = LLVMGetNumArgOperands(Src);
726         for (int i = 0; i < ArgCount; i++)
727           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
728         LLVMTypeRef FnTy = CloneType(LLVMGetCalledFunctionType(Src));
729         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
730         Dst = LLVMBuildCall2(Builder, FnTy, Fn, Args.data(), ArgCount, Name);
731         LLVMSetTailCall(Dst, LLVMIsTailCall(Src));
732         CloneAttrs(Src, Dst);
733         break;
734       }
735       case LLVMResume: {
736         Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
737         break;
738       }
739       case LLVMLandingPad: {
740         // The landing pad API is a bit screwed up for historical reasons.
741         Dst = LLVMBuildLandingPad(Builder, CloneType(Src), nullptr, 0, Name);
742         unsigned NumClauses = LLVMGetNumClauses(Src);
743         for (unsigned i = 0; i < NumClauses; ++i)
744           LLVMAddClause(Dst, CloneValue(LLVMGetClause(Src, i)));
745         LLVMSetCleanup(Dst, LLVMIsCleanup(Src));
746         break;
747       }
748       case LLVMCleanupRet: {
749         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
750         LLVMBasicBlockRef Unwind = nullptr;
751         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src))
752           Unwind = DeclareBB(UDest);
753         Dst = LLVMBuildCleanupRet(Builder, CatchPad, Unwind);
754         break;
755       }
756       case LLVMCatchRet: {
757         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
758         LLVMBasicBlockRef SuccBB = DeclareBB(LLVMGetSuccessor(Src, 0));
759         Dst = LLVMBuildCatchRet(Builder, CatchPad, SuccBB);
760         break;
761       }
762       case LLVMCatchPad: {
763         LLVMValueRef ParentPad = CloneValue(LLVMGetParentCatchSwitch(Src));
764         SmallVector<LLVMValueRef, 8> Args;
765         int ArgCount = LLVMGetNumArgOperands(Src);
766         for (int i = 0; i < ArgCount; i++)
767           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
768         Dst = LLVMBuildCatchPad(Builder, ParentPad,
769                                 Args.data(), ArgCount, Name);
770         break;
771       }
772       case LLVMCleanupPad: {
773         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
774         SmallVector<LLVMValueRef, 8> Args;
775         int ArgCount = LLVMGetNumArgOperands(Src);
776         for (int i = 0; i < ArgCount; i++)
777           Args.push_back(CloneValue(LLVMGetArgOperand(Src, i)));
778         Dst = LLVMBuildCleanupPad(Builder, ParentPad,
779                                   Args.data(), ArgCount, Name);
780         break;
781       }
782       case LLVMCatchSwitch: {
783         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
784         LLVMBasicBlockRef UnwindBB = nullptr;
785         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src)) {
786           UnwindBB = DeclareBB(UDest);
787         }
788         unsigned NumHandlers = LLVMGetNumHandlers(Src);
789         Dst = LLVMBuildCatchSwitch(Builder, ParentPad, UnwindBB, NumHandlers, Name);
790         if (NumHandlers > 0) {
791           LLVMBasicBlockRef *Handlers = static_cast<LLVMBasicBlockRef*>(
792                        safe_malloc(NumHandlers * sizeof(LLVMBasicBlockRef)));
793           LLVMGetHandlers(Src, Handlers);
794           for (unsigned i = 0; i < NumHandlers; i++)
795             LLVMAddHandler(Dst, DeclareBB(Handlers[i]));
796           free(Handlers);
797         }
798         break;
799       }
800       case LLVMExtractValue: {
801         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
802         if (LLVMGetNumIndices(Src) > 1)
803           report_fatal_error("ExtractValue: Expected only one index");
804         else if (LLVMGetNumIndices(Src) < 1)
805           report_fatal_error("ExtractValue: Expected an index");
806         auto I = LLVMGetIndices(Src)[0];
807         Dst = LLVMBuildExtractValue(Builder, Agg, I, Name);
808         break;
809       }
810       case LLVMInsertValue: {
811         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
812         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
813         if (LLVMGetNumIndices(Src) > 1)
814           report_fatal_error("InsertValue: Expected only one index");
815         else if (LLVMGetNumIndices(Src) < 1)
816           report_fatal_error("InsertValue: Expected an index");
817         auto I = LLVMGetIndices(Src)[0];
818         Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
819         break;
820       }
821       case LLVMExtractElement: {
822         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
823         LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 1));
824         Dst = LLVMBuildExtractElement(Builder, Agg, Index, Name);
825         break;
826       }
827       case LLVMInsertElement: {
828         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
829         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
830         LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 2));
831         Dst = LLVMBuildInsertElement(Builder, Agg, V, Index, Name);
832         break;
833       }
834       case LLVMShuffleVector: {
835         LLVMValueRef Agg0 = CloneValue(LLVMGetOperand(Src, 0));
836         LLVMValueRef Agg1 = CloneValue(LLVMGetOperand(Src, 1));
837         SmallVector<LLVMValueRef, 8> MaskElts;
838         unsigned NumMaskElts = LLVMGetNumMaskElements(Src);
839         for (unsigned i = 0; i < NumMaskElts; i++) {
840           int Val = LLVMGetMaskValue(Src, i);
841           if (Val == LLVMGetUndefMaskElem()) {
842             MaskElts.push_back(LLVMGetUndef(LLVMInt64Type()));
843           } else {
844             MaskElts.push_back(LLVMConstInt(LLVMInt64Type(), Val, true));
845           }
846         }
847         LLVMValueRef Mask = LLVMConstVector(MaskElts.data(), NumMaskElts);
848         Dst = LLVMBuildShuffleVector(Builder, Agg0, Agg1, Mask, Name);
849         break;
850       }
851       case LLVMFreeze: {
852         LLVMValueRef Arg = CloneValue(LLVMGetOperand(Src, 0));
853         Dst = LLVMBuildFreeze(Builder, Arg, Name);
854         break;
855       }
856       default:
857         break;
858     }
859 
860     if (Dst == nullptr) {
861       fprintf(stderr, "%d is not a supported opcode\n", Op);
862       exit(-1);
863     }
864 
865     auto Ctx = LLVMGetModuleContext(M);
866     size_t NumMetadataEntries;
867     auto *AllMetadata =
868         LLVMInstructionGetAllMetadataOtherThanDebugLoc(Src,
869                                                        &NumMetadataEntries);
870     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
871       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
872       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
873       LLVMSetMetadata(Dst, Kind, LLVMMetadataAsValue(Ctx, MD));
874     }
875     LLVMDisposeValueMetadataEntries(AllMetadata);
876     LLVMAddMetadataToInst(Builder, Dst);
877 
878     check_value_kind(Dst, LLVMInstructionValueKind);
879     return VMap[Src] = Dst;
880   }
881 
882   LLVMBasicBlockRef DeclareBB(LLVMBasicBlockRef Src) {
883     // Check if this is something we already computed.
884     {
885       auto i = BBMap.find(Src);
886       if (i != BBMap.end()) {
887         return i->second;
888       }
889     }
890 
891     LLVMValueRef V = LLVMBasicBlockAsValue(Src);
892     if (!LLVMValueIsBasicBlock(V) || LLVMValueAsBasicBlock(V) != Src)
893       report_fatal_error("Basic block is not a basic block");
894 
895     const char *Name = LLVMGetBasicBlockName(Src);
896     size_t NameLen;
897     const char *VName = LLVMGetValueName2(V, &NameLen);
898     if (Name != VName)
899       report_fatal_error("Basic block name mismatch");
900 
901     LLVMBasicBlockRef BB = LLVMAppendBasicBlock(Fun, Name);
902     return BBMap[Src] = BB;
903   }
904 
905   LLVMBasicBlockRef CloneBB(LLVMBasicBlockRef Src) {
906     LLVMBasicBlockRef BB = DeclareBB(Src);
907 
908     // Make sure ordering is correct.
909     LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Src);
910     if (Prev)
911       LLVMMoveBasicBlockAfter(BB, DeclareBB(Prev));
912 
913     LLVMValueRef First = LLVMGetFirstInstruction(Src);
914     LLVMValueRef Last = LLVMGetLastInstruction(Src);
915 
916     if (First == nullptr) {
917       if (Last != nullptr)
918         report_fatal_error("Has no first instruction, but last one");
919       return BB;
920     }
921 
922     auto Ctx = LLVMGetModuleContext(M);
923     LLVMBuilderRef Builder = LLVMCreateBuilderInContext(Ctx);
924     LLVMPositionBuilderAtEnd(Builder, BB);
925 
926     LLVMValueRef Cur = First;
927     LLVMValueRef Next = nullptr;
928     while(true) {
929       CloneInstruction(Cur, Builder);
930       Next = LLVMGetNextInstruction(Cur);
931       if (Next == nullptr) {
932         if (Cur != Last)
933           report_fatal_error("Final instruction does not match Last");
934         break;
935       }
936 
937       LLVMValueRef Prev = LLVMGetPreviousInstruction(Next);
938       if (Prev != Cur)
939         report_fatal_error("Next.Previous instruction is not Current");
940 
941       Cur = Next;
942     }
943 
944     LLVMDisposeBuilder(Builder);
945     return BB;
946   }
947 
948   void CloneBBs(LLVMValueRef Src) {
949     unsigned Count = LLVMCountBasicBlocks(Src);
950     if (Count == 0)
951       return;
952 
953     LLVMBasicBlockRef First = LLVMGetFirstBasicBlock(Src);
954     LLVMBasicBlockRef Last = LLVMGetLastBasicBlock(Src);
955 
956     LLVMBasicBlockRef Cur = First;
957     LLVMBasicBlockRef Next = nullptr;
958     while(true) {
959       CloneBB(Cur);
960       Count--;
961       Next = LLVMGetNextBasicBlock(Cur);
962       if (Next == nullptr) {
963         if (Cur != Last)
964           report_fatal_error("Final basic block does not match Last");
965         break;
966       }
967 
968       LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Next);
969       if (Prev != Cur)
970         report_fatal_error("Next.Previous basic bloc is not Current");
971 
972       Cur = Next;
973     }
974 
975     if (Count != 0)
976       report_fatal_error("Basic block count does not match iterration");
977   }
978 };
979 
980 static void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
981   auto Ctx = LLVMGetModuleContext(M);
982 
983   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
984   LLVMValueRef End = LLVMGetLastGlobal(Src);
985 
986   LLVMValueRef Cur = Begin;
987   LLVMValueRef Next = nullptr;
988   if (!Begin) {
989     if (End != nullptr)
990       report_fatal_error("Range has an end but no beginning");
991     goto FunDecl;
992   }
993 
994   while (true) {
995     size_t NameLen;
996     const char *Name = LLVMGetValueName2(Cur, &NameLen);
997     if (LLVMGetNamedGlobal(M, Name))
998       report_fatal_error("GlobalVariable already cloned");
999     LLVMAddGlobal(M, LLVMGetElementType(TypeCloner(M).Clone(Cur)), Name);
1000 
1001     Next = LLVMGetNextGlobal(Cur);
1002     if (Next == nullptr) {
1003       if (Cur != End)
1004         report_fatal_error("");
1005       break;
1006     }
1007 
1008     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
1009     if (Prev != Cur)
1010       report_fatal_error("Next.Previous global is not Current");
1011 
1012     Cur = Next;
1013   }
1014 
1015 FunDecl:
1016   Begin = LLVMGetFirstFunction(Src);
1017   End = LLVMGetLastFunction(Src);
1018   if (!Begin) {
1019     if (End != nullptr)
1020       report_fatal_error("Range has an end but no beginning");
1021     goto AliasDecl;
1022   }
1023 
1024   Cur = Begin;
1025   Next = nullptr;
1026   while (true) {
1027     size_t NameLen;
1028     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1029     if (LLVMGetNamedFunction(M, Name))
1030       report_fatal_error("Function already cloned");
1031     auto Ty = LLVMGetElementType(TypeCloner(M).Clone(Cur));
1032     auto F = LLVMAddFunction(M, Name, Ty);
1033 
1034     // Copy attributes
1035     for (int i = LLVMAttributeFunctionIndex, c = LLVMCountParams(F);
1036          i <= c; ++i) {
1037       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
1038         if (auto SrcA = LLVMGetEnumAttributeAtIndex(Cur, i, k)) {
1039           auto Val = LLVMGetEnumAttributeValue(SrcA);
1040           auto DstA = LLVMCreateEnumAttribute(Ctx, k, Val);
1041           LLVMAddAttributeAtIndex(F, i, DstA);
1042         }
1043       }
1044     }
1045 
1046     Next = LLVMGetNextFunction(Cur);
1047     if (Next == nullptr) {
1048       if (Cur != End)
1049         report_fatal_error("Last function does not match End");
1050       break;
1051     }
1052 
1053     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1054     if (Prev != Cur)
1055       report_fatal_error("Next.Previous function is not Current");
1056 
1057     Cur = Next;
1058   }
1059 
1060 AliasDecl:
1061   Begin = LLVMGetFirstGlobalAlias(Src);
1062   End = LLVMGetLastGlobalAlias(Src);
1063   if (!Begin) {
1064     if (End != nullptr)
1065       report_fatal_error("Range has an end but no beginning");
1066     goto GlobalIFuncDecl;
1067   }
1068 
1069   Cur = Begin;
1070   Next = nullptr;
1071   while (true) {
1072     size_t NameLen;
1073     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1074     if (LLVMGetNamedGlobalAlias(M, Name, NameLen))
1075       report_fatal_error("Global alias already cloned");
1076     LLVMTypeRef PtrType = TypeCloner(M).Clone(Cur);
1077     LLVMTypeRef ValType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1078     unsigned AddrSpace = LLVMGetPointerAddressSpace(PtrType);
1079     // FIXME: Allow NULL aliasee.
1080     LLVMAddAlias2(M, ValType, AddrSpace, LLVMGetUndef(PtrType), Name);
1081 
1082     Next = LLVMGetNextGlobalAlias(Cur);
1083     if (Next == nullptr) {
1084       if (Cur != End)
1085         report_fatal_error("");
1086       break;
1087     }
1088 
1089     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1090     if (Prev != Cur)
1091       report_fatal_error("Next.Previous global is not Current");
1092 
1093     Cur = Next;
1094   }
1095 
1096 GlobalIFuncDecl:
1097   Begin = LLVMGetFirstGlobalIFunc(Src);
1098   End = LLVMGetLastGlobalIFunc(Src);
1099   if (!Begin) {
1100     if (End != nullptr)
1101       report_fatal_error("Range has an end but no beginning");
1102     goto NamedMDDecl;
1103   }
1104 
1105   Cur = Begin;
1106   Next = nullptr;
1107   while (true) {
1108     size_t NameLen;
1109     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1110     if (LLVMGetNamedGlobalIFunc(M, Name, NameLen))
1111       report_fatal_error("Global ifunc already cloned");
1112     LLVMTypeRef CurType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1113     // FIXME: Allow NULL resolver.
1114     LLVMAddGlobalIFunc(M, Name, NameLen,
1115                        CurType, /*addressSpace*/ 0, LLVMGetUndef(CurType));
1116 
1117     Next = LLVMGetNextGlobalIFunc(Cur);
1118     if (Next == nullptr) {
1119       if (Cur != End)
1120         report_fatal_error("");
1121       break;
1122     }
1123 
1124     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1125     if (Prev != Cur)
1126       report_fatal_error("Next.Previous global is not Current");
1127 
1128     Cur = Next;
1129   }
1130 
1131 NamedMDDecl:
1132   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1133   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1134   if (!BeginMD) {
1135     if (EndMD != nullptr)
1136       report_fatal_error("Range has an end but no beginning");
1137     return;
1138   }
1139 
1140   LLVMNamedMDNodeRef CurMD = BeginMD;
1141   LLVMNamedMDNodeRef NextMD = nullptr;
1142   while (true) {
1143     size_t NameLen;
1144     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1145     if (LLVMGetNamedMetadata(M, Name, NameLen))
1146       report_fatal_error("Named Metadata Node already cloned");
1147     LLVMGetOrInsertNamedMetadata(M, Name, NameLen);
1148 
1149     NextMD = LLVMGetNextNamedMetadata(CurMD);
1150     if (NextMD == nullptr) {
1151       if (CurMD != EndMD)
1152         report_fatal_error("");
1153       break;
1154     }
1155 
1156     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1157     if (PrevMD != CurMD)
1158       report_fatal_error("Next.Previous global is not Current");
1159 
1160     CurMD = NextMD;
1161   }
1162 }
1163 
1164 static void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
1165   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
1166   LLVMValueRef End = LLVMGetLastGlobal(Src);
1167 
1168   LLVMValueRef Cur = Begin;
1169   LLVMValueRef Next = nullptr;
1170   if (!Begin) {
1171     if (End != nullptr)
1172       report_fatal_error("Range has an end but no beginning");
1173     goto FunClone;
1174   }
1175 
1176   while (true) {
1177     size_t NameLen;
1178     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1179     LLVMValueRef G = LLVMGetNamedGlobal(M, Name);
1180     if (!G)
1181       report_fatal_error("GlobalVariable must have been declared already");
1182 
1183     if (auto I = LLVMGetInitializer(Cur))
1184       LLVMSetInitializer(G, clone_constant(I, M));
1185 
1186     size_t NumMetadataEntries;
1187     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1188     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1189       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1190       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1191       LLVMGlobalSetMetadata(G, Kind, MD);
1192     }
1193     LLVMDisposeValueMetadataEntries(AllMetadata);
1194 
1195     LLVMSetGlobalConstant(G, LLVMIsGlobalConstant(Cur));
1196     LLVMSetThreadLocal(G, LLVMIsThreadLocal(Cur));
1197     LLVMSetExternallyInitialized(G, LLVMIsExternallyInitialized(Cur));
1198     LLVMSetLinkage(G, LLVMGetLinkage(Cur));
1199     LLVMSetSection(G, LLVMGetSection(Cur));
1200     LLVMSetVisibility(G, LLVMGetVisibility(Cur));
1201     LLVMSetUnnamedAddress(G, LLVMGetUnnamedAddress(Cur));
1202     LLVMSetAlignment(G, LLVMGetAlignment(Cur));
1203 
1204     Next = LLVMGetNextGlobal(Cur);
1205     if (Next == nullptr) {
1206       if (Cur != End)
1207         report_fatal_error("");
1208       break;
1209     }
1210 
1211     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
1212     if (Prev != Cur)
1213       report_fatal_error("Next.Previous global is not Current");
1214 
1215     Cur = Next;
1216   }
1217 
1218 FunClone:
1219   Begin = LLVMGetFirstFunction(Src);
1220   End = LLVMGetLastFunction(Src);
1221   if (!Begin) {
1222     if (End != nullptr)
1223       report_fatal_error("Range has an end but no beginning");
1224     goto AliasClone;
1225   }
1226 
1227   Cur = Begin;
1228   Next = nullptr;
1229   while (true) {
1230     size_t NameLen;
1231     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1232     LLVMValueRef Fun = LLVMGetNamedFunction(M, Name);
1233     if (!Fun)
1234       report_fatal_error("Function must have been declared already");
1235 
1236     if (LLVMHasPersonalityFn(Cur)) {
1237       size_t FNameLen;
1238       const char *FName = LLVMGetValueName2(LLVMGetPersonalityFn(Cur),
1239                                            &FNameLen);
1240       LLVMValueRef P = LLVMGetNamedFunction(M, FName);
1241       if (!P)
1242         report_fatal_error("Could not find personality function");
1243       LLVMSetPersonalityFn(Fun, P);
1244     }
1245 
1246     size_t NumMetadataEntries;
1247     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1248     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1249       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1250       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1251       LLVMGlobalSetMetadata(Fun, Kind, MD);
1252     }
1253     LLVMDisposeValueMetadataEntries(AllMetadata);
1254 
1255     FunCloner FC(Cur, Fun);
1256     FC.CloneBBs(Cur);
1257 
1258     Next = LLVMGetNextFunction(Cur);
1259     if (Next == nullptr) {
1260       if (Cur != End)
1261         report_fatal_error("Last function does not match End");
1262       break;
1263     }
1264 
1265     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1266     if (Prev != Cur)
1267       report_fatal_error("Next.Previous function is not Current");
1268 
1269     Cur = Next;
1270   }
1271 
1272 AliasClone:
1273   Begin = LLVMGetFirstGlobalAlias(Src);
1274   End = LLVMGetLastGlobalAlias(Src);
1275   if (!Begin) {
1276     if (End != nullptr)
1277       report_fatal_error("Range has an end but no beginning");
1278     goto GlobalIFuncClone;
1279   }
1280 
1281   Cur = Begin;
1282   Next = nullptr;
1283   while (true) {
1284     size_t NameLen;
1285     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1286     LLVMValueRef Alias = LLVMGetNamedGlobalAlias(M, Name, NameLen);
1287     if (!Alias)
1288       report_fatal_error("Global alias must have been declared already");
1289 
1290     if (LLVMValueRef Aliasee = LLVMAliasGetAliasee(Cur)) {
1291       LLVMAliasSetAliasee(Alias, clone_constant(Aliasee, M));
1292     }
1293 
1294     LLVMSetLinkage(Alias, LLVMGetLinkage(Cur));
1295     LLVMSetUnnamedAddress(Alias, LLVMGetUnnamedAddress(Cur));
1296 
1297     Next = LLVMGetNextGlobalAlias(Cur);
1298     if (Next == nullptr) {
1299       if (Cur != End)
1300         report_fatal_error("Last global alias does not match End");
1301       break;
1302     }
1303 
1304     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1305     if (Prev != Cur)
1306       report_fatal_error("Next.Previous global alias is not Current");
1307 
1308     Cur = Next;
1309   }
1310 
1311 GlobalIFuncClone:
1312   Begin = LLVMGetFirstGlobalIFunc(Src);
1313   End = LLVMGetLastGlobalIFunc(Src);
1314   if (!Begin) {
1315     if (End != nullptr)
1316       report_fatal_error("Range has an end but no beginning");
1317     goto NamedMDClone;
1318   }
1319 
1320   Cur = Begin;
1321   Next = nullptr;
1322   while (true) {
1323     size_t NameLen;
1324     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1325     LLVMValueRef IFunc = LLVMGetNamedGlobalIFunc(M, Name, NameLen);
1326     if (!IFunc)
1327       report_fatal_error("Global ifunc must have been declared already");
1328 
1329     if (LLVMValueRef Resolver = LLVMGetGlobalIFuncResolver(Cur)) {
1330       LLVMSetGlobalIFuncResolver(IFunc, clone_constant(Resolver, M));
1331     }
1332 
1333     LLVMSetLinkage(IFunc, LLVMGetLinkage(Cur));
1334     LLVMSetUnnamedAddress(IFunc, LLVMGetUnnamedAddress(Cur));
1335 
1336     Next = LLVMGetNextGlobalIFunc(Cur);
1337     if (Next == nullptr) {
1338       if (Cur != End)
1339         report_fatal_error("Last global alias does not match End");
1340       break;
1341     }
1342 
1343     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1344     if (Prev != Cur)
1345       report_fatal_error("Next.Previous global alias is not Current");
1346 
1347     Cur = Next;
1348   }
1349 
1350 NamedMDClone:
1351   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1352   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1353   if (!BeginMD) {
1354     if (EndMD != nullptr)
1355       report_fatal_error("Range has an end but no beginning");
1356     return;
1357   }
1358 
1359   LLVMNamedMDNodeRef CurMD = BeginMD;
1360   LLVMNamedMDNodeRef NextMD = nullptr;
1361   while (true) {
1362     size_t NameLen;
1363     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1364     LLVMNamedMDNodeRef NamedMD = LLVMGetNamedMetadata(M, Name, NameLen);
1365     if (!NamedMD)
1366       report_fatal_error("Named MD Node must have been declared already");
1367 
1368     unsigned OperandCount = LLVMGetNamedMetadataNumOperands(Src, Name);
1369     LLVMValueRef *OperandBuf = static_cast<LLVMValueRef *>(
1370               safe_malloc(OperandCount * sizeof(LLVMValueRef)));
1371     LLVMGetNamedMetadataOperands(Src, Name, OperandBuf);
1372     for (unsigned i = 0, e = OperandCount; i != e; ++i) {
1373       LLVMAddNamedMetadataOperand(M, Name, OperandBuf[i]);
1374     }
1375     free(OperandBuf);
1376 
1377     NextMD = LLVMGetNextNamedMetadata(CurMD);
1378     if (NextMD == nullptr) {
1379       if (CurMD != EndMD)
1380         report_fatal_error("Last Named MD Node does not match End");
1381       break;
1382     }
1383 
1384     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1385     if (PrevMD != CurMD)
1386       report_fatal_error("Next.Previous Named MD Node is not Current");
1387 
1388     CurMD = NextMD;
1389   }
1390 }
1391 
1392 int llvm_echo(void) {
1393   LLVMEnablePrettyStackTrace();
1394 
1395   LLVMModuleRef Src = llvm_load_module(false, true);
1396   size_t SourceFileLen;
1397   const char *SourceFileName = LLVMGetSourceFileName(Src, &SourceFileLen);
1398   size_t ModuleIdentLen;
1399   const char *ModuleName = LLVMGetModuleIdentifier(Src, &ModuleIdentLen);
1400   LLVMContextRef Ctx = LLVMContextCreate();
1401   LLVMModuleRef M = LLVMModuleCreateWithNameInContext(ModuleName, Ctx);
1402 
1403   LLVMSetSourceFileName(M, SourceFileName, SourceFileLen);
1404   LLVMSetModuleIdentifier(M, ModuleName, ModuleIdentLen);
1405 
1406   LLVMSetTarget(M, LLVMGetTarget(Src));
1407   LLVMSetModuleDataLayout(M, LLVMGetModuleDataLayout(Src));
1408   if (strcmp(LLVMGetDataLayoutStr(M), LLVMGetDataLayoutStr(Src)))
1409     report_fatal_error("Inconsistent DataLayout string representation");
1410 
1411   size_t ModuleInlineAsmLen;
1412   const char *ModuleAsm = LLVMGetModuleInlineAsm(Src, &ModuleInlineAsmLen);
1413   LLVMSetModuleInlineAsm2(M, ModuleAsm, ModuleInlineAsmLen);
1414 
1415   declare_symbols(Src, M);
1416   clone_symbols(Src, M);
1417   char *Str = LLVMPrintModuleToString(M);
1418   fputs(Str, stdout);
1419 
1420   LLVMDisposeMessage(Str);
1421   LLVMDisposeModule(Src);
1422   LLVMDisposeModule(M);
1423   LLVMContextDispose(Ctx);
1424 
1425   return 0;
1426 }
1427