mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 03:02:36 +01:00
1c866d4e4f
This is a followup to D103422. The DenseMapInfo implementations for ArrayRef and StringRef are moved into the ArrayRef.h and StringRef.h headers, which means that these two headers no longer need to be included by DenseMapInfo.h. This required adding a few additional includes, as many files were relying on various things pulled in by ArrayRef.h. Differential Revision: https://reviews.llvm.org/D103491
1407 lines
46 KiB
C++
1407 lines
46 KiB
C++
//===-- echo.cpp - tool for testing libLLVM and llvm-c API ----------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the --echo command in llvm-c-test.
|
|
//
|
|
// This command uses the C API to read a module and output an exact copy of it
|
|
// as output. It is used to check that the resulting module matches the input
|
|
// to validate that the C API can read and write modules properly.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm-c-test.h"
|
|
#include "llvm-c/DebugInfo.h"
|
|
#include "llvm-c/Target.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
using namespace llvm;
|
|
|
|
// Provide DenseMapInfo for C API opaque types.
|
|
template<typename T>
|
|
struct CAPIDenseMap {};
|
|
|
|
// The default DenseMapInfo require to know about pointer alignment.
|
|
// Because the C API uses opaque pointer types, their alignment is unknown.
|
|
// As a result, we need to roll out our own implementation.
|
|
template<typename T>
|
|
struct CAPIDenseMap<T*> {
|
|
struct CAPIDenseMapInfo {
|
|
static inline T* getEmptyKey() {
|
|
uintptr_t Val = static_cast<uintptr_t>(-1);
|
|
return reinterpret_cast<T*>(Val);
|
|
}
|
|
static inline T* getTombstoneKey() {
|
|
uintptr_t Val = static_cast<uintptr_t>(-2);
|
|
return reinterpret_cast<T*>(Val);
|
|
}
|
|
static unsigned getHashValue(const T *PtrVal) {
|
|
return hash_value(PtrVal);
|
|
}
|
|
static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
|
|
};
|
|
|
|
typedef DenseMap<T*, T*, CAPIDenseMapInfo> Map;
|
|
};
|
|
|
|
typedef CAPIDenseMap<LLVMValueRef>::Map ValueMap;
|
|
typedef CAPIDenseMap<LLVMBasicBlockRef>::Map BasicBlockMap;
|
|
|
|
struct TypeCloner {
|
|
LLVMModuleRef M;
|
|
LLVMContextRef Ctx;
|
|
|
|
TypeCloner(LLVMModuleRef M): M(M), Ctx(LLVMGetModuleContext(M)) {}
|
|
|
|
LLVMTypeRef Clone(LLVMValueRef Src) {
|
|
return Clone(LLVMTypeOf(Src));
|
|
}
|
|
|
|
LLVMTypeRef Clone(LLVMTypeRef Src) {
|
|
LLVMTypeKind Kind = LLVMGetTypeKind(Src);
|
|
switch (Kind) {
|
|
case LLVMVoidTypeKind:
|
|
return LLVMVoidTypeInContext(Ctx);
|
|
case LLVMHalfTypeKind:
|
|
return LLVMHalfTypeInContext(Ctx);
|
|
case LLVMBFloatTypeKind:
|
|
return LLVMHalfTypeInContext(Ctx);
|
|
case LLVMFloatTypeKind:
|
|
return LLVMFloatTypeInContext(Ctx);
|
|
case LLVMDoubleTypeKind:
|
|
return LLVMDoubleTypeInContext(Ctx);
|
|
case LLVMX86_FP80TypeKind:
|
|
return LLVMX86FP80TypeInContext(Ctx);
|
|
case LLVMFP128TypeKind:
|
|
return LLVMFP128TypeInContext(Ctx);
|
|
case LLVMPPC_FP128TypeKind:
|
|
return LLVMPPCFP128TypeInContext(Ctx);
|
|
case LLVMLabelTypeKind:
|
|
return LLVMLabelTypeInContext(Ctx);
|
|
case LLVMIntegerTypeKind:
|
|
return LLVMIntTypeInContext(Ctx, LLVMGetIntTypeWidth(Src));
|
|
case LLVMFunctionTypeKind: {
|
|
unsigned ParamCount = LLVMCountParamTypes(Src);
|
|
LLVMTypeRef* Params = nullptr;
|
|
if (ParamCount > 0) {
|
|
Params = static_cast<LLVMTypeRef*>(
|
|
safe_malloc(ParamCount * sizeof(LLVMTypeRef)));
|
|
LLVMGetParamTypes(Src, Params);
|
|
for (unsigned i = 0; i < ParamCount; i++)
|
|
Params[i] = Clone(Params[i]);
|
|
}
|
|
|
|
LLVMTypeRef FunTy = LLVMFunctionType(Clone(LLVMGetReturnType(Src)),
|
|
Params, ParamCount,
|
|
LLVMIsFunctionVarArg(Src));
|
|
if (ParamCount > 0)
|
|
free(Params);
|
|
return FunTy;
|
|
}
|
|
case LLVMStructTypeKind: {
|
|
LLVMTypeRef S = nullptr;
|
|
const char *Name = LLVMGetStructName(Src);
|
|
if (Name) {
|
|
S = LLVMGetTypeByName2(Ctx, Name);
|
|
if (S)
|
|
return S;
|
|
S = LLVMStructCreateNamed(Ctx, Name);
|
|
if (LLVMIsOpaqueStruct(Src))
|
|
return S;
|
|
}
|
|
|
|
unsigned EltCount = LLVMCountStructElementTypes(Src);
|
|
SmallVector<LLVMTypeRef, 8> Elts;
|
|
for (unsigned i = 0; i < EltCount; i++)
|
|
Elts.push_back(Clone(LLVMStructGetTypeAtIndex(Src, i)));
|
|
if (Name)
|
|
LLVMStructSetBody(S, Elts.data(), EltCount, LLVMIsPackedStruct(Src));
|
|
else
|
|
S = LLVMStructTypeInContext(Ctx, Elts.data(), EltCount,
|
|
LLVMIsPackedStruct(Src));
|
|
return S;
|
|
}
|
|
case LLVMArrayTypeKind:
|
|
return LLVMArrayType(
|
|
Clone(LLVMGetElementType(Src)),
|
|
LLVMGetArrayLength(Src)
|
|
);
|
|
case LLVMPointerTypeKind:
|
|
return LLVMPointerType(
|
|
Clone(LLVMGetElementType(Src)),
|
|
LLVMGetPointerAddressSpace(Src)
|
|
);
|
|
case LLVMVectorTypeKind:
|
|
return LLVMVectorType(
|
|
Clone(LLVMGetElementType(Src)),
|
|
LLVMGetVectorSize(Src)
|
|
);
|
|
case LLVMScalableVectorTypeKind:
|
|
return LLVMScalableVectorType(Clone(LLVMGetElementType(Src)),
|
|
LLVMGetVectorSize(Src));
|
|
case LLVMMetadataTypeKind:
|
|
return LLVMMetadataTypeInContext(Ctx);
|
|
case LLVMX86_AMXTypeKind:
|
|
return LLVMX86AMXTypeInContext(Ctx);
|
|
case LLVMX86_MMXTypeKind:
|
|
return LLVMX86MMXTypeInContext(Ctx);
|
|
case LLVMTokenTypeKind:
|
|
return LLVMTokenTypeInContext(Ctx);
|
|
}
|
|
|
|
fprintf(stderr, "%d is not a supported typekind\n", Kind);
|
|
exit(-1);
|
|
}
|
|
};
|
|
|
|
static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
|
|
unsigned Count = LLVMCountParams(Src);
|
|
if (Count != LLVMCountParams(Dst))
|
|
report_fatal_error("Parameter count mismatch");
|
|
|
|
ValueMap VMap;
|
|
if (Count == 0)
|
|
return VMap;
|
|
|
|
LLVMValueRef SrcFirst = LLVMGetFirstParam(Src);
|
|
LLVMValueRef DstFirst = LLVMGetFirstParam(Dst);
|
|
LLVMValueRef SrcLast = LLVMGetLastParam(Src);
|
|
LLVMValueRef DstLast = LLVMGetLastParam(Dst);
|
|
|
|
LLVMValueRef SrcCur = SrcFirst;
|
|
LLVMValueRef DstCur = DstFirst;
|
|
LLVMValueRef SrcNext = nullptr;
|
|
LLVMValueRef DstNext = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(SrcCur, &NameLen);
|
|
LLVMSetValueName2(DstCur, Name, NameLen);
|
|
|
|
VMap[SrcCur] = DstCur;
|
|
|
|
Count--;
|
|
SrcNext = LLVMGetNextParam(SrcCur);
|
|
DstNext = LLVMGetNextParam(DstCur);
|
|
if (SrcNext == nullptr && DstNext == nullptr) {
|
|
if (SrcCur != SrcLast)
|
|
report_fatal_error("SrcLast param does not match End");
|
|
if (DstCur != DstLast)
|
|
report_fatal_error("DstLast param does not match End");
|
|
break;
|
|
}
|
|
|
|
if (SrcNext == nullptr)
|
|
report_fatal_error("SrcNext was unexpectedly null");
|
|
if (DstNext == nullptr)
|
|
report_fatal_error("DstNext was unexpectedly null");
|
|
|
|
LLVMValueRef SrcPrev = LLVMGetPreviousParam(SrcNext);
|
|
if (SrcPrev != SrcCur)
|
|
report_fatal_error("SrcNext.Previous param is not Current");
|
|
|
|
LLVMValueRef DstPrev = LLVMGetPreviousParam(DstNext);
|
|
if (DstPrev != DstCur)
|
|
report_fatal_error("DstNext.Previous param is not Current");
|
|
|
|
SrcCur = SrcNext;
|
|
DstCur = DstNext;
|
|
}
|
|
|
|
if (Count != 0)
|
|
report_fatal_error("Parameter count does not match iteration");
|
|
|
|
return VMap;
|
|
}
|
|
|
|
static void check_value_kind(LLVMValueRef V, LLVMValueKind K) {
|
|
if (LLVMGetValueKind(V) != K)
|
|
report_fatal_error("LLVMGetValueKind returned incorrect type");
|
|
}
|
|
|
|
static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M);
|
|
|
|
static LLVMValueRef clone_constant(LLVMValueRef Cst, LLVMModuleRef M) {
|
|
LLVMValueRef Ret = clone_constant_impl(Cst, M);
|
|
check_value_kind(Ret, LLVMGetValueKind(Cst));
|
|
return Ret;
|
|
}
|
|
|
|
static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M) {
|
|
if (!LLVMIsAConstant(Cst))
|
|
report_fatal_error("Expected a constant");
|
|
|
|
// Maybe it is a symbol
|
|
if (LLVMIsAGlobalValue(Cst)) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cst, &NameLen);
|
|
|
|
// Try function
|
|
if (LLVMIsAFunction(Cst)) {
|
|
check_value_kind(Cst, LLVMFunctionValueKind);
|
|
|
|
LLVMValueRef Dst = nullptr;
|
|
// Try an intrinsic
|
|
unsigned ID = LLVMGetIntrinsicID(Cst);
|
|
if (ID > 0 && !LLVMIntrinsicIsOverloaded(ID)) {
|
|
Dst = LLVMGetIntrinsicDeclaration(M, ID, nullptr, 0);
|
|
} else {
|
|
// Try a normal function
|
|
Dst = LLVMGetNamedFunction(M, Name);
|
|
}
|
|
|
|
if (Dst)
|
|
return Dst;
|
|
report_fatal_error("Could not find function");
|
|
}
|
|
|
|
// Try global variable
|
|
if (LLVMIsAGlobalVariable(Cst)) {
|
|
check_value_kind(Cst, LLVMGlobalVariableValueKind);
|
|
LLVMValueRef Dst = LLVMGetNamedGlobal(M, Name);
|
|
if (Dst)
|
|
return Dst;
|
|
report_fatal_error("Could not find variable");
|
|
}
|
|
|
|
// Try global alias
|
|
if (LLVMIsAGlobalAlias(Cst)) {
|
|
check_value_kind(Cst, LLVMGlobalAliasValueKind);
|
|
LLVMValueRef Dst = LLVMGetNamedGlobalAlias(M, Name, NameLen);
|
|
if (Dst)
|
|
return Dst;
|
|
report_fatal_error("Could not find alias");
|
|
}
|
|
|
|
fprintf(stderr, "Could not find @%s\n", Name);
|
|
exit(-1);
|
|
}
|
|
|
|
// Try integer literal
|
|
if (LLVMIsAConstantInt(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantIntValueKind);
|
|
return LLVMConstInt(TypeCloner(M).Clone(Cst),
|
|
LLVMConstIntGetZExtValue(Cst), false);
|
|
}
|
|
|
|
// Try zeroinitializer
|
|
if (LLVMIsAConstantAggregateZero(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantAggregateZeroValueKind);
|
|
return LLVMConstNull(TypeCloner(M).Clone(Cst));
|
|
}
|
|
|
|
// Try constant array
|
|
if (LLVMIsAConstantArray(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantArrayValueKind);
|
|
LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
|
|
unsigned EltCount = LLVMGetArrayLength(Ty);
|
|
SmallVector<LLVMValueRef, 8> Elts;
|
|
for (unsigned i = 0; i < EltCount; i++)
|
|
Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
|
|
return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
|
|
}
|
|
|
|
// Try constant data array
|
|
if (LLVMIsAConstantDataArray(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantDataArrayValueKind);
|
|
LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
|
|
unsigned EltCount = LLVMGetArrayLength(Ty);
|
|
SmallVector<LLVMValueRef, 8> Elts;
|
|
for (unsigned i = 0; i < EltCount; i++)
|
|
Elts.push_back(clone_constant(LLVMGetElementAsConstant(Cst, i), M));
|
|
return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
|
|
}
|
|
|
|
// Try constant struct
|
|
if (LLVMIsAConstantStruct(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantStructValueKind);
|
|
LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
|
|
unsigned EltCount = LLVMCountStructElementTypes(Ty);
|
|
SmallVector<LLVMValueRef, 8> Elts;
|
|
for (unsigned i = 0; i < EltCount; i++)
|
|
Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
|
|
if (LLVMGetStructName(Ty))
|
|
return LLVMConstNamedStruct(Ty, Elts.data(), EltCount);
|
|
return LLVMConstStructInContext(LLVMGetModuleContext(M), Elts.data(),
|
|
EltCount, LLVMIsPackedStruct(Ty));
|
|
}
|
|
|
|
// Try ConstantPointerNull
|
|
if (LLVMIsAConstantPointerNull(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantPointerNullValueKind);
|
|
LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
|
|
return LLVMConstNull(Ty);
|
|
}
|
|
|
|
// Try undef
|
|
if (LLVMIsUndef(Cst)) {
|
|
check_value_kind(Cst, LLVMUndefValueValueKind);
|
|
return LLVMGetUndef(TypeCloner(M).Clone(Cst));
|
|
}
|
|
|
|
// Try poison
|
|
if (LLVMIsPoison(Cst)) {
|
|
check_value_kind(Cst, LLVMPoisonValueValueKind);
|
|
return LLVMGetPoison(TypeCloner(M).Clone(Cst));
|
|
}
|
|
|
|
// Try null
|
|
if (LLVMIsNull(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantTokenNoneValueKind);
|
|
LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
|
|
return LLVMConstNull(Ty);
|
|
}
|
|
|
|
// Try float literal
|
|
if (LLVMIsAConstantFP(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantFPValueKind);
|
|
report_fatal_error("ConstantFP is not supported");
|
|
}
|
|
|
|
// Try ConstantVector
|
|
if (LLVMIsAConstantVector(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantVectorValueKind);
|
|
LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
|
|
unsigned EltCount = LLVMGetVectorSize(Ty);
|
|
SmallVector<LLVMValueRef, 8> Elts;
|
|
for (unsigned i = 0; i < EltCount; i++)
|
|
Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
|
|
return LLVMConstVector(Elts.data(), EltCount);
|
|
}
|
|
|
|
// Try ConstantDataVector
|
|
if (LLVMIsAConstantDataVector(Cst)) {
|
|
check_value_kind(Cst, LLVMConstantDataVectorValueKind);
|
|
LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
|
|
unsigned EltCount = LLVMGetVectorSize(Ty);
|
|
SmallVector<LLVMValueRef, 8> Elts;
|
|
for (unsigned i = 0; i < EltCount; i++)
|
|
Elts.push_back(clone_constant(LLVMGetElementAsConstant(Cst, i), M));
|
|
return LLVMConstVector(Elts.data(), EltCount);
|
|
}
|
|
|
|
// At this point, if it's not a constant expression, it's a kind of constant
|
|
// which is not supported
|
|
if (!LLVMIsAConstantExpr(Cst))
|
|
report_fatal_error("Unsupported constant kind");
|
|
|
|
// At this point, it must be a constant expression
|
|
check_value_kind(Cst, LLVMConstantExprValueKind);
|
|
|
|
LLVMOpcode Op = LLVMGetConstOpcode(Cst);
|
|
switch(Op) {
|
|
case LLVMBitCast:
|
|
return LLVMConstBitCast(clone_constant(LLVMGetOperand(Cst, 0), M),
|
|
TypeCloner(M).Clone(Cst));
|
|
default:
|
|
fprintf(stderr, "%d is not a supported opcode for constant expressions\n",
|
|
Op);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
struct FunCloner {
|
|
LLVMValueRef Fun;
|
|
LLVMModuleRef M;
|
|
|
|
ValueMap VMap;
|
|
BasicBlockMap BBMap;
|
|
|
|
FunCloner(LLVMValueRef Src, LLVMValueRef Dst): Fun(Dst),
|
|
M(LLVMGetGlobalParent(Fun)), VMap(clone_params(Src, Dst)) {}
|
|
|
|
LLVMTypeRef CloneType(LLVMTypeRef Src) {
|
|
return TypeCloner(M).Clone(Src);
|
|
}
|
|
|
|
LLVMTypeRef CloneType(LLVMValueRef Src) {
|
|
return TypeCloner(M).Clone(Src);
|
|
}
|
|
|
|
// Try to clone everything in the llvm::Value hierarchy.
|
|
LLVMValueRef CloneValue(LLVMValueRef Src) {
|
|
// First, the value may be constant.
|
|
if (LLVMIsAConstant(Src))
|
|
return clone_constant(Src, M);
|
|
|
|
// Function argument should always be in the map already.
|
|
auto i = VMap.find(Src);
|
|
if (i != VMap.end())
|
|
return i->second;
|
|
|
|
if (!LLVMIsAInstruction(Src))
|
|
report_fatal_error("Expected an instruction");
|
|
|
|
auto Ctx = LLVMGetModuleContext(M);
|
|
auto Builder = LLVMCreateBuilderInContext(Ctx);
|
|
auto BB = DeclareBB(LLVMGetInstructionParent(Src));
|
|
LLVMPositionBuilderAtEnd(Builder, BB);
|
|
auto Dst = CloneInstruction(Src, Builder);
|
|
LLVMDisposeBuilder(Builder);
|
|
return Dst;
|
|
}
|
|
|
|
void CloneAttrs(LLVMValueRef Src, LLVMValueRef Dst) {
|
|
auto Ctx = LLVMGetModuleContext(M);
|
|
int ArgCount = LLVMGetNumArgOperands(Src);
|
|
for (int i = LLVMAttributeReturnIndex; i <= ArgCount; i++) {
|
|
for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
|
|
if (auto SrcA = LLVMGetCallSiteEnumAttribute(Src, i, k)) {
|
|
auto Val = LLVMGetEnumAttributeValue(SrcA);
|
|
auto A = LLVMCreateEnumAttribute(Ctx, k, Val);
|
|
LLVMAddCallSiteAttribute(Dst, i, A);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
|
|
check_value_kind(Src, LLVMInstructionValueKind);
|
|
if (!LLVMIsAInstruction(Src))
|
|
report_fatal_error("Expected an instruction");
|
|
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Src, &NameLen);
|
|
|
|
// Check if this is something we already computed.
|
|
{
|
|
auto i = VMap.find(Src);
|
|
if (i != VMap.end()) {
|
|
// If we have a hit, it means we already generated the instruction
|
|
// as a dependency to something else. We need to make sure
|
|
// it is ordered properly.
|
|
auto I = i->second;
|
|
LLVMInstructionRemoveFromParent(I);
|
|
LLVMInsertIntoBuilderWithName(Builder, I, Name);
|
|
return I;
|
|
}
|
|
}
|
|
|
|
// We tried everything, it must be an instruction
|
|
// that hasn't been generated already.
|
|
LLVMValueRef Dst = nullptr;
|
|
|
|
LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
|
|
switch(Op) {
|
|
case LLVMRet: {
|
|
int OpCount = LLVMGetNumOperands(Src);
|
|
if (OpCount == 0)
|
|
Dst = LLVMBuildRetVoid(Builder);
|
|
else
|
|
Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0)));
|
|
break;
|
|
}
|
|
case LLVMBr: {
|
|
if (!LLVMIsConditional(Src)) {
|
|
LLVMValueRef SrcOp = LLVMGetOperand(Src, 0);
|
|
LLVMBasicBlockRef SrcBB = LLVMValueAsBasicBlock(SrcOp);
|
|
Dst = LLVMBuildBr(Builder, DeclareBB(SrcBB));
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Cond = LLVMGetCondition(Src);
|
|
LLVMValueRef Else = LLVMGetOperand(Src, 1);
|
|
LLVMBasicBlockRef ElseBB = DeclareBB(LLVMValueAsBasicBlock(Else));
|
|
LLVMValueRef Then = LLVMGetOperand(Src, 2);
|
|
LLVMBasicBlockRef ThenBB = DeclareBB(LLVMValueAsBasicBlock(Then));
|
|
Dst = LLVMBuildCondBr(Builder, CloneValue(Cond), ThenBB, ElseBB);
|
|
break;
|
|
}
|
|
case LLVMSwitch:
|
|
case LLVMIndirectBr:
|
|
break;
|
|
case LLVMInvoke: {
|
|
SmallVector<LLVMValueRef, 8> Args;
|
|
int ArgCount = LLVMGetNumArgOperands(Src);
|
|
for (int i = 0; i < ArgCount; i++)
|
|
Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
|
|
LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
|
|
LLVMBasicBlockRef Then = DeclareBB(LLVMGetNormalDest(Src));
|
|
LLVMBasicBlockRef Unwind = DeclareBB(LLVMGetUnwindDest(Src));
|
|
Dst = LLVMBuildInvoke(Builder, Fn, Args.data(), ArgCount,
|
|
Then, Unwind, Name);
|
|
CloneAttrs(Src, Dst);
|
|
break;
|
|
}
|
|
case LLVMUnreachable:
|
|
Dst = LLVMBuildUnreachable(Builder);
|
|
break;
|
|
case LLVMAdd: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildAdd(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMSub: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildSub(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMMul: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildMul(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMUDiv: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildUDiv(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMSDiv: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildSDiv(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMURem: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildURem(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMSRem: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildSRem(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMShl: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildShl(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMLShr: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildLShr(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMAShr: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildAShr(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMAnd: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildAnd(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMOr: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildOr(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMXor: {
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildXor(Builder, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMAlloca: {
|
|
LLVMTypeRef Ty = CloneType(LLVMGetAllocatedType(Src));
|
|
Dst = LLVMBuildAlloca(Builder, Ty, Name);
|
|
LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
|
|
break;
|
|
}
|
|
case LLVMLoad: {
|
|
LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
|
|
Dst = LLVMBuildLoad(Builder, Ptr, Name);
|
|
LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
|
|
LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
|
|
LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
|
|
break;
|
|
}
|
|
case LLVMStore: {
|
|
LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildStore(Builder, Val, Ptr);
|
|
LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
|
|
LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
|
|
LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
|
|
break;
|
|
}
|
|
case LLVMGetElementPtr: {
|
|
LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
|
|
SmallVector<LLVMValueRef, 8> Idx;
|
|
int NumIdx = LLVMGetNumIndices(Src);
|
|
for (int i = 1; i <= NumIdx; i++)
|
|
Idx.push_back(CloneValue(LLVMGetOperand(Src, i)));
|
|
if (LLVMIsInBounds(Src))
|
|
Dst = LLVMBuildInBoundsGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
|
|
else
|
|
Dst = LLVMBuildGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
|
|
break;
|
|
}
|
|
case LLVMAtomicRMW: {
|
|
LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 1));
|
|
LLVMAtomicRMWBinOp BinOp = LLVMGetAtomicRMWBinOp(Src);
|
|
LLVMAtomicOrdering Ord = LLVMGetOrdering(Src);
|
|
LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
|
|
Dst = LLVMBuildAtomicRMW(Builder, BinOp, Ptr, Val, Ord, SingleThread);
|
|
LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
|
|
LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
|
|
LLVMSetValueName2(Dst, Name, NameLen);
|
|
break;
|
|
}
|
|
case LLVMAtomicCmpXchg: {
|
|
LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef Cmp = CloneValue(LLVMGetOperand(Src, 1));
|
|
LLVMValueRef New = CloneValue(LLVMGetOperand(Src, 2));
|
|
LLVMAtomicOrdering Succ = LLVMGetCmpXchgSuccessOrdering(Src);
|
|
LLVMAtomicOrdering Fail = LLVMGetCmpXchgFailureOrdering(Src);
|
|
LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
|
|
|
|
Dst = LLVMBuildAtomicCmpXchg(Builder, Ptr, Cmp, New, Succ, Fail,
|
|
SingleThread);
|
|
LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
|
|
LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
|
|
LLVMSetWeak(Dst, LLVMGetWeak(Src));
|
|
LLVMSetValueName2(Dst, Name, NameLen);
|
|
break;
|
|
}
|
|
case LLVMBitCast: {
|
|
LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 0));
|
|
Dst = LLVMBuildBitCast(Builder, V, CloneType(Src), Name);
|
|
break;
|
|
}
|
|
case LLVMICmp: {
|
|
LLVMIntPredicate Pred = LLVMGetICmpPredicate(Src);
|
|
LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildICmp(Builder, Pred, LHS, RHS, Name);
|
|
break;
|
|
}
|
|
case LLVMPHI: {
|
|
// We need to aggressively set things here because of loops.
|
|
VMap[Src] = Dst = LLVMBuildPhi(Builder, CloneType(Src), Name);
|
|
|
|
SmallVector<LLVMValueRef, 8> Values;
|
|
SmallVector<LLVMBasicBlockRef, 8> Blocks;
|
|
|
|
unsigned IncomingCount = LLVMCountIncoming(Src);
|
|
for (unsigned i = 0; i < IncomingCount; ++i) {
|
|
Blocks.push_back(DeclareBB(LLVMGetIncomingBlock(Src, i)));
|
|
Values.push_back(CloneValue(LLVMGetIncomingValue(Src, i)));
|
|
}
|
|
|
|
LLVMAddIncoming(Dst, Values.data(), Blocks.data(), IncomingCount);
|
|
return Dst;
|
|
}
|
|
case LLVMCall: {
|
|
SmallVector<LLVMValueRef, 8> Args;
|
|
int ArgCount = LLVMGetNumArgOperands(Src);
|
|
for (int i = 0; i < ArgCount; i++)
|
|
Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
|
|
LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
|
|
Dst = LLVMBuildCall(Builder, Fn, Args.data(), ArgCount, Name);
|
|
LLVMSetTailCall(Dst, LLVMIsTailCall(Src));
|
|
CloneAttrs(Src, Dst);
|
|
break;
|
|
}
|
|
case LLVMResume: {
|
|
Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
|
|
break;
|
|
}
|
|
case LLVMLandingPad: {
|
|
// The landing pad API is a bit screwed up for historical reasons.
|
|
Dst = LLVMBuildLandingPad(Builder, CloneType(Src), nullptr, 0, Name);
|
|
unsigned NumClauses = LLVMGetNumClauses(Src);
|
|
for (unsigned i = 0; i < NumClauses; ++i)
|
|
LLVMAddClause(Dst, CloneValue(LLVMGetClause(Src, i)));
|
|
LLVMSetCleanup(Dst, LLVMIsCleanup(Src));
|
|
break;
|
|
}
|
|
case LLVMCleanupRet: {
|
|
LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMBasicBlockRef Unwind = nullptr;
|
|
if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src))
|
|
Unwind = DeclareBB(UDest);
|
|
Dst = LLVMBuildCleanupRet(Builder, CatchPad, Unwind);
|
|
break;
|
|
}
|
|
case LLVMCatchRet: {
|
|
LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMBasicBlockRef SuccBB = DeclareBB(LLVMGetSuccessor(Src, 0));
|
|
Dst = LLVMBuildCatchRet(Builder, CatchPad, SuccBB);
|
|
break;
|
|
}
|
|
case LLVMCatchPad: {
|
|
LLVMValueRef ParentPad = CloneValue(LLVMGetParentCatchSwitch(Src));
|
|
SmallVector<LLVMValueRef, 8> Args;
|
|
int ArgCount = LLVMGetNumArgOperands(Src);
|
|
for (int i = 0; i < ArgCount; i++)
|
|
Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
|
|
Dst = LLVMBuildCatchPad(Builder, ParentPad,
|
|
Args.data(), ArgCount, Name);
|
|
break;
|
|
}
|
|
case LLVMCleanupPad: {
|
|
LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
|
|
SmallVector<LLVMValueRef, 8> Args;
|
|
int ArgCount = LLVMGetNumArgOperands(Src);
|
|
for (int i = 0; i < ArgCount; i++)
|
|
Args.push_back(CloneValue(LLVMGetArgOperand(Src, i)));
|
|
Dst = LLVMBuildCleanupPad(Builder, ParentPad,
|
|
Args.data(), ArgCount, Name);
|
|
break;
|
|
}
|
|
case LLVMCatchSwitch: {
|
|
LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMBasicBlockRef UnwindBB = nullptr;
|
|
if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src)) {
|
|
UnwindBB = DeclareBB(UDest);
|
|
}
|
|
unsigned NumHandlers = LLVMGetNumHandlers(Src);
|
|
Dst = LLVMBuildCatchSwitch(Builder, ParentPad, UnwindBB, NumHandlers, Name);
|
|
if (NumHandlers > 0) {
|
|
LLVMBasicBlockRef *Handlers = static_cast<LLVMBasicBlockRef*>(
|
|
safe_malloc(NumHandlers * sizeof(LLVMBasicBlockRef)));
|
|
LLVMGetHandlers(Src, Handlers);
|
|
for (unsigned i = 0; i < NumHandlers; i++)
|
|
LLVMAddHandler(Dst, DeclareBB(Handlers[i]));
|
|
free(Handlers);
|
|
}
|
|
break;
|
|
}
|
|
case LLVMExtractValue: {
|
|
LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
|
|
if (LLVMGetNumIndices(Src) > 1)
|
|
report_fatal_error("ExtractValue: Expected only one index");
|
|
else if (LLVMGetNumIndices(Src) < 1)
|
|
report_fatal_error("ExtractValue: Expected an index");
|
|
auto I = LLVMGetIndices(Src)[0];
|
|
Dst = LLVMBuildExtractValue(Builder, Agg, I, Name);
|
|
break;
|
|
}
|
|
case LLVMInsertValue: {
|
|
LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
|
|
if (LLVMGetNumIndices(Src) > 1)
|
|
report_fatal_error("InsertValue: Expected only one index");
|
|
else if (LLVMGetNumIndices(Src) < 1)
|
|
report_fatal_error("InsertValue: Expected an index");
|
|
auto I = LLVMGetIndices(Src)[0];
|
|
Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
|
|
break;
|
|
}
|
|
case LLVMExtractElement: {
|
|
LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 1));
|
|
Dst = LLVMBuildExtractElement(Builder, Agg, Index, Name);
|
|
break;
|
|
}
|
|
case LLVMInsertElement: {
|
|
LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
|
|
LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 2));
|
|
Dst = LLVMBuildInsertElement(Builder, Agg, V, Index, Name);
|
|
break;
|
|
}
|
|
case LLVMShuffleVector: {
|
|
LLVMValueRef Agg0 = CloneValue(LLVMGetOperand(Src, 0));
|
|
LLVMValueRef Agg1 = CloneValue(LLVMGetOperand(Src, 1));
|
|
SmallVector<LLVMValueRef, 8> MaskElts;
|
|
unsigned NumMaskElts = LLVMGetNumMaskElements(Src);
|
|
for (unsigned i = 0; i < NumMaskElts; i++) {
|
|
int Val = LLVMGetMaskValue(Src, i);
|
|
if (Val == LLVMGetUndefMaskElem()) {
|
|
MaskElts.push_back(LLVMGetUndef(LLVMInt64Type()));
|
|
} else {
|
|
MaskElts.push_back(LLVMConstInt(LLVMInt64Type(), Val, true));
|
|
}
|
|
}
|
|
LLVMValueRef Mask = LLVMConstVector(MaskElts.data(), NumMaskElts);
|
|
Dst = LLVMBuildShuffleVector(Builder, Agg0, Agg1, Mask, Name);
|
|
break;
|
|
}
|
|
case LLVMFreeze: {
|
|
LLVMValueRef Arg = CloneValue(LLVMGetOperand(Src, 0));
|
|
Dst = LLVMBuildFreeze(Builder, Arg, Name);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (Dst == nullptr) {
|
|
fprintf(stderr, "%d is not a supported opcode\n", Op);
|
|
exit(-1);
|
|
}
|
|
|
|
auto Ctx = LLVMGetModuleContext(M);
|
|
size_t NumMetadataEntries;
|
|
auto *AllMetadata =
|
|
LLVMInstructionGetAllMetadataOtherThanDebugLoc(Src,
|
|
&NumMetadataEntries);
|
|
for (unsigned i = 0; i < NumMetadataEntries; ++i) {
|
|
unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
|
|
LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
|
|
LLVMSetMetadata(Dst, Kind, LLVMMetadataAsValue(Ctx, MD));
|
|
}
|
|
LLVMDisposeValueMetadataEntries(AllMetadata);
|
|
LLVMSetInstDebugLocation(Builder, Dst);
|
|
|
|
check_value_kind(Dst, LLVMInstructionValueKind);
|
|
return VMap[Src] = Dst;
|
|
}
|
|
|
|
LLVMBasicBlockRef DeclareBB(LLVMBasicBlockRef Src) {
|
|
// Check if this is something we already computed.
|
|
{
|
|
auto i = BBMap.find(Src);
|
|
if (i != BBMap.end()) {
|
|
return i->second;
|
|
}
|
|
}
|
|
|
|
LLVMValueRef V = LLVMBasicBlockAsValue(Src);
|
|
if (!LLVMValueIsBasicBlock(V) || LLVMValueAsBasicBlock(V) != Src)
|
|
report_fatal_error("Basic block is not a basic block");
|
|
|
|
const char *Name = LLVMGetBasicBlockName(Src);
|
|
size_t NameLen;
|
|
const char *VName = LLVMGetValueName2(V, &NameLen);
|
|
if (Name != VName)
|
|
report_fatal_error("Basic block name mismatch");
|
|
|
|
LLVMBasicBlockRef BB = LLVMAppendBasicBlock(Fun, Name);
|
|
return BBMap[Src] = BB;
|
|
}
|
|
|
|
LLVMBasicBlockRef CloneBB(LLVMBasicBlockRef Src) {
|
|
LLVMBasicBlockRef BB = DeclareBB(Src);
|
|
|
|
// Make sure ordering is correct.
|
|
LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Src);
|
|
if (Prev)
|
|
LLVMMoveBasicBlockAfter(BB, DeclareBB(Prev));
|
|
|
|
LLVMValueRef First = LLVMGetFirstInstruction(Src);
|
|
LLVMValueRef Last = LLVMGetLastInstruction(Src);
|
|
|
|
if (First == nullptr) {
|
|
if (Last != nullptr)
|
|
report_fatal_error("Has no first instruction, but last one");
|
|
return BB;
|
|
}
|
|
|
|
auto Ctx = LLVMGetModuleContext(M);
|
|
LLVMBuilderRef Builder = LLVMCreateBuilderInContext(Ctx);
|
|
LLVMPositionBuilderAtEnd(Builder, BB);
|
|
|
|
LLVMValueRef Cur = First;
|
|
LLVMValueRef Next = nullptr;
|
|
while(true) {
|
|
CloneInstruction(Cur, Builder);
|
|
Next = LLVMGetNextInstruction(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != Last)
|
|
report_fatal_error("Final instruction does not match Last");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousInstruction(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous instruction is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
LLVMDisposeBuilder(Builder);
|
|
return BB;
|
|
}
|
|
|
|
void CloneBBs(LLVMValueRef Src) {
|
|
unsigned Count = LLVMCountBasicBlocks(Src);
|
|
if (Count == 0)
|
|
return;
|
|
|
|
LLVMBasicBlockRef First = LLVMGetFirstBasicBlock(Src);
|
|
LLVMBasicBlockRef Last = LLVMGetLastBasicBlock(Src);
|
|
|
|
LLVMBasicBlockRef Cur = First;
|
|
LLVMBasicBlockRef Next = nullptr;
|
|
while(true) {
|
|
CloneBB(Cur);
|
|
Count--;
|
|
Next = LLVMGetNextBasicBlock(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != Last)
|
|
report_fatal_error("Final basic block does not match Last");
|
|
break;
|
|
}
|
|
|
|
LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous basic bloc is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
if (Count != 0)
|
|
report_fatal_error("Basic block count does not match iterration");
|
|
}
|
|
};
|
|
|
|
static void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
|
|
auto Ctx = LLVMGetModuleContext(M);
|
|
|
|
LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
|
|
LLVMValueRef End = LLVMGetLastGlobal(Src);
|
|
|
|
LLVMValueRef Cur = Begin;
|
|
LLVMValueRef Next = nullptr;
|
|
if (!Begin) {
|
|
if (End != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
goto FunDecl;
|
|
}
|
|
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cur, &NameLen);
|
|
if (LLVMGetNamedGlobal(M, Name))
|
|
report_fatal_error("GlobalVariable already cloned");
|
|
LLVMAddGlobal(M, LLVMGetElementType(TypeCloner(M).Clone(Cur)), Name);
|
|
|
|
Next = LLVMGetNextGlobal(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != End)
|
|
report_fatal_error("");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous global is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
FunDecl:
|
|
Begin = LLVMGetFirstFunction(Src);
|
|
End = LLVMGetLastFunction(Src);
|
|
if (!Begin) {
|
|
if (End != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
goto AliasDecl;
|
|
}
|
|
|
|
Cur = Begin;
|
|
Next = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cur, &NameLen);
|
|
if (LLVMGetNamedFunction(M, Name))
|
|
report_fatal_error("Function already cloned");
|
|
auto Ty = LLVMGetElementType(TypeCloner(M).Clone(Cur));
|
|
auto F = LLVMAddFunction(M, Name, Ty);
|
|
|
|
// Copy attributes
|
|
for (int i = LLVMAttributeFunctionIndex, c = LLVMCountParams(F);
|
|
i <= c; ++i) {
|
|
for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
|
|
if (auto SrcA = LLVMGetEnumAttributeAtIndex(Cur, i, k)) {
|
|
auto Val = LLVMGetEnumAttributeValue(SrcA);
|
|
auto DstA = LLVMCreateEnumAttribute(Ctx, k, Val);
|
|
LLVMAddAttributeAtIndex(F, i, DstA);
|
|
}
|
|
}
|
|
}
|
|
|
|
Next = LLVMGetNextFunction(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != End)
|
|
report_fatal_error("Last function does not match End");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous function is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
AliasDecl:
|
|
Begin = LLVMGetFirstGlobalAlias(Src);
|
|
End = LLVMGetLastGlobalAlias(Src);
|
|
if (!Begin) {
|
|
if (End != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
goto GlobalIFuncDecl;
|
|
}
|
|
|
|
Cur = Begin;
|
|
Next = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cur, &NameLen);
|
|
if (LLVMGetNamedGlobalAlias(M, Name, NameLen))
|
|
report_fatal_error("Global alias already cloned");
|
|
LLVMTypeRef CurType = TypeCloner(M).Clone(Cur);
|
|
// FIXME: Allow NULL aliasee.
|
|
LLVMAddAlias(M, CurType, LLVMGetUndef(CurType), Name);
|
|
|
|
Next = LLVMGetNextGlobalAlias(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != End)
|
|
report_fatal_error("");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous global is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
GlobalIFuncDecl:
|
|
Begin = LLVMGetFirstGlobalIFunc(Src);
|
|
End = LLVMGetLastGlobalIFunc(Src);
|
|
if (!Begin) {
|
|
if (End != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
goto NamedMDDecl;
|
|
}
|
|
|
|
Cur = Begin;
|
|
Next = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cur, &NameLen);
|
|
if (LLVMGetNamedGlobalIFunc(M, Name, NameLen))
|
|
report_fatal_error("Global ifunc already cloned");
|
|
LLVMTypeRef CurType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
|
|
// FIXME: Allow NULL resolver.
|
|
LLVMAddGlobalIFunc(M, Name, NameLen,
|
|
CurType, /*addressSpace*/ 0, LLVMGetUndef(CurType));
|
|
|
|
Next = LLVMGetNextGlobalIFunc(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != End)
|
|
report_fatal_error("");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous global is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
NamedMDDecl:
|
|
LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
|
|
LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
|
|
if (!BeginMD) {
|
|
if (EndMD != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
return;
|
|
}
|
|
|
|
LLVMNamedMDNodeRef CurMD = BeginMD;
|
|
LLVMNamedMDNodeRef NextMD = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
|
|
if (LLVMGetNamedMetadata(M, Name, NameLen))
|
|
report_fatal_error("Named Metadata Node already cloned");
|
|
LLVMGetOrInsertNamedMetadata(M, Name, NameLen);
|
|
|
|
NextMD = LLVMGetNextNamedMetadata(CurMD);
|
|
if (NextMD == nullptr) {
|
|
if (CurMD != EndMD)
|
|
report_fatal_error("");
|
|
break;
|
|
}
|
|
|
|
LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
|
|
if (PrevMD != CurMD)
|
|
report_fatal_error("Next.Previous global is not Current");
|
|
|
|
CurMD = NextMD;
|
|
}
|
|
}
|
|
|
|
static void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
|
|
LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
|
|
LLVMValueRef End = LLVMGetLastGlobal(Src);
|
|
|
|
LLVMValueRef Cur = Begin;
|
|
LLVMValueRef Next = nullptr;
|
|
if (!Begin) {
|
|
if (End != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
goto FunClone;
|
|
}
|
|
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cur, &NameLen);
|
|
LLVMValueRef G = LLVMGetNamedGlobal(M, Name);
|
|
if (!G)
|
|
report_fatal_error("GlobalVariable must have been declared already");
|
|
|
|
if (auto I = LLVMGetInitializer(Cur))
|
|
LLVMSetInitializer(G, clone_constant(I, M));
|
|
|
|
size_t NumMetadataEntries;
|
|
auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
|
|
for (unsigned i = 0; i < NumMetadataEntries; ++i) {
|
|
unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
|
|
LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
|
|
LLVMGlobalSetMetadata(G, Kind, MD);
|
|
}
|
|
LLVMDisposeValueMetadataEntries(AllMetadata);
|
|
|
|
LLVMSetGlobalConstant(G, LLVMIsGlobalConstant(Cur));
|
|
LLVMSetThreadLocal(G, LLVMIsThreadLocal(Cur));
|
|
LLVMSetExternallyInitialized(G, LLVMIsExternallyInitialized(Cur));
|
|
LLVMSetLinkage(G, LLVMGetLinkage(Cur));
|
|
LLVMSetSection(G, LLVMGetSection(Cur));
|
|
LLVMSetVisibility(G, LLVMGetVisibility(Cur));
|
|
LLVMSetUnnamedAddress(G, LLVMGetUnnamedAddress(Cur));
|
|
LLVMSetAlignment(G, LLVMGetAlignment(Cur));
|
|
|
|
Next = LLVMGetNextGlobal(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != End)
|
|
report_fatal_error("");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous global is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
FunClone:
|
|
Begin = LLVMGetFirstFunction(Src);
|
|
End = LLVMGetLastFunction(Src);
|
|
if (!Begin) {
|
|
if (End != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
goto AliasClone;
|
|
}
|
|
|
|
Cur = Begin;
|
|
Next = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cur, &NameLen);
|
|
LLVMValueRef Fun = LLVMGetNamedFunction(M, Name);
|
|
if (!Fun)
|
|
report_fatal_error("Function must have been declared already");
|
|
|
|
if (LLVMHasPersonalityFn(Cur)) {
|
|
size_t FNameLen;
|
|
const char *FName = LLVMGetValueName2(LLVMGetPersonalityFn(Cur),
|
|
&FNameLen);
|
|
LLVMValueRef P = LLVMGetNamedFunction(M, FName);
|
|
if (!P)
|
|
report_fatal_error("Could not find personality function");
|
|
LLVMSetPersonalityFn(Fun, P);
|
|
}
|
|
|
|
size_t NumMetadataEntries;
|
|
auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
|
|
for (unsigned i = 0; i < NumMetadataEntries; ++i) {
|
|
unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
|
|
LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
|
|
LLVMGlobalSetMetadata(Fun, Kind, MD);
|
|
}
|
|
LLVMDisposeValueMetadataEntries(AllMetadata);
|
|
|
|
FunCloner FC(Cur, Fun);
|
|
FC.CloneBBs(Cur);
|
|
|
|
Next = LLVMGetNextFunction(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != End)
|
|
report_fatal_error("Last function does not match End");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous function is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
AliasClone:
|
|
Begin = LLVMGetFirstGlobalAlias(Src);
|
|
End = LLVMGetLastGlobalAlias(Src);
|
|
if (!Begin) {
|
|
if (End != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
goto GlobalIFuncClone;
|
|
}
|
|
|
|
Cur = Begin;
|
|
Next = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cur, &NameLen);
|
|
LLVMValueRef Alias = LLVMGetNamedGlobalAlias(M, Name, NameLen);
|
|
if (!Alias)
|
|
report_fatal_error("Global alias must have been declared already");
|
|
|
|
if (LLVMValueRef Aliasee = LLVMAliasGetAliasee(Cur)) {
|
|
LLVMAliasSetAliasee(Alias, clone_constant(Aliasee, M));
|
|
}
|
|
|
|
LLVMSetLinkage(Alias, LLVMGetLinkage(Cur));
|
|
LLVMSetUnnamedAddress(Alias, LLVMGetUnnamedAddress(Cur));
|
|
|
|
Next = LLVMGetNextGlobalAlias(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != End)
|
|
report_fatal_error("Last global alias does not match End");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous global alias is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
GlobalIFuncClone:
|
|
Begin = LLVMGetFirstGlobalIFunc(Src);
|
|
End = LLVMGetLastGlobalIFunc(Src);
|
|
if (!Begin) {
|
|
if (End != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
goto NamedMDClone;
|
|
}
|
|
|
|
Cur = Begin;
|
|
Next = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetValueName2(Cur, &NameLen);
|
|
LLVMValueRef IFunc = LLVMGetNamedGlobalIFunc(M, Name, NameLen);
|
|
if (!IFunc)
|
|
report_fatal_error("Global ifunc must have been declared already");
|
|
|
|
if (LLVMValueRef Resolver = LLVMGetGlobalIFuncResolver(Cur)) {
|
|
LLVMSetGlobalIFuncResolver(IFunc, clone_constant(Resolver, M));
|
|
}
|
|
|
|
LLVMSetLinkage(IFunc, LLVMGetLinkage(Cur));
|
|
LLVMSetUnnamedAddress(IFunc, LLVMGetUnnamedAddress(Cur));
|
|
|
|
Next = LLVMGetNextGlobalIFunc(Cur);
|
|
if (Next == nullptr) {
|
|
if (Cur != End)
|
|
report_fatal_error("Last global alias does not match End");
|
|
break;
|
|
}
|
|
|
|
LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
|
|
if (Prev != Cur)
|
|
report_fatal_error("Next.Previous global alias is not Current");
|
|
|
|
Cur = Next;
|
|
}
|
|
|
|
NamedMDClone:
|
|
LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
|
|
LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
|
|
if (!BeginMD) {
|
|
if (EndMD != nullptr)
|
|
report_fatal_error("Range has an end but no beginning");
|
|
return;
|
|
}
|
|
|
|
LLVMNamedMDNodeRef CurMD = BeginMD;
|
|
LLVMNamedMDNodeRef NextMD = nullptr;
|
|
while (true) {
|
|
size_t NameLen;
|
|
const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
|
|
LLVMNamedMDNodeRef NamedMD = LLVMGetNamedMetadata(M, Name, NameLen);
|
|
if (!NamedMD)
|
|
report_fatal_error("Named MD Node must have been declared already");
|
|
|
|
unsigned OperandCount = LLVMGetNamedMetadataNumOperands(Src, Name);
|
|
LLVMValueRef *OperandBuf = static_cast<LLVMValueRef *>(
|
|
safe_malloc(OperandCount * sizeof(LLVMValueRef)));
|
|
LLVMGetNamedMetadataOperands(Src, Name, OperandBuf);
|
|
for (unsigned i = 0, e = OperandCount; i != e; ++i) {
|
|
LLVMAddNamedMetadataOperand(M, Name, OperandBuf[i]);
|
|
}
|
|
free(OperandBuf);
|
|
|
|
NextMD = LLVMGetNextNamedMetadata(CurMD);
|
|
if (NextMD == nullptr) {
|
|
if (CurMD != EndMD)
|
|
report_fatal_error("Last Named MD Node does not match End");
|
|
break;
|
|
}
|
|
|
|
LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
|
|
if (PrevMD != CurMD)
|
|
report_fatal_error("Next.Previous Named MD Node is not Current");
|
|
|
|
CurMD = NextMD;
|
|
}
|
|
}
|
|
|
|
int llvm_echo(void) {
|
|
LLVMEnablePrettyStackTrace();
|
|
|
|
LLVMModuleRef Src = llvm_load_module(false, true);
|
|
size_t SourceFileLen;
|
|
const char *SourceFileName = LLVMGetSourceFileName(Src, &SourceFileLen);
|
|
size_t ModuleIdentLen;
|
|
const char *ModuleName = LLVMGetModuleIdentifier(Src, &ModuleIdentLen);
|
|
LLVMContextRef Ctx = LLVMContextCreate();
|
|
LLVMModuleRef M = LLVMModuleCreateWithNameInContext(ModuleName, Ctx);
|
|
|
|
LLVMSetSourceFileName(M, SourceFileName, SourceFileLen);
|
|
LLVMSetModuleIdentifier(M, ModuleName, ModuleIdentLen);
|
|
|
|
LLVMSetTarget(M, LLVMGetTarget(Src));
|
|
LLVMSetModuleDataLayout(M, LLVMGetModuleDataLayout(Src));
|
|
if (strcmp(LLVMGetDataLayoutStr(M), LLVMGetDataLayoutStr(Src)))
|
|
report_fatal_error("Inconsistent DataLayout string representation");
|
|
|
|
size_t ModuleInlineAsmLen;
|
|
const char *ModuleAsm = LLVMGetModuleInlineAsm(Src, &ModuleInlineAsmLen);
|
|
LLVMSetModuleInlineAsm2(M, ModuleAsm, ModuleInlineAsmLen);
|
|
|
|
declare_symbols(Src, M);
|
|
clone_symbols(Src, M);
|
|
char *Str = LLVMPrintModuleToString(M);
|
|
fputs(Str, stdout);
|
|
|
|
LLVMDisposeMessage(Str);
|
|
LLVMDisposeModule(Src);
|
|
LLVMDisposeModule(M);
|
|
LLVMContextDispose(Ctx);
|
|
|
|
return 0;
|
|
}
|