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