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