This is an archive of the discontinued LLVM Phabricator instance.

Differential D56573

Remove TypeBuilder.h, and fix the few locations using it.
ClosedPublic

Authored by jyknight on Jan 10 2019, 6:33 PM.

Details

Reviewers
niravd
Commits
rGc0044118c8ec: Remove TypeBuilder.h, and fix the few locations using it.
rL351020: Remove TypeBuilder.h, and fix the few locations using it.
Summary

This shortcut mechanism for creating types was added 10 years ago, but
has seen almost no uptake since then, neither internally nor in
external projects.

The very small number of characters saved by using it does not seem
worth the mental overhead of an additional type-creation API, so,
delete it.

Diff Detail

Repository
rL LLVM

Event Timeline

jyknight created this revision.Jan 10 2019, 6:33 PM
Herald added a subscriber: mgorny. · View Herald TranscriptJan 10 2019, 6:33 PM
Harbormaster completed remote builds in B26673: Diff 181202.Jan 10 2019, 6:34 PM
niravd accepted this revision.Jan 11 2019, 12:13 PM

LGTM.

This revision is now accepted and ready to land.Jan 11 2019, 12:13 PM
Closed by commit rL351020: Remove TypeBuilder.h, and fix the few locations using it. (authored by jyknight). · Explain WhyJan 13 2019, 8:13 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
docs/
8 lines
31 lines
include/
llvm/
IR/
407 lines
tools/
lli/
26 lines
unittests/
ExecutionEngine/
MCJIT/
9 lines
44 lines
60 lines
Orc/
5 lines
19 lines
11 lines
20 lines
18 lines
7 lines
IR/
3 lines
1 line
284 lines
utils/
gn/
secondary/
llvm/
unittests/
IR/
1 line

Diff 181473

llvm/trunk/docs/ExtendingLLVM.rst

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Lines#. ``llvm/lib/IR/Type.cpp`` and ``llvm/lib/IR/ValueTypes.cpp``:
add mapping from ``TypeID`` => ``Type*``; initialize the static ``Type*`` add mapping from ``TypeID`` => ``Type*``; initialize the static ``Type*``
#. ``llvm/llvm/llvm-c/Core.cpp``: #. ``llvm/llvm/llvm-c/Core.cpp``:
add enum ``LLVMTypeKind`` and modify add enum ``LLVMTypeKind`` and modify
``LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty)`` for the new type ``LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty)`` for the new type
#. ``llvm/include/llvm/IR/TypeBuilder.h``:
add new class to represent new type in the hierarchy
#. ``llvm/lib/AsmParser/LLLexer.cpp``: #. ``llvm/lib/AsmParser/LLLexer.cpp``:
add ability to parse in the type from text assembly add ability to parse in the type from text assembly
#. ``llvm/lib/AsmParser/LLParser.cpp``: #. ``llvm/lib/AsmParser/LLParser.cpp``:
add a token for that type add a token for that type
Show All 26 Lines#. ``llvm/lib/IR/Type.cpp`` and ``llvm/lib/IR/ValueTypes.cpp``:
add support for derived type, notably `enum TypeID` and `is`, `get` methods. add support for derived type, notably `enum TypeID` and `is`, `get` methods.
#. ``llvm/llvm/llvm-c/Core.cpp``: #. ``llvm/llvm/llvm-c/Core.cpp``:
add enum ``LLVMTypeKind`` and modify add enum ``LLVMTypeKind`` and modify
`LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty)` for the new type `LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty)` for the new type
#. ``llvm/include/llvm/IR/TypeBuilder.h``:
add new class to represent new class in the hierarchy
#. ``llvm/lib/AsmParser/LLLexer.cpp``: #. ``llvm/lib/AsmParser/LLLexer.cpp``:
modify ``lltok::Kind LLLexer::LexIdentifier()`` to add ability to modify ``lltok::Kind LLLexer::LexIdentifier()`` to add ability to
parse in the type from text assembly parse in the type from text assembly
#. ``llvm/lib/Bitcode/Writer/BitcodeWriter.cpp``: #. ``llvm/lib/Bitcode/Writer/BitcodeWriter.cpp``:
modify ``static void WriteTypeTable(const ValueEnumerator &VE, modify ``static void WriteTypeTable(const ValueEnumerator &VE,
Show All 14 Lines

llvm/trunk/docs/ProgrammersManual.rst

Show First 20 Lines • Show All 2,899 Lines • ▼ Show 20 Lines
.. code-block:: c++ .. code-block:: c++
GlobalVariable *GV = .. ; GlobalVariable *GV = .. ;
GV->eraseFromParent(); GV->eraseFromParent();
.. _create_types:
How to Create Types
-------------------
In generating IR, you may need some complex types. If you know these types
statically, you can use ``TypeBuilder<...>::get()``, defined in
``llvm/Support/TypeBuilder.h``, to retrieve them. ``TypeBuilder`` has two forms
depending on whether you're building types for cross-compilation or native
library use. ``TypeBuilder<T, true>`` requires that ``T`` be independent of the
host environment, meaning that it's built out of types from the ``llvm::types``
(`doxygen <http://llvm.org/doxygen/namespacellvm_1_1types.html>`__) namespace
and pointers, functions, arrays, etc. built of those. ``TypeBuilder<T, false>``
additionally allows native C types whose size may depend on the host compiler.
For example,
.. code-block:: c++
FunctionType *ft = TypeBuilder<types::i<8>(types::i<32>*), true>::get();
is easier to read and write than the equivalent
.. code-block:: c++
std::vector<const Type*> params;
params.push_back(PointerType::getUnqual(Type::Int32Ty));
FunctionType *ft = FunctionType::get(Type::Int8Ty, params, false);
See the `class comment
<http://llvm.org/doxygen/TypeBuilder_8h_source.html#l00001>`_ for more details.
.. _threading: .. _threading:
Threads and LLVM Threads and LLVM
================ ================
This section describes the interaction of the LLVM APIs with multithreading, This section describes the interaction of the LLVM APIs with multithreading,
both on the part of client applications, and in the JIT, in the hosted both on the part of client applications, and in the JIT, in the hosted
application. application.
▲ Show 20 Lines • Show All 1,184 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/TypeBuilder.h

//===---- llvm/TypeBuilder.h - Builder for LLVM types -----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the TypeBuilder class, which is used as a convenient way to
// create LLVM types with a consistent and simplified interface.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_IR_TYPEBUILDER_H
#define LLVM_IR_TYPEBUILDER_H
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/LLVMContext.h"
#include <climits>
namespace llvm {
/// TypeBuilder - This provides a uniform API for looking up types
/// known at compile time. To support cross-compilation, we define a
/// series of tag types in the llvm::types namespace, like i<N>,
/// ieee_float, ppc_fp128, etc. TypeBuilder<T, false> allows T to be
/// any of these, a native C type (whose size may depend on the host
/// compiler), or a pointer, function, or struct type built out of
/// these. TypeBuilder<T, true> removes native C types from this set
/// to guarantee that its result is suitable for cross-compilation.
/// We define the primitive types, pointer types, and functions up to
/// 5 arguments here, but to use this class with your own types,
/// you'll need to specialize it. For example, say you want to call a
/// function defined externally as:
///
/// \code{.cpp}
///
/// struct MyType {
/// int32 a;
/// int32 *b;
/// void *array[1]; // Intended as a flexible array.
/// };
/// int8 AFunction(struct MyType *value);
///
/// \endcode
///
/// You'll want to use
/// Function::Create(TypeBuilder<types::i<8>(MyType*), true>::get(), ...)
/// to declare the function, but when you first try this, your compiler will
/// complain that TypeBuilder<MyType, true>::get() doesn't exist. To fix this,
/// write:
///
/// \code{.cpp}
///
/// namespace llvm {
/// template<bool xcompile> class TypeBuilder<MyType, xcompile> {
/// public:
/// static StructType *get(LLVMContext &Context) {
/// // If you cache this result, be sure to cache it separately
/// // for each LLVMContext.
/// return StructType::get(
/// TypeBuilder<types::i<32>, xcompile>::get(Context),
/// TypeBuilder<types::i<32>*, xcompile>::get(Context),
/// TypeBuilder<types::i<8>*[], xcompile>::get(Context),
/// nullptr);
/// }
///
/// // You may find this a convenient place to put some constants
/// // to help with getelementptr. They don't have any effect on
/// // the operation of TypeBuilder.
/// enum Fields {
/// FIELD_A,
/// FIELD_B,
/// FIELD_ARRAY
/// };
/// }
/// } // namespace llvm
///
/// \endcode
///
/// TypeBuilder cannot handle recursive types or types you only know at runtime.
/// If you try to give it a recursive type, it will deadlock, infinitely
/// recurse, or do something similarly undesirable.
template<typename T, bool cross_compilable> class TypeBuilder {};
// Types for use with cross-compilable TypeBuilders. These correspond
// exactly with an LLVM-native type.
namespace types {
/// i<N> corresponds to the LLVM IntegerType with N bits.
template<uint32_t num_bits> class i {};
// The following classes represent the LLVM floating types.
class ieee_float {};
class ieee_double {};
class x86_fp80 {};
class fp128 {};
class ppc_fp128 {};
// X86 MMX.
class x86_mmx {};
} // namespace types
// LLVM doesn't have const or volatile types.
template<typename T, bool cross> class TypeBuilder<const T, cross>
: public TypeBuilder<T, cross> {};
template<typename T, bool cross> class TypeBuilder<volatile T, cross>
: public TypeBuilder<T, cross> {};
template<typename T, bool cross> class TypeBuilder<const volatile T, cross>
: public TypeBuilder<T, cross> {};
// Pointers
template<typename T, bool cross> class TypeBuilder<T*, cross> {
public:
static PointerType *get(LLVMContext &Context) {
return PointerType::getUnqual(TypeBuilder<T,cross>::get(Context));
}
};
/// There is no support for references
template<typename T, bool cross> class TypeBuilder<T&, cross> {};
// Arrays
template<typename T, size_t N, bool cross> class TypeBuilder<T[N], cross> {
public:
static ArrayType *get(LLVMContext &Context) {
return ArrayType::get(TypeBuilder<T, cross>::get(Context), N);
}
};
/// LLVM uses an array of length 0 to represent an unknown-length array.
template<typename T, bool cross> class TypeBuilder<T[], cross> {
public:
static ArrayType *get(LLVMContext &Context) {
return ArrayType::get(TypeBuilder<T, cross>::get(Context), 0);
}
};
// Define the C integral types only for TypeBuilder<T, false>.
//
// C integral types do not have a defined size. It would be nice to use the
// stdint.h-defined typedefs that do have defined sizes, but we'd run into the
// following problem:
//
// On an ILP32 machine, stdint.h might define:
//
// typedef int int32_t;
// typedef long long int64_t;
// typedef long size_t;
//
// If we defined TypeBuilder<int32_t> and TypeBuilder<int64_t>, then any use of
// TypeBuilder<size_t> would fail. We couldn't define TypeBuilder<size_t> in
// addition to the defined-size types because we'd get duplicate definitions on
// platforms where stdint.h instead defines:
//
// typedef int int32_t;
// typedef long long int64_t;
// typedef int size_t;
//
// So we define all the primitive C types and nothing else.
#define DEFINE_INTEGRAL_TYPEBUILDER(T) \
template<> class TypeBuilder<T, false> { \
public: \
static IntegerType *get(LLVMContext &Context) { \
return IntegerType::get(Context, sizeof(T) * CHAR_BIT); \
} \
}; \
template<> class TypeBuilder<T, true> { \
/* We provide a definition here so users don't accidentally */ \
/* define these types to work. */ \
}
DEFINE_INTEGRAL_TYPEBUILDER(char);
DEFINE_INTEGRAL_TYPEBUILDER(signed char);
DEFINE_INTEGRAL_TYPEBUILDER(unsigned char);
DEFINE_INTEGRAL_TYPEBUILDER(short);
DEFINE_INTEGRAL_TYPEBUILDER(unsigned short);
DEFINE_INTEGRAL_TYPEBUILDER(int);
DEFINE_INTEGRAL_TYPEBUILDER(unsigned int);
DEFINE_INTEGRAL_TYPEBUILDER(long);
DEFINE_INTEGRAL_TYPEBUILDER(unsigned long);
#ifdef _MSC_VER
DEFINE_INTEGRAL_TYPEBUILDER(__int64);
DEFINE_INTEGRAL_TYPEBUILDER(unsigned __int64);
#else /* _MSC_VER */
DEFINE_INTEGRAL_TYPEBUILDER(long long);
DEFINE_INTEGRAL_TYPEBUILDER(unsigned long long);
#endif /* _MSC_VER */
#undef DEFINE_INTEGRAL_TYPEBUILDER
template<uint32_t num_bits, bool cross>
class TypeBuilder<types::i<num_bits>, cross> {
public:
static IntegerType *get(LLVMContext &C) {
return IntegerType::get(C, num_bits);
}
};
template<> class TypeBuilder<float, false> {
public:
static Type *get(LLVMContext& C) {
return Type::getFloatTy(C);
}
};
template<> class TypeBuilder<float, true> {};
template<> class TypeBuilder<double, false> {
public:
static Type *get(LLVMContext& C) {
return Type::getDoubleTy(C);
}
};
template<> class TypeBuilder<double, true> {};
template<bool cross> class TypeBuilder<types::ieee_float, cross> {
public:
static Type *get(LLVMContext& C) { return Type::getFloatTy(C); }
};
template<bool cross> class TypeBuilder<types::ieee_double, cross> {
public:
static Type *get(LLVMContext& C) { return Type::getDoubleTy(C); }
};
template<bool cross> class TypeBuilder<types::x86_fp80, cross> {
public:
static Type *get(LLVMContext& C) { return Type::getX86_FP80Ty(C); }
};
template<bool cross> class TypeBuilder<types::fp128, cross> {
public:
static Type *get(LLVMContext& C) { return Type::getFP128Ty(C); }
};
template<bool cross> class TypeBuilder<types::ppc_fp128, cross> {
public:
static Type *get(LLVMContext& C) { return Type::getPPC_FP128Ty(C); }
};
template<bool cross> class TypeBuilder<types::x86_mmx, cross> {
public:
static Type *get(LLVMContext& C) { return Type::getX86_MMXTy(C); }
};
template<bool cross> class TypeBuilder<void, cross> {
public:
static Type *get(LLVMContext &C) {
return Type::getVoidTy(C);
}
};
/// void* is disallowed in LLVM types, but it occurs often enough in C code that
/// we special case it.
template<> class TypeBuilder<void*, false>
: public TypeBuilder<types::i<8>*, false> {};
template<> class TypeBuilder<const void*, false>
: public TypeBuilder<types::i<8>*, false> {};
template<> class TypeBuilder<volatile void*, false>
: public TypeBuilder<types::i<8>*, false> {};
template<> class TypeBuilder<const volatile void*, false>
: public TypeBuilder<types::i<8>*, false> {};
template<typename R, bool cross> class TypeBuilder<R(), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
return FunctionType::get(TypeBuilder<R, cross>::get(Context), false);
}
};
template<typename R, typename A1, bool cross> class TypeBuilder<R(A1), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, false);
}
};
template<typename R, typename A1, typename A2, bool cross>
class TypeBuilder<R(A1, A2), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
TypeBuilder<A2, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, false);
}
};
template<typename R, typename A1, typename A2, typename A3, bool cross>
class TypeBuilder<R(A1, A2, A3), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
TypeBuilder<A2, cross>::get(Context),
TypeBuilder<A3, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, false);
}
};
template<typename R, typename A1, typename A2, typename A3, typename A4,
bool cross>
class TypeBuilder<R(A1, A2, A3, A4), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
TypeBuilder<A2, cross>::get(Context),
TypeBuilder<A3, cross>::get(Context),
TypeBuilder<A4, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, false);
}
};
template<typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, bool cross>
class TypeBuilder<R(A1, A2, A3, A4, A5), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
TypeBuilder<A2, cross>::get(Context),
TypeBuilder<A3, cross>::get(Context),
TypeBuilder<A4, cross>::get(Context),
TypeBuilder<A5, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, false);
}
};
template<typename R, bool cross> class TypeBuilder<R(...), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
return FunctionType::get(TypeBuilder<R, cross>::get(Context), true);
}
};
template<typename R, typename A1, bool cross>
class TypeBuilder<R(A1, ...), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context), params, true);
}
};
template<typename R, typename A1, typename A2, bool cross>
class TypeBuilder<R(A1, A2, ...), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
TypeBuilder<A2, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, true);
}
};
template<typename R, typename A1, typename A2, typename A3, bool cross>
class TypeBuilder<R(A1, A2, A3, ...), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
TypeBuilder<A2, cross>::get(Context),
TypeBuilder<A3, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, true);
}
};
template<typename R, typename A1, typename A2, typename A3, typename A4,
bool cross>
class TypeBuilder<R(A1, A2, A3, A4, ...), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
TypeBuilder<A2, cross>::get(Context),
TypeBuilder<A3, cross>::get(Context),
TypeBuilder<A4, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, true);
}
};
template<typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, bool cross>
class TypeBuilder<R(A1, A2, A3, A4, A5, ...), cross> {
public:
static FunctionType *get(LLVMContext &Context) {
Type *params[] = {
TypeBuilder<A1, cross>::get(Context),
TypeBuilder<A2, cross>::get(Context),
TypeBuilder<A3, cross>::get(Context),
TypeBuilder<A4, cross>::get(Context),
TypeBuilder<A5, cross>::get(Context),
};
return FunctionType::get(TypeBuilder<R, cross>::get(Context),
params, true);
}
};
} // namespace llvm
#endif

llvm/trunk/tools/lli/lli.cpp

Show All 29 Lines
#include "llvm/ExecutionEngine/Orc/LLJIT.h" #include "llvm/ExecutionEngine/Orc/LLJIT.h"
#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h" #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h"
#include "llvm/ExecutionEngine/OrcMCJITReplacement.h" #include "llvm/ExecutionEngine/OrcMCJITReplacement.h"
#include "llvm/ExecutionEngine/SectionMemoryManager.h" #include "llvm/ExecutionEngine/SectionMemoryManager.h"
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/Type.h" #include "llvm/IR/Type.h"
#include "llvm/IR/TypeBuilder.h"
#include "llvm/IR/Verifier.h" #include "llvm/IR/Verifier.h"
#include "llvm/IRReader/IRReader.h" #include "llvm/IRReader/IRReader.h"
#include "llvm/Object/Archive.h" #include "llvm/Object/Archive.h"
#include "llvm/Object/ObjectFile.h" #include "llvm/Object/ObjectFile.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/DynamicLibrary.h" #include "llvm/Support/DynamicLibrary.h"
#include "llvm/Support/Format.h" #include "llvm/Support/Format.h"
▲ Show 20 Lines • Show All 265 Lines • ▼ Show 20 Linesstatic void addCygMingExtraModule(ExecutionEngine &EE, LLVMContext &Context,
IRBuilder<> Builder(Context); IRBuilder<> Builder(Context);
Triple TargetTriple(TargetTripleStr); Triple TargetTriple(TargetTripleStr);
// Create a new module. // Create a new module.
std::unique_ptr<Module> M = make_unique<Module>("CygMingHelper", Context); std::unique_ptr<Module> M = make_unique<Module>("CygMingHelper", Context);
M->setTargetTriple(TargetTripleStr); M->setTargetTriple(TargetTripleStr);
// Create an empty function named "__main". // Create an empty function named "__main".
Function *Result; Type *ReturnTy;
if (TargetTriple.isArch64Bit()) { if (TargetTriple.isArch64Bit())
Result = Function::Create( ReturnTy = Type::getInt64Ty(Context);
TypeBuilder<int64_t(void), false>::get(Context), else
GlobalValue::ExternalLinkage, "__main", M.get()); ReturnTy = Type::getInt32Ty(Context);
} else { Function *Result =
Result = Function::Create( Function::Create(FunctionType::get(ReturnTy, {}, false),
TypeBuilder<int32_t(void), false>::get(Context),
GlobalValue::ExternalLinkage, "__main", M.get()); GlobalValue::ExternalLinkage, "__main", M.get());
}
BasicBlock *BB = BasicBlock::Create(Context, "__main", Result); BasicBlock *BB = BasicBlock::Create(Context, "__main", Result);
Builder.SetInsertPoint(BB); Builder.SetInsertPoint(BB);
Value *ReturnVal; Value *ReturnVal = ConstantInt::get(ReturnTy, 0);
if (TargetTriple.isArch64Bit())
ReturnVal = ConstantInt::get(Context, APInt(64, 0));
else
ReturnVal = ConstantInt::get(Context, APInt(32, 0));
Builder.CreateRet(ReturnVal); Builder.CreateRet(ReturnVal);
// Add this new module to the ExecutionEngine. // Add this new module to the ExecutionEngine.
EE.addModule(std::move(M)); EE.addModule(std::move(M));
} }
CodeGenOpt::Level getOptLevel() { CodeGenOpt::Level getOptLevel() {
switch (OptLevel) { switch (OptLevel) {
▲ Show 20 Lines • Show All 623 Lines • Show Last 20 Lines

llvm/trunk/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp

Show First 20 Lines • Show All 169 Lines • ▼ Show 20 Lines
// Module B { Extern FA1, Function FB which calls FA1 }, // Module B { Extern FA1, Function FB which calls FA1 },
// execute FB then FA2 // execute FB then FA2
TEST_F(MCJITMultipleModuleTest, two_module_consecutive_call_case) { TEST_F(MCJITMultipleModuleTest, two_module_consecutive_call_case) {
SKIP_UNSUPPORTED_PLATFORM; SKIP_UNSUPPORTED_PLATFORM;
std::unique_ptr<Module> A, B; std::unique_ptr<Module> A, B;
Function *FA1, *FA2, *FB; Function *FA1, *FA2, *FB;
createTwoModuleExternCase(A, FA1, B, FB); createTwoModuleExternCase(A, FA1, B, FB);
FA2 = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(A.get(), FA1); FA2 = insertSimpleCallFunction(A.get(), FA1);
createJIT(std::move(A)); createJIT(std::move(A));
TheJIT->addModule(std::move(B)); TheJIT->addModule(std::move(B));
uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str()); uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
TheJIT->finalizeObject(); TheJIT->finalizeObject();
checkAdd(ptr); checkAdd(ptr);
Show All 11 Lines
// execute FB then FA, also check that the global variables are properly accesible // execute FB then FA, also check that the global variables are properly accesible
// through the ExecutionEngine APIs // through the ExecutionEngine APIs
TEST_F(MCJITMultipleModuleTest, two_module_global_variables_case) { TEST_F(MCJITMultipleModuleTest, two_module_global_variables_case) {
SKIP_UNSUPPORTED_PLATFORM; SKIP_UNSUPPORTED_PLATFORM;
std::unique_ptr<Module> A, B; std::unique_ptr<Module> A, B;
Function *FA, *FB; Function *FA, *FB;
GlobalVariable *GVA, *GVB, *GVC; GlobalVariable *GVA, *GVB, *GVC;
A.reset(createEmptyModule("A")); A.reset(createEmptyModule("A"));
B.reset(createEmptyModule("B")); B.reset(createEmptyModule("B"));
int32_t initialNum = 7; int32_t initialNum = 7;
GVA = insertGlobalInt32(A.get(), "GVA", initialNum); GVA = insertGlobalInt32(A.get(), "GVA", initialNum);
GVB = insertGlobalInt32(B.get(), "GVB", initialNum); GVB = insertGlobalInt32(B.get(), "GVB", initialNum);
FA = startFunction<int32_t(void)>(A.get(), "FA"); FA = startFunction(A.get(),
FunctionType::get(Builder.getInt32Ty(), {}, false), "FA");
endFunctionWithRet(FA, Builder.CreateLoad(GVA)); endFunctionWithRet(FA, Builder.CreateLoad(GVA));
FB = startFunction<int32_t(void)>(B.get(), "FB"); FB = startFunction(B.get(),
FunctionType::get(Builder.getInt32Ty(), {}, false), "FB");
endFunctionWithRet(FB, Builder.CreateLoad(GVB)); endFunctionWithRet(FB, Builder.CreateLoad(GVB));
GVC = insertGlobalInt32(B.get(), "GVC", initialNum); GVC = insertGlobalInt32(B.get(), "GVC", initialNum);
GVC->setLinkage(GlobalValue::InternalLinkage); GVC->setLinkage(GlobalValue::InternalLinkage);
createJIT(std::move(A)); createJIT(std::move(A));
TheJIT->addModule(std::move(B)); TheJIT->addModule(std::move(B));
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

llvm/trunk/unittests/ExecutionEngine/MCJIT/MCJITTest.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
} }
TEST_F(MCJITTest, return_global) { TEST_F(MCJITTest, return_global) {
SKIP_UNSUPPORTED_PLATFORM; SKIP_UNSUPPORTED_PLATFORM;
int32_t initialNum = 7; int32_t initialNum = 7;
GlobalVariable *GV = insertGlobalInt32(M.get(), "myglob", initialNum); GlobalVariable *GV = insertGlobalInt32(M.get(), "myglob", initialNum);
Function *ReturnGlobal = startFunction<int32_t(void)>(M.get(), Function *ReturnGlobal =
startFunction(M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false),
"ReturnGlobal"); "ReturnGlobal");
Value *ReadGlobal = Builder.CreateLoad(GV); Value *ReadGlobal = Builder.CreateLoad(GV);
endFunctionWithRet(ReturnGlobal, ReadGlobal); endFunctionWithRet(ReturnGlobal, ReadGlobal);
createJIT(std::move(M)); createJIT(std::move(M));
uint64_t rgvPtr = TheJIT->getFunctionAddress(ReturnGlobal->getName().str()); uint64_t rgvPtr = TheJIT->getFunctionAddress(ReturnGlobal->getName().str());
EXPECT_TRUE(0 != rgvPtr); EXPECT_TRUE(0 != rgvPtr);
int32_t(*FuncPtr)() = (int32_t(*)())rgvPtr; int32_t(*FuncPtr)() = (int32_t(*)())rgvPtr;
Show All 9 Lines
// has the correct initial value, but updates to the real global (accessed by // has the correct initial value, but updates to the real global (accessed by
// JITted code) are not propagated. Instead, getPointerToGlobal() should return // JITted code) are not propagated. Instead, getPointerToGlobal() should return
// a pointer into the loaded ObjectImage to reference the emitted global. // a pointer into the loaded ObjectImage to reference the emitted global.
/* /*
TEST_F(MCJITTest, increment_global) { TEST_F(MCJITTest, increment_global) {
SKIP_UNSUPPORTED_PLATFORM; SKIP_UNSUPPORTED_PLATFORM;
int32_t initialNum = 5; int32_t initialNum = 5;
Function *IncrementGlobal = startFunction<int32_t(void)>(M.get(), "IncrementGlobal"); Function *IncrementGlobal = startFunction(
M.get(),
FunctionType::get(Builder.getInt32Ty(), {}, false),
"IncrementGlobal");
GlobalVariable *GV = insertGlobalInt32(M.get(), "my_global", initialNum); GlobalVariable *GV = insertGlobalInt32(M.get(), "my_global", initialNum);
Value *DerefGV = Builder.CreateLoad(GV); Value *DerefGV = Builder.CreateLoad(GV);
Value *AddResult = Builder.CreateAdd(DerefGV, Value *AddResult = Builder.CreateAdd(DerefGV,
ConstantInt::get(Context, APInt(32, 1))); ConstantInt::get(Context, APInt(32, 1)));
Builder.CreateStore(AddResult, GV); Builder.CreateStore(AddResult, GV);
endFunctionWithRet(IncrementGlobal, AddResult); endFunctionWithRet(IncrementGlobal, AddResult);
createJIT(M.take()); createJIT(M.take());
Show All 18 Lines
#if !defined(__arm__) #if !defined(__arm__)
TEST_F(MCJITTest, multiple_functions) { TEST_F(MCJITTest, multiple_functions) {
SKIP_UNSUPPORTED_PLATFORM; SKIP_UNSUPPORTED_PLATFORM;
unsigned int numLevels = 23; unsigned int numLevels = 23;
int32_t innerRetVal= 5; int32_t innerRetVal= 5;
Function *Inner = startFunction<int32_t(void)>(M.get(), "Inner"); Function *Inner = startFunction(
M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false), "Inner");
endFunctionWithRet(Inner, ConstantInt::get(Context, APInt(32, innerRetVal))); endFunctionWithRet(Inner, ConstantInt::get(Context, APInt(32, innerRetVal)));
Function *Outer; Function *Outer;
for (unsigned int i = 0; i < numLevels; ++i) { for (unsigned int i = 0; i < numLevels; ++i) {
std::stringstream funcName; std::stringstream funcName;
funcName << "level_" << i; funcName << "level_" << i;
Outer = startFunction<int32_t(void)>(M.get(), funcName.str()); Outer = startFunction(M.get(),
FunctionType::get(Builder.getInt32Ty(), {}, false),
funcName.str());
Value *innerResult = Builder.CreateCall(Inner, {}); Value *innerResult = Builder.CreateCall(Inner, {});
endFunctionWithRet(Outer, innerResult); endFunctionWithRet(Outer, innerResult);
Inner = Outer; Inner = Outer;
} }
createJIT(std::move(M)); createJIT(std::move(M));
uint64_t ptr = TheJIT->getFunctionAddress(Outer->getName().str()); uint64_t ptr = TheJIT->getFunctionAddress(Outer->getName().str());
EXPECT_TRUE(0 != ptr) EXPECT_TRUE(0 != ptr)
<< "Unable to get pointer to outer function from JIT"; << "Unable to get pointer to outer function from JIT";
int32_t(*FuncPtr)() = (int32_t(*)())ptr; int32_t(*FuncPtr)() = (int32_t(*)())ptr;
EXPECT_EQ(innerRetVal, FuncPtr()) EXPECT_EQ(innerRetVal, FuncPtr())
<< "Incorrect result returned from function"; << "Incorrect result returned from function";
} }
#endif /*!defined(__arm__)*/ #endif /*!defined(__arm__)*/
TEST_F(MCJITTest, multiple_decl_lookups) { TEST_F(MCJITTest, multiple_decl_lookups) {
SKIP_UNSUPPORTED_PLATFORM; SKIP_UNSUPPORTED_PLATFORM;
Function *Foo = insertExternalReferenceToFunction<void(void)>(M.get(), "_exit"); Function *Foo = insertExternalReferenceToFunction(
M.get(), FunctionType::get(Builder.getVoidTy(), {}, false), "_exit");
createJIT(std::move(M)); createJIT(std::move(M));
void *A = TheJIT->getPointerToFunction(Foo); void *A = TheJIT->getPointerToFunction(Foo);
void *B = TheJIT->getPointerToFunction(Foo); void *B = TheJIT->getPointerToFunction(Foo);
EXPECT_TRUE(A != nullptr) << "Failed lookup - test not correctly configured."; EXPECT_TRUE(A != nullptr) << "Failed lookup - test not correctly configured.";
EXPECT_EQ(A, B) << "Repeat calls to getPointerToFunction fail."; EXPECT_EQ(A, B) << "Repeat calls to getPointerToFunction fail.";
} }
typedef void * (*FunctionHandlerPtr)(const std::string &str); typedef void * (*FunctionHandlerPtr)(const std::string &str);
TEST_F(MCJITTest, lazy_function_creator_pointer) { TEST_F(MCJITTest, lazy_function_creator_pointer) {
SKIP_UNSUPPORTED_PLATFORM; SKIP_UNSUPPORTED_PLATFORM;
Function *Foo = insertExternalReferenceToFunction<int32_t(void)>(M.get(), Function *Foo = insertExternalReferenceToFunction(
M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false),
"\1Foo"); "\1Foo");
startFunction<int32_t(void)>(M.get(), "Parent"); startFunction(M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false),
"Parent");
CallInst *Call = Builder.CreateCall(Foo, {}); CallInst *Call = Builder.CreateCall(Foo, {});
Builder.CreateRet(Call); Builder.CreateRet(Call);
createJIT(std::move(M)); createJIT(std::move(M));
// Set up the lazy function creator that records the name of the last // Set up the lazy function creator that records the name of the last
// unresolved external function found in the module. Using a function pointer // unresolved external function found in the module. Using a function pointer
// prevents us from capturing local variables, which is why this is static. // prevents us from capturing local variables, which is why this is static.
Show All 17 LinesTEST_F(MCJITTest, lazy_function_creator_pointer) {
TheJIT->finalizeObject(); TheJIT->finalizeObject();
// Verify that our handler was called. // Verify that our handler was called.
EXPECT_EQ(UnresolvedExternal, "Foo"); EXPECT_EQ(UnresolvedExternal, "Foo");
} }
TEST_F(MCJITTest, lazy_function_creator_lambda) { TEST_F(MCJITTest, lazy_function_creator_lambda) {
SKIP_UNSUPPORTED_PLATFORM; SKIP_UNSUPPORTED_PLATFORM;
Function *Foo1 = insertExternalReferenceToFunction<int32_t(void)>(M.get(), FunctionType *Int32VoidFnTy =
"\1Foo1"); FunctionType::get(Builder.getInt32Ty(), {}, false);
Function *Foo2 = insertExternalReferenceToFunction<int32_t(void)>(M.get(), Function *Foo1 =
"\1Foo2"); insertExternalReferenceToFunction(M.get(), Int32VoidFnTy, "\1Foo1");
startFunction<int32_t(void)>(M.get(), "Parent"); Function *Foo2 =
insertExternalReferenceToFunction(M.get(), Int32VoidFnTy, "\1Foo2");
startFunction(M.get(), Int32VoidFnTy, "Parent");
CallInst *Call1 = Builder.CreateCall(Foo1, {}); CallInst *Call1 = Builder.CreateCall(Foo1, {});
CallInst *Call2 = Builder.CreateCall(Foo2, {}); CallInst *Call2 = Builder.CreateCall(Foo2, {});
Value *Result = Builder.CreateAdd(Call1, Call2); Value *Result = Builder.CreateAdd(Call1, Call2);
Builder.CreateRet(Result); Builder.CreateRet(Result);
createJIT(std::move(M)); createJIT(std::move(M));
// Set up the lazy function creator that records the name of unresolved // Set up the lazy function creator that records the name of unresolved
Show All 27 Lines

llvm/trunk/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

Show All 18 Lines
#include "MCJITTestAPICommon.h" #include "MCJITTestAPICommon.h"
#include "llvm/Config/config.h" #include "llvm/Config/config.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/SectionMemoryManager.h" #include "llvm/ExecutionEngine/SectionMemoryManager.h"
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/TypeBuilder.h" #include "llvm/IR/Type.h"
#include "llvm/Support/CodeGen.h" #include "llvm/Support/CodeGen.h"
namespace llvm { namespace llvm {
/// Helper class that can build very simple Modules /// Helper class that can build very simple Modules
class TrivialModuleBuilder { class TrivialModuleBuilder {
protected: protected:
LLVMContext Context; LLVMContext Context;
IRBuilder<> Builder; IRBuilder<> Builder;
std::string BuilderTriple; std::string BuilderTriple;
TrivialModuleBuilder(const std::string &Triple) TrivialModuleBuilder(const std::string &Triple)
: Builder(Context), BuilderTriple(Triple) {} : Builder(Context), BuilderTriple(Triple) {}
Module *createEmptyModule(StringRef Name = StringRef()) { Module *createEmptyModule(StringRef Name = StringRef()) {
Module * M = new Module(Name, Context); Module * M = new Module(Name, Context);
M->setTargetTriple(Triple::normalize(BuilderTriple)); M->setTargetTriple(Triple::normalize(BuilderTriple));
return M; return M;
} }
template<typename FuncType> Function *startFunction(Module *M, FunctionType *FT, StringRef Name) {
Function *startFunction(Module *M, StringRef Name) { Function *Result =
Function *Result = Function::Create( Function::Create(FT, GlobalValue::ExternalLinkage, Name, M);
TypeBuilder<FuncType, false>::get(Context),
GlobalValue::ExternalLinkage, Name, M);
BasicBlock *BB = BasicBlock::Create(Context, Name, Result); BasicBlock *BB = BasicBlock::Create(Context, Name, Result);
Builder.SetInsertPoint(BB); Builder.SetInsertPoint(BB);
return Result; return Result;
} }
void endFunctionWithRet(Function *Func, Value *RetValue) { void endFunctionWithRet(Function *Func, Value *RetValue) {
Builder.CreateRet(RetValue); Builder.CreateRet(RetValue);
} }
// Inserts a simple function that invokes Callee and takes the same arguments: // Inserts a simple function that invokes Callee and takes the same arguments:
// int Caller(...) { return Callee(...); } // int Caller(...) { return Callee(...); }
template<typename Signature>
Function *insertSimpleCallFunction(Module *M, Function *Callee) { Function *insertSimpleCallFunction(Module *M, Function *Callee) {
Function *Result = startFunction<Signature>(M, "caller"); Function *Result = startFunction(M, Callee->getFunctionType(), "caller");
SmallVector<Value*, 1> CallArgs; SmallVector<Value*, 1> CallArgs;
for (Argument &A : Result->args()) for (Argument &A : Result->args())
CallArgs.push_back(&A); CallArgs.push_back(&A);
Value *ReturnCode = Builder.CreateCall(Callee, CallArgs); Value *ReturnCode = Builder.CreateCall(Callee, CallArgs);
Builder.CreateRet(ReturnCode); Builder.CreateRet(ReturnCode);
return Result; return Result;
} }
// Inserts a function named 'main' that returns a uint32_t: // Inserts a function named 'main' that returns a uint32_t:
// int32_t main() { return X; } // int32_t main() { return X; }
// where X is given by returnCode // where X is given by returnCode
Function *insertMainFunction(Module *M, uint32_t returnCode) { Function *insertMainFunction(Module *M, uint32_t returnCode) {
Function *Result = startFunction<int32_t(void)>(M, "main"); Function *Result = startFunction(
M, FunctionType::get(Type::getInt32Ty(Context), {}, false), "main");
Value *ReturnVal = ConstantInt::get(Context, APInt(32, returnCode)); Value *ReturnVal = ConstantInt::get(Context, APInt(32, returnCode));
endFunctionWithRet(Result, ReturnVal); endFunctionWithRet(Result, ReturnVal);
return Result; return Result;
} }
// Inserts a function // Inserts a function
// int32_t add(int32_t a, int32_t b) { return a + b; } // int32_t add(int32_t a, int32_t b) { return a + b; }
// in the current module and returns a pointer to it. // in the current module and returns a pointer to it.
Function *insertAddFunction(Module *M, StringRef Name = "add") { Function *insertAddFunction(Module *M, StringRef Name = "add") {
Function *Result = startFunction<int32_t(int32_t, int32_t)>(M, Name); Function *Result = startFunction(
M,
FunctionType::get(
Type::getInt32Ty(Context),
{Type::getInt32Ty(Context), Type::getInt32Ty(Context)}, false),
Name);
Function::arg_iterator args = Result->arg_begin(); Function::arg_iterator args = Result->arg_begin();
Value *Arg1 = &*args; Value *Arg1 = &*args;
Value *Arg2 = &*++args; Value *Arg2 = &*++args;
Value *AddResult = Builder.CreateAdd(Arg1, Arg2); Value *AddResult = Builder.CreateAdd(Arg1, Arg2);
endFunctionWithRet(Result, AddResult); endFunctionWithRet(Result, AddResult);
return Result; return Result;
} }
// Inserts a declaration to a function defined elsewhere // Inserts a declaration to a function defined elsewhere
template <typename FuncType> Function *insertExternalReferenceToFunction(Module *M, FunctionType *FTy,
Function *insertExternalReferenceToFunction(Module *M, StringRef Name) { StringRef Name) {
Function *Result = Function::Create( Function *Result =
TypeBuilder<FuncType, false>::get(Context), Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M);
GlobalValue::ExternalLinkage, Name, M);
return Result;
}
// Inserts an declaration to a function defined elsewhere
Function *insertExternalReferenceToFunction(Module *M, StringRef Name,
FunctionType *FuncTy) {
Function *Result = Function::Create(FuncTy,
GlobalValue::ExternalLinkage,
Name, M);
return Result; return Result;
} }
// Inserts an declaration to a function defined elsewhere // Inserts an declaration to a function defined elsewhere
Function *insertExternalReferenceToFunction(Module *M, Function *Func) { Function *insertExternalReferenceToFunction(Module *M, Function *Func) {
Function *Result = Function::Create(Func->getFunctionType(), Function *Result = Function::Create(Func->getFunctionType(),
GlobalValue::ExternalLinkage, GlobalValue::ExternalLinkage,
Func->getName(), M); Func->getName(), M);
return Result; return Result;
} }
// Inserts a global variable of type int32 // Inserts a global variable of type int32
// FIXME: make this a template function to support any type // FIXME: make this a template function to support any type
GlobalVariable *insertGlobalInt32(Module *M, GlobalVariable *insertGlobalInt32(Module *M,
StringRef name, StringRef name,
int32_t InitialValue) { int32_t InitialValue) {
Type *GlobalTy = TypeBuilder<types::i<32>, true>::get(Context); Type *GlobalTy = Type::getInt32Ty(Context);
Constant *IV = ConstantInt::get(Context, APInt(32, InitialValue)); Constant *IV = ConstantInt::get(Context, APInt(32, InitialValue));
GlobalVariable *Global = new GlobalVariable(*M, GlobalVariable *Global = new GlobalVariable(*M,
GlobalTy, GlobalTy,
false, false,
GlobalValue::ExternalLinkage, GlobalValue::ExternalLinkage,
IV, IV,
name); name);
return Global; return Global;
} }
// Inserts a function // Inserts a function
// int32_t recursive_add(int32_t num) { // int32_t recursive_add(int32_t num) {
// if (num == 0) { // if (num == 0) {
// return num; // return num;
// } else { // } else {
// int32_t recursive_param = num - 1; // int32_t recursive_param = num - 1;
// return num + Helper(recursive_param); // return num + Helper(recursive_param);
// } // }
// } // }
// NOTE: if Helper is left as the default parameter, Helper == recursive_add. // NOTE: if Helper is left as the default parameter, Helper == recursive_add.
Function *insertAccumulateFunction(Module *M, Function *insertAccumulateFunction(Module *M,
Function *Helper = nullptr, Function *Helper = nullptr,
StringRef Name = "accumulate") { StringRef Name = "accumulate") {
Function *Result = startFunction<int32_t(int32_t)>(M, Name); Function *Result =
startFunction(M,
FunctionType::get(Type::getInt32Ty(Context),
{Type::getInt32Ty(Context)}, false),
Name);
if (!Helper) if (!Helper)
Helper = Result; Helper = Result;
BasicBlock *BaseCase = BasicBlock::Create(Context, "", Result); BasicBlock *BaseCase = BasicBlock::Create(Context, "", Result);
BasicBlock *RecursiveCase = BasicBlock::Create(Context, "", Result); BasicBlock *RecursiveCase = BasicBlock::Create(Context, "", Result);
// if (num == 0) // if (num == 0)
Value *Param = &*Result->arg_begin(); Value *Param = &*Result->arg_begin();
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Linesprotected:
createThreeModuleChainedCallsCase(std::unique_ptr<Module> &A, Function *&FA, createThreeModuleChainedCallsCase(std::unique_ptr<Module> &A, Function *&FA,
std::unique_ptr<Module> &B, Function *&FB, std::unique_ptr<Module> &B, Function *&FB,
std::unique_ptr<Module> &C, Function *&FC) { std::unique_ptr<Module> &C, Function *&FC) {
A.reset(createEmptyModule("A")); A.reset(createEmptyModule("A"));
FA = insertAddFunction(A.get()); FA = insertAddFunction(A.get());
B.reset(createEmptyModule("B")); B.reset(createEmptyModule("B"));
Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA);
FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), FAExtern_in_B); FB = insertSimpleCallFunction(B.get(), FAExtern_in_B);
C.reset(createEmptyModule("C")); C.reset(createEmptyModule("C"));
Function *FBExtern_in_C = insertExternalReferenceToFunction(C.get(), FB); Function *FBExtern_in_C = insertExternalReferenceToFunction(C.get(), FB);
FC = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(C.get(), FBExtern_in_C); FC = insertSimpleCallFunction(C.get(), FBExtern_in_C);
} }
// Module A { Function FA }, // Module A { Function FA },
// Populates Modules A and B: // Populates Modules A and B:
// Module B { Function FB } // Module B { Function FB }
void createTwoModuleCase(std::unique_ptr<Module> &A, Function *&FA, void createTwoModuleCase(std::unique_ptr<Module> &A, Function *&FA,
std::unique_ptr<Module> &B, Function *&FB) { std::unique_ptr<Module> &B, Function *&FB) {
A.reset(createEmptyModule("A")); A.reset(createEmptyModule("A"));
FA = insertAddFunction(A.get()); FA = insertAddFunction(A.get());
B.reset(createEmptyModule("B")); B.reset(createEmptyModule("B"));
FB = insertAddFunction(B.get()); FB = insertAddFunction(B.get());
} }
// Module A { Function FA }, // Module A { Function FA },
// Module B { Extern FA, Function FB which calls FA } // Module B { Extern FA, Function FB which calls FA }
void createTwoModuleExternCase(std::unique_ptr<Module> &A, Function *&FA, void createTwoModuleExternCase(std::unique_ptr<Module> &A, Function *&FA,
std::unique_ptr<Module> &B, Function *&FB) { std::unique_ptr<Module> &B, Function *&FB) {
A.reset(createEmptyModule("A")); A.reset(createEmptyModule("A"));
FA = insertAddFunction(A.get()); FA = insertAddFunction(A.get());
B.reset(createEmptyModule("B")); B.reset(createEmptyModule("B"));
Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA);
FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), FB = insertSimpleCallFunction(B.get(), FAExtern_in_B);
FAExtern_in_B);
} }
// Module A { Function FA }, // Module A { Function FA },
// Module B { Extern FA, Function FB which calls FA }, // Module B { Extern FA, Function FB which calls FA },
// Module C { Extern FB, Function FC which calls FA }, // Module C { Extern FB, Function FC which calls FA },
void createThreeModuleCase(std::unique_ptr<Module> &A, Function *&FA, void createThreeModuleCase(std::unique_ptr<Module> &A, Function *&FA,
std::unique_ptr<Module> &B, Function *&FB, std::unique_ptr<Module> &B, Function *&FB,
std::unique_ptr<Module> &C, Function *&FC) { std::unique_ptr<Module> &C, Function *&FC) {
A.reset(createEmptyModule("A")); A.reset(createEmptyModule("A"));
FA = insertAddFunction(A.get()); FA = insertAddFunction(A.get());
B.reset(createEmptyModule("B")); B.reset(createEmptyModule("B"));
Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA);
FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), FAExtern_in_B); FB = insertSimpleCallFunction(B.get(), FAExtern_in_B);
C.reset(createEmptyModule("C")); C.reset(createEmptyModule("C"));
Function *FAExtern_in_C = insertExternalReferenceToFunction(C.get(), FA); Function *FAExtern_in_C = insertExternalReferenceToFunction(C.get(), FA);
FC = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(C.get(), FAExtern_in_C); FC = insertSimpleCallFunction(C.get(), FAExtern_in_C);
} }
}; };
class MCJITTestBase : public MCJITTestAPICommon, public TrivialModuleBuilder { class MCJITTestBase : public MCJITTestAPICommon, public TrivialModuleBuilder {
protected: protected:
MCJITTestBase() MCJITTestBase()
: TrivialModuleBuilder(HostTriple), OptLevel(CodeGenOpt::None), : TrivialModuleBuilder(HostTriple), OptLevel(CodeGenOpt::None),
CodeModel(CodeModel::Small), MArch(""), MM(new SectionMemoryManager) { CodeModel(CodeModel::Small), MArch(""), MM(new SectionMemoryManager) {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/trunk/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp

Show All 13 Lines
using namespace llvm; using namespace llvm;
namespace { namespace {
TEST(IndirectionUtilsTest, MakeStub) { TEST(IndirectionUtilsTest, MakeStub) {
LLVMContext Context; LLVMContext Context;
ModuleBuilder MB(Context, "x86_64-apple-macosx10.10", ""); ModuleBuilder MB(Context, "x86_64-apple-macosx10.10", "");
Function *F = MB.createFunctionDecl<void(DummyStruct, DummyStruct)>(""); FunctionType *FTy = FunctionType::get(
Type::getVoidTy(Context),
{getDummyStructTy(Context), getDummyStructTy(Context)}, false);
Function *F = MB.createFunctionDecl(FTy, "");
AttributeSet FnAttrs = AttributeSet::get( AttributeSet FnAttrs = AttributeSet::get(
Context, AttrBuilder().addAttribute(Attribute::NoUnwind)); Context, AttrBuilder().addAttribute(Attribute::NoUnwind));
AttributeSet RetAttrs; // None AttributeSet RetAttrs; // None
AttributeSet ArgAttrs[2] = { AttributeSet ArgAttrs[2] = {
AttributeSet::get(Context, AttributeSet::get(Context,
AttrBuilder().addAttribute(Attribute::StructRet)), AttrBuilder().addAttribute(Attribute::StructRet)),
AttributeSet::get(Context, AttrBuilder().addAttribute(Attribute::ByVal)), AttributeSet::get(Context, AttrBuilder().addAttribute(Attribute::ByVal)),
}; };
Show All 17 Lines

llvm/trunk/unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines auto Obj = SimpleCompiler(*TM)(*M);
cantFail(ObjLayer.removeObject(K)); cantFail(ObjLayer.removeObject(K));
} }
} }
TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) { TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
if (!SupportsJIT) if (!SupportsJIT)
return; return;
Type *Int32Ty = IntegerType::get(Context, 32);
ExecutionSession ES; ExecutionSession ES;
auto MM = std::make_shared<SectionMemoryManagerWrapper>(); auto MM = std::make_shared<SectionMemoryManagerWrapper>();
std::map<orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>> Resolvers; std::map<orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>> Resolvers;
LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&](VModuleKey K) { LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&](VModuleKey K) {
auto I = Resolvers.find(K); auto I = Resolvers.find(K);
Show All 14 LinesTEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
// Verify that the memory manager is only finalized once (for Module 2). // Verify that the memory manager is only finalized once (for Module 2).
// Failure suggests that finalize is being called on the inner RTDyld // Failure suggests that finalize is being called on the inner RTDyld
// instance (for Module 1) which is unsafe, as it will prevent relocation of // instance (for Module 1) which is unsafe, as it will prevent relocation of
// Module 2. // Module 2.
ModuleBuilder MB1(Context, "", "dummy"); ModuleBuilder MB1(Context, "", "dummy");
{ {
MB1.getModule()->setDataLayout(TM->createDataLayout()); MB1.getModule()->setDataLayout(TM->createDataLayout());
Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("bar"); Function *BarImpl =
MB1.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "bar");
BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl); BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
IRBuilder<> Builder(BarEntry); IRBuilder<> Builder(BarEntry);
IntegerType *Int32Ty = IntegerType::get(Context, 32); IntegerType *Int32Ty = IntegerType::get(Context, 32);
Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42); Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
Builder.CreateRet(FourtyTwo); Builder.CreateRet(FourtyTwo);
} }
auto Obj1 = Compile(*MB1.getModule()); auto Obj1 = Compile(*MB1.getModule());
ModuleBuilder MB2(Context, "", "dummy"); ModuleBuilder MB2(Context, "", "dummy");
{ {
MB2.getModule()->setDataLayout(TM->createDataLayout()); MB2.getModule()->setDataLayout(TM->createDataLayout());
Function *BarDecl = MB2.createFunctionDecl<int32_t(void)>("bar"); Function *BarDecl =
Function *FooImpl = MB2.createFunctionDecl<int32_t(void)>("foo"); MB2.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "bar");
Function *FooImpl =
MB2.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "foo");
BasicBlock *FooEntry = BasicBlock::Create(Context, "entry", FooImpl); BasicBlock *FooEntry = BasicBlock::Create(Context, "entry", FooImpl);
IRBuilder<> Builder(FooEntry); IRBuilder<> Builder(FooEntry);
Builder.CreateRet(Builder.CreateCall(BarDecl)); Builder.CreateRet(Builder.CreateCall(BarDecl));
} }
auto Obj2 = Compile(*MB2.getModule()); auto Obj2 = Compile(*MB2.getModule());
auto K1 = ES.allocateVModule(); auto K1 = ES.allocateVModule();
Resolvers[K1] = std::make_shared<NullResolver>(); Resolvers[K1] = std::make_shared<NullResolver>();
Show All 23 LinesTEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
EXPECT_EQ(MM->FinalizationCount, 1) EXPECT_EQ(MM->FinalizationCount, 1)
<< "Extra call to finalize"; << "Extra call to finalize";
} }
TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) { TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) {
if (!SupportsJIT) if (!SupportsJIT)
return; return;
Type *Int32Ty = IntegerType::get(Context, 32);
ExecutionSession ES; ExecutionSession ES;
auto MM = std::make_shared<SectionMemoryManagerWrapper>(); auto MM = std::make_shared<SectionMemoryManagerWrapper>();
LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey K) { LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey K) {
return LegacyRTDyldObjectLinkingLayer::Resources{ return LegacyRTDyldObjectLinkingLayer::Resources{
MM, std::make_shared<NullResolver>()}; MM, std::make_shared<NullResolver>()};
}); });
Show All 10 LinesTEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) {
// second object is not loaded before the first one is finalized. To do this // second object is not loaded before the first one is finalized. To do this
// in a portable way, we abuse the // in a portable way, we abuse the
// RuntimeDyld::MemoryManager::needsToReserveAllocationSpace hook, which is // RuntimeDyld::MemoryManager::needsToReserveAllocationSpace hook, which is
// called once per object before any sections are allocated. // called once per object before any sections are allocated.
ModuleBuilder MB1(Context, "", "dummy"); ModuleBuilder MB1(Context, "", "dummy");
{ {
MB1.getModule()->setDataLayout(TM->createDataLayout()); MB1.getModule()->setDataLayout(TM->createDataLayout());
Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("foo"); Function *BarImpl =
MB1.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "foo");
BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl); BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
IRBuilder<> Builder(BarEntry); IRBuilder<> Builder(BarEntry);
IntegerType *Int32Ty = IntegerType::get(Context, 32); IntegerType *Int32Ty = IntegerType::get(Context, 32);
Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42); Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
Builder.CreateRet(FourtyTwo); Builder.CreateRet(FourtyTwo);
} }
auto Obj1 = Compile(*MB1.getModule()); auto Obj1 = Compile(*MB1.getModule());
ModuleBuilder MB2(Context, "", "dummy"); ModuleBuilder MB2(Context, "", "dummy");
{ {
MB2.getModule()->setDataLayout(TM->createDataLayout()); MB2.getModule()->setDataLayout(TM->createDataLayout());
Function *BarImpl = MB2.createFunctionDecl<int32_t(void)>("bar"); Function *BarImpl =
MB2.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "bar");
BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl); BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
IRBuilder<> Builder(BarEntry); IRBuilder<> Builder(BarEntry);
IntegerType *Int32Ty = IntegerType::get(Context, 32); IntegerType *Int32Ty = IntegerType::get(Context, 32);
Value *Seven = ConstantInt::getSigned(Int32Ty, 7); Value *Seven = ConstantInt::getSigned(Int32Ty, 7);
Builder.CreateRet(Seven); Builder.CreateRet(Seven);
} }
auto Obj2 = Compile(*MB2.getModule()); auto Obj2 = Compile(*MB2.getModule());
Show All 25 Lines

llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

Show All 21 Lines
namespace llvm { namespace llvm {
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
class OrcCAPIExecutionTest : public testing::Test, public OrcExecutionTest { class OrcCAPIExecutionTest : public testing::Test, public OrcExecutionTest {
protected: protected:
std::unique_ptr<Module> createTestModule(const Triple &TT) { std::unique_ptr<Module> createTestModule(const Triple &TT) {
ModuleBuilder MB(Context, TT.str(), ""); ModuleBuilder MB(Context, TT.str(), "");
Function *TestFunc = MB.createFunctionDecl<int()>("testFunc"); Type *IntTy = Type::getScalarTy<int>(Context);
Function *Main = MB.createFunctionDecl<int(int, char*[])>("main"); Function *TestFunc =
MB.createFunctionDecl(FunctionType::get(IntTy, {}, false), "testFunc");
Function *Main = MB.createFunctionDecl(
FunctionType::get(
IntTy,
{IntTy, Type::getInt8PtrTy(Context)->getPointerTo()},
false),
"main");
Main->getBasicBlockList().push_back(BasicBlock::Create(Context)); Main->getBasicBlockList().push_back(BasicBlock::Create(Context));
IRBuilder<> B(&Main->back()); IRBuilder<> B(&Main->back());
Value* Result = B.CreateCall(TestFunc); Value* Result = B.CreateCall(TestFunc);
B.CreateRet(Result); B.CreateRet(Result);
return MB.takeModule(); return MB.takeModule();
} }
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

llvm/trunk/unittests/ExecutionEngine/Orc/OrcTestCommon.h

Show All 16 Lines
#include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/JITSymbol.h" #include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h" #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/TypeBuilder.h"
#include "llvm/Object/ObjectFile.h" #include "llvm/Object/ObjectFile.h"
#include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/TargetSelect.h" #include "llvm/Support/TargetSelect.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <memory> #include <memory>
namespace llvm { namespace llvm {
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Linesprotected:
bool SupportsIndirection = false; bool SupportsIndirection = false;
}; };
class ModuleBuilder { class ModuleBuilder {
public: public:
ModuleBuilder(LLVMContext &Context, StringRef Triple, ModuleBuilder(LLVMContext &Context, StringRef Triple,
StringRef Name); StringRef Name);
template <typename FuncType> Function *createFunctionDecl(FunctionType *FTy, StringRef Name) {
Function* createFunctionDecl(StringRef Name) { return Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M.get());
return Function::Create(
TypeBuilder<FuncType, false>::get(M->getContext()),
GlobalValue::ExternalLinkage, Name, M.get());
} }
Module* getModule() { return M.get(); } Module* getModule() { return M.get(); }
const Module* getModule() const { return M.get(); } const Module* getModule() const { return M.get(); }
std::unique_ptr<Module> takeModule() { return std::move(M); } std::unique_ptr<Module> takeModule() { return std::move(M); }
private: private:
std::unique_ptr<Module> M; std::unique_ptr<Module> M;
}; };
// Dummy struct type. // Dummy struct type.
struct DummyStruct { struct DummyStruct {
int X[256]; int X[256];
}; };
// TypeBuilder specialization for DummyStruct. inline StructType *getDummyStructTy(LLVMContext &Context) {
template <bool XCompile> return StructType::get(ArrayType::get(Type::getInt32Ty(Context), 256));
class TypeBuilder<DummyStruct, XCompile> {
public:
static StructType *get(LLVMContext &Context) {
return StructType::get(
TypeBuilder<types::i<32>[256], XCompile>::get(Context));
} }
};
template <typename HandleT, typename ModuleT> template <typename HandleT, typename ModuleT>
class MockBaseLayer { class MockBaseLayer {
public: public:
using ModuleHandleT = HandleT; using ModuleHandleT = HandleT;
using AddModuleSignature = using AddModuleSignature =
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/trunk/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 LinesTEST(RTDyldObjectLinkingLayerTest, TestOverrideObjectFlags) {
// Create a module with two void() functions: foo and bar. // Create a module with two void() functions: foo and bar.
ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>()); ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
ThreadSafeModule M; ThreadSafeModule M;
{ {
ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy"); ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy");
MB.getModule()->setDataLayout(TM->createDataLayout()); MB.getModule()->setDataLayout(TM->createDataLayout());
Function *FooImpl = MB.createFunctionDecl<void()>("foo"); Function *FooImpl = MB.createFunctionDecl(
FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
"foo");
BasicBlock *FooEntry = BasicBlock *FooEntry =
BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl); BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
IRBuilder<> B1(FooEntry); IRBuilder<> B1(FooEntry);
B1.CreateRetVoid(); B1.CreateRetVoid();
Function *BarImpl = MB.createFunctionDecl<void()>("bar"); Function *BarImpl = MB.createFunctionDecl(
FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
"bar");
BasicBlock *BarEntry = BasicBlock *BarEntry =
BasicBlock::Create(*TSCtx.getContext(), "entry", BarImpl); BasicBlock::Create(*TSCtx.getContext(), "entry", BarImpl);
IRBuilder<> B2(BarEntry); IRBuilder<> B2(BarEntry);
B2.CreateRetVoid(); B2.CreateRetVoid();
M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx)); M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
} }
Show All 27 LinesTEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) {
// Our compiler is going to add a new symbol without telling ORC. // Our compiler is going to add a new symbol without telling ORC.
// This will test our ability to auto-claim responsibility later. // This will test our ability to auto-claim responsibility later.
class FunkySimpleCompiler : public SimpleCompiler { class FunkySimpleCompiler : public SimpleCompiler {
public: public:
FunkySimpleCompiler(TargetMachine &TM) : SimpleCompiler(TM) {} FunkySimpleCompiler(TargetMachine &TM) : SimpleCompiler(TM) {}
CompileResult operator()(Module &M) { CompileResult operator()(Module &M) {
Function *BarImpl = Function *BarImpl = Function::Create(
Function::Create(TypeBuilder<void(), false>::get(M.getContext()), FunctionType::get(Type::getVoidTy(M.getContext()), {}, false),
GlobalValue::ExternalLinkage, "bar", &M); GlobalValue::ExternalLinkage, "bar", &M);
BasicBlock *BarEntry = BasicBlock *BarEntry =
BasicBlock::Create(M.getContext(), "entry", BarImpl); BasicBlock::Create(M.getContext(), "entry", BarImpl);
IRBuilder<> B(BarEntry); IRBuilder<> B(BarEntry);
B.CreateRetVoid(); B.CreateRetVoid();
return SimpleCompiler::operator()(M); return SimpleCompiler::operator()(M);
} }
}; };
// Create a module with two void() functions: foo and bar. // Create a module with two void() functions: foo and bar.
ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>()); ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
ThreadSafeModule M; ThreadSafeModule M;
{ {
ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy"); ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy");
MB.getModule()->setDataLayout(TM->createDataLayout()); MB.getModule()->setDataLayout(TM->createDataLayout());
Function *FooImpl = MB.createFunctionDecl<void()>("foo"); Function *FooImpl = MB.createFunctionDecl(
FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
"foo");
BasicBlock *FooEntry = BasicBlock *FooEntry =
BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl); BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
IRBuilder<> B(FooEntry); IRBuilder<> B(FooEntry);
B.CreateRetVoid(); B.CreateRetVoid();
M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx)); M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
} }
Show All 18 Lines

llvm/trunk/unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 LinesMockObjectLayer::ObjectPtr createTestObject() {
auto TM = std::unique_ptr<TargetMachine>(EngineBuilder().selectTarget()); auto TM = std::unique_ptr<TargetMachine>(EngineBuilder().selectTarget());
if (!TM) if (!TM)
return nullptr; return nullptr;
LLVMContext Ctx; LLVMContext Ctx;
ModuleBuilder MB(Ctx, TM->getTargetTriple().str(), "TestModule"); ModuleBuilder MB(Ctx, TM->getTargetTriple().str(), "TestModule");
MB.getModule()->setDataLayout(TM->createDataLayout()); MB.getModule()->setDataLayout(TM->createDataLayout());
auto *Main = MB.createFunctionDecl<void(int, char**)>("main"); auto *Main = MB.createFunctionDecl(
FunctionType::get(Type::getInt32Ty(Ctx),
{Type::getInt32Ty(Ctx),
Type::getInt8PtrTy(Ctx)->getPointerTo()},
false),
"main");
Main->getBasicBlockList().push_back(BasicBlock::Create(Ctx)); Main->getBasicBlockList().push_back(BasicBlock::Create(Ctx));
IRBuilder<> B(&Main->back()); IRBuilder<> B(&Main->back());
B.CreateRet(ConstantInt::getSigned(Type::getInt32Ty(Ctx), 42)); B.CreateRet(ConstantInt::getSigned(Type::getInt32Ty(Ctx), 42));
SimpleCompiler IRCompiler(*TM); SimpleCompiler IRCompiler(*TM);
return IRCompiler(*MB.getModule()); return IRCompiler(*MB.getModule());
} }
▲ Show 20 Lines • Show All 478 Lines • Show Last 20 Lines

llvm/trunk/unittests/IR/CFGBuilder.cpp

//===- llvm/Testing/Support/CFGBuilder.cpp --------------------------------===// //===- llvm/Testing/Support/CFGBuilder.cpp --------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CFGBuilder.h" #include "CFGBuilder.h"
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/TypeBuilder.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#define DEBUG_TYPE "cfg-builder" #define DEBUG_TYPE "cfg-builder"
using namespace llvm; using namespace llvm;
CFGHolder::CFGHolder(StringRef ModuleName, StringRef FunctionName) CFGHolder::CFGHolder(StringRef ModuleName, StringRef FunctionName)
: Context(llvm::make_unique<LLVMContext>()), : Context(llvm::make_unique<LLVMContext>()),
M(llvm::make_unique<Module>(ModuleName, *Context)) { M(llvm::make_unique<Module>(ModuleName, *Context)) {
FunctionType *FTy = TypeBuilder<void(), false>::get(*Context); FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Context), {}, false);
F = cast<Function>(M->getOrInsertFunction(FunctionName, FTy)); F = cast<Function>(M->getOrInsertFunction(FunctionName, FTy));
} }
CFGHolder::~CFGHolder() = default; CFGHolder::~CFGHolder() = default;
CFGBuilder::CFGBuilder(Function *F, const std::vector<Arc> &InitialArcs, CFGBuilder::CFGBuilder(Function *F, const std::vector<Arc> &InitialArcs,
std::vector<Update> Updates) std::vector<Update> Updates)
: F(F), Updates(std::move(Updates)) { : F(F), Updates(std::move(Updates)) {
assert(F); assert(F);
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

llvm/trunk/unittests/IR/CMakeLists.txt

Show All 24 Linesadd_llvm_unittest(IRTests
IntrinsicsTest.cpp IntrinsicsTest.cpp
LegacyPassManagerTest.cpp LegacyPassManagerTest.cpp
MDBuilderTest.cpp MDBuilderTest.cpp
ManglerTest.cpp ManglerTest.cpp
MetadataTest.cpp MetadataTest.cpp
ModuleTest.cpp ModuleTest.cpp
PassManagerTest.cpp PassManagerTest.cpp
PatternMatch.cpp PatternMatch.cpp
TypeBuilderTest.cpp
TypesTest.cpp TypesTest.cpp
UseTest.cpp UseTest.cpp
UserTest.cpp UserTest.cpp
ValueHandleTest.cpp ValueHandleTest.cpp
ValueMapTest.cpp ValueMapTest.cpp
ValueTest.cpp ValueTest.cpp
VerifierTest.cpp VerifierTest.cpp
WaymarkTest.cpp WaymarkTest.cpp
) )
target_link_libraries(IRTests PRIVATE LLVMTestingSupport) target_link_libraries(IRTests PRIVATE LLVMTestingSupport)

llvm/trunk/unittests/IR/TypeBuilderTest.cpp

//===- llvm/unittest/TypeBuilderTest.cpp - TypeBuilder tests --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/IR/TypeBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
TEST(TypeBuilderTest, Void) {
LLVMContext Context;
EXPECT_EQ(Type::getVoidTy(Context), (TypeBuilder<void, true>::get(Context)));
EXPECT_EQ(Type::getVoidTy(Context), (TypeBuilder<void, false>::get(Context)));
// Special cases for C compatibility:
EXPECT_EQ(Type::getInt8PtrTy(Context),
(TypeBuilder<void *, false>::get(Context)));
EXPECT_EQ(Type::getInt8PtrTy(Context),
(TypeBuilder<const void *, false>::get(Context)));
EXPECT_EQ(Type::getInt8PtrTy(Context),
(TypeBuilder<volatile void *, false>::get(Context)));
EXPECT_EQ(Type::getInt8PtrTy(Context),
(TypeBuilder<const volatile void *, false>::get(Context)));
}
TEST(TypeBuilderTest, HostIntegers) {
LLVMContext Context;
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<int8_t, false>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<uint8_t, false>::get(Context)));
EXPECT_EQ(Type::getInt16Ty(Context),
(TypeBuilder<int16_t, false>::get(Context)));
EXPECT_EQ(Type::getInt16Ty(Context),
(TypeBuilder<uint16_t, false>::get(Context)));
EXPECT_EQ(Type::getInt32Ty(Context),
(TypeBuilder<int32_t, false>::get(Context)));
EXPECT_EQ(Type::getInt32Ty(Context),
(TypeBuilder<uint32_t, false>::get(Context)));
EXPECT_EQ(Type::getInt64Ty(Context),
(TypeBuilder<int64_t, false>::get(Context)));
EXPECT_EQ(Type::getInt64Ty(Context),
(TypeBuilder<uint64_t, false>::get(Context)));
EXPECT_EQ(IntegerType::get(Context, sizeof(size_t) * CHAR_BIT),
(TypeBuilder<size_t, false>::get(Context)));
EXPECT_EQ(IntegerType::get(Context, sizeof(ptrdiff_t) * CHAR_BIT),
(TypeBuilder<ptrdiff_t, false>::get(Context)));
}
TEST(TypeBuilderTest, CrossCompilableIntegers) {
LLVMContext Context;
EXPECT_EQ(IntegerType::get(Context, 1),
(TypeBuilder<types::i<1>, true>::get(Context)));
EXPECT_EQ(IntegerType::get(Context, 1),
(TypeBuilder<types::i<1>, false>::get(Context)));
EXPECT_EQ(IntegerType::get(Context, 72),
(TypeBuilder<types::i<72>, true>::get(Context)));
EXPECT_EQ(IntegerType::get(Context, 72),
(TypeBuilder<types::i<72>, false>::get(Context)));
}
TEST(TypeBuilderTest, Float) {
LLVMContext Context;
EXPECT_EQ(Type::getFloatTy(Context),
(TypeBuilder<float, false>::get(Context)));
EXPECT_EQ(Type::getDoubleTy(Context),
(TypeBuilder<double, false>::get(Context)));
// long double isn't supported yet.
EXPECT_EQ(Type::getFloatTy(Context),
(TypeBuilder<types::ieee_float, true>::get(Context)));
EXPECT_EQ(Type::getFloatTy(Context),
(TypeBuilder<types::ieee_float, false>::get(Context)));
EXPECT_EQ(Type::getDoubleTy(Context),
(TypeBuilder<types::ieee_double, true>::get(Context)));
EXPECT_EQ(Type::getDoubleTy(Context),
(TypeBuilder<types::ieee_double, false>::get(Context)));
EXPECT_EQ(Type::getX86_FP80Ty(Context),
(TypeBuilder<types::x86_fp80, true>::get(Context)));
EXPECT_EQ(Type::getX86_FP80Ty(Context),
(TypeBuilder<types::x86_fp80, false>::get(Context)));
EXPECT_EQ(Type::getFP128Ty(Context),
(TypeBuilder<types::fp128, true>::get(Context)));
EXPECT_EQ(Type::getFP128Ty(Context),
(TypeBuilder<types::fp128, false>::get(Context)));
EXPECT_EQ(Type::getPPC_FP128Ty(Context),
(TypeBuilder<types::ppc_fp128, true>::get(Context)));
EXPECT_EQ(Type::getPPC_FP128Ty(Context),
(TypeBuilder<types::ppc_fp128, false>::get(Context)));
}
TEST(TypeBuilderTest, Derived) {
LLVMContext Context;
EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)),
(TypeBuilder<int8_t **, false>::get(Context)));
EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7),
(TypeBuilder<int8_t[7], false>::get(Context)));
EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0),
(TypeBuilder<int8_t[], false>::get(Context)));
EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)),
(TypeBuilder<types::i<8> **, false>::get(Context)));
EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7),
(TypeBuilder<types::i<8>[7], false>::get(Context)));
EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0),
(TypeBuilder<types::i<8>[], false>::get(Context)));
EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)),
(TypeBuilder<types::i<8> **, true>::get(Context)));
EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7),
(TypeBuilder<types::i<8>[7], true>::get(Context)));
EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0),
(TypeBuilder<types::i<8>[], true>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<const int8_t, false>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<volatile int8_t, false>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<const volatile int8_t, false>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<const types::i<8>, false>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<volatile types::i<8>, false>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<const volatile types::i<8>, false>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<const types::i<8>, true>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<volatile types::i<8>, true>::get(Context)));
EXPECT_EQ(Type::getInt8Ty(Context),
(TypeBuilder<const volatile types::i<8>, true>::get(Context)));
EXPECT_EQ(Type::getInt8PtrTy(Context),
(TypeBuilder<const volatile int8_t *const volatile, false>::get(
Context)));
}
TEST(TypeBuilderTest, Functions) {
LLVMContext Context;
std::vector<Type*> params;
EXPECT_EQ(FunctionType::get(Type::getVoidTy(Context), params, false),
(TypeBuilder<void(), true>::get(Context)));
EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
(TypeBuilder<int8_t(...), false>::get(Context)));
params.push_back(TypeBuilder<int32_t *, false>::get(Context));
EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
(TypeBuilder<int8_t(const int32_t *), false>::get(Context)));
EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
(TypeBuilder<int8_t(const int32_t *, ...), false>::get(Context)));
params.push_back(TypeBuilder<char *, false>::get(Context));
EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
(TypeBuilder<int8_t(int32_t *, void *), false>::get(Context)));
EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
(TypeBuilder<int8_t(int32_t *, char *, ...), false>::get(Context)));
params.push_back(TypeBuilder<char, false>::get(Context));
EXPECT_EQ(
FunctionType::get(Type::getInt8Ty(Context), params, false),
(TypeBuilder<int8_t(int32_t *, void *, char), false>::get(Context)));
EXPECT_EQ(
FunctionType::get(Type::getInt8Ty(Context), params, true),
(TypeBuilder<int8_t(int32_t *, char *, char, ...), false>::get(Context)));
params.push_back(TypeBuilder<char, false>::get(Context));
EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
(TypeBuilder<int8_t(int32_t *, void *, char, char), false>::get(
Context)));
EXPECT_EQ(
FunctionType::get(Type::getInt8Ty(Context), params, true),
(TypeBuilder<int8_t(int32_t *, char *, char, char, ...), false>::get(
Context)));
params.push_back(TypeBuilder<char, false>::get(Context));
EXPECT_EQ(
FunctionType::get(Type::getInt8Ty(Context), params, false),
(TypeBuilder<int8_t(int32_t *, void *, char, char, char), false>::get(
Context)));
EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
(TypeBuilder<int8_t(int32_t *, char *, char, char, char, ...),
false>::get(Context)));
}
TEST(TypeBuilderTest, Context) {
// We used to cache TypeBuilder results in static local variables. This
// produced the same type for different contexts, which of course broke
// things.
LLVMContext context1;
EXPECT_EQ(&context1,
&(TypeBuilder<types::i<1>, true>::get(context1))->getContext());
LLVMContext context2;
EXPECT_EQ(&context2,
&(TypeBuilder<types::i<1>, true>::get(context2))->getContext());
}
struct MyType {
int a;
int *b;
void *array[1];
};
struct MyPortableType {
int32_t a;
int32_t *b;
void *array[1];
};
} // anonymous namespace
namespace llvm {
template<bool cross> class TypeBuilder<MyType, cross> {
public:
static StructType *get(LLVMContext &Context) {
// Using the static result variable ensures that the type is
// only looked up once.
std::vector<Type*> st;
st.push_back(TypeBuilder<int, cross>::get(Context));
st.push_back(TypeBuilder<int*, cross>::get(Context));
st.push_back(TypeBuilder<void*[], cross>::get(Context));
static StructType *const result = StructType::get(Context, st);
return result;
}
// You may find this a convenient place to put some constants
// to help with getelementptr. They don't have any effect on
// the operation of TypeBuilder.
enum Fields {
FIELD_A,
FIELD_B,
FIELD_ARRAY
};
};
template<bool cross> class TypeBuilder<MyPortableType, cross> {
public:
static StructType *get(LLVMContext &Context) {
// Using the static result variable ensures that the type is
// only looked up once.
std::vector<Type*> st;
st.push_back(TypeBuilder<types::i<32>, cross>::get(Context));
st.push_back(TypeBuilder<types::i<32>*, cross>::get(Context));
st.push_back(TypeBuilder<types::i<8>*[], cross>::get(Context));
static StructType *const result = StructType::get(Context, st);
return result;
}
// You may find this a convenient place to put some constants
// to help with getelementptr. They don't have any effect on
// the operation of TypeBuilder.
enum Fields {
FIELD_A,
FIELD_B,
FIELD_ARRAY
};
};
} // namespace llvm
namespace {
TEST(TypeBuilderTest, Extensions) {
LLVMContext Context;
EXPECT_EQ(PointerType::getUnqual(
StructType::get(TypeBuilder<int, false>::get(Context),
TypeBuilder<int *, false>::get(Context),
TypeBuilder<void *[], false>::get(Context))),
(TypeBuilder<MyType *, false>::get(Context)));
EXPECT_EQ(PointerType::getUnqual(StructType::get(
TypeBuilder<types::i<32>, false>::get(Context),
TypeBuilder<types::i<32> *, false>::get(Context),
TypeBuilder<types::i<8> *[], false>::get(Context))),
(TypeBuilder<MyPortableType *, false>::get(Context)));
EXPECT_EQ(PointerType::getUnqual(StructType::get(
TypeBuilder<types::i<32>, false>::get(Context),
TypeBuilder<types::i<32> *, false>::get(Context),
TypeBuilder<types::i<8> *[], false>::get(Context))),
(TypeBuilder<MyPortableType *, true>::get(Context)));
}
} // anonymous namespace

llvm/trunk/utils/gn/secondary/llvm/unittests/IR/BUILD.gn

Show All 27 Lines sources = [
"LegacyPassManagerTest.cpp", "LegacyPassManagerTest.cpp",
"MDBuilderTest.cpp", "MDBuilderTest.cpp",
"ManglerTest.cpp", "ManglerTest.cpp",
"MetadataTest.cpp", "MetadataTest.cpp",
"ModuleTest.cpp", "ModuleTest.cpp",
"PassBuilderCallbacksTest.cpp", "PassBuilderCallbacksTest.cpp",
"PassManagerTest.cpp", "PassManagerTest.cpp",
"PatternMatch.cpp", "PatternMatch.cpp",
"TypeBuilderTest.cpp",
"TypesTest.cpp", "TypesTest.cpp",
"UseTest.cpp", "UseTest.cpp",
"UserTest.cpp", "UserTest.cpp",
"ValueHandleTest.cpp", "ValueHandleTest.cpp",
"ValueMapTest.cpp", "ValueMapTest.cpp",
"ValueTest.cpp", "ValueTest.cpp",
"VerifierTest.cpp", "VerifierTest.cpp",
"WaymarkTest.cpp", "WaymarkTest.cpp",
] ]
} }
llvm/trunk/unittests/IR/CFGBuilder.cpp