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