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