← Back to branch summary

~ubuntu-branches/ubuntu/trusty/llvm-toolchain-snapshot/trusty-201310232150

« back to all changes in this revision

Viewing changes to unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-27 15:01:57 UTC
  • mfrom: (0.10.1) (0.9.1) (0.8.1) (0.7.1) (0.6.1) (0.5.2)
  • Revision ID: package-import@ubuntu.com-20130527150157-tdkrsjpuvht7v0qx
Tags: 1:3.4~svn182733-1~exp1
http://bugs.debian.org/708677
* New snapshot release (3.4 release)
* Add a symlink of libLLVM-3.4.so.1 to usr/lib/llvm-3.4/lib/libLLVM-3.4.so
    to fix make the llvm-config-3.4 --libdir work (Closes: #708677)
  * Various packages rename to allow co installations:
    * libclang1 => libclang1-3.4
    * libclang1-dbg => libclang1-3.4-dbg
    * libclang-dev => libclang-3.4-dev
    * libclang-common-dev => libclang-common-3.4-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp
 
1
//===- MCJITTest.cpp - Unit tests for the MCJIT ---------------------------===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This test suite verifies basic MCJIT functionality when invoked form the C
 
11
// API.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
#include "llvm-c/Analysis.h"
 
16
#include "llvm-c/Core.h"
 
17
#include "llvm-c/ExecutionEngine.h"
 
18
#include "llvm-c/Target.h"
 
19
#include "llvm-c/Transforms/Scalar.h"
 
20
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 
21
#include "llvm/Support/Host.h"
 
22
#include "MCJITTestAPICommon.h"
 
23
#include "gtest/gtest.h"
 
24
 
 
25
using namespace llvm;
 
26
 
 
27
static bool didCallAllocateCodeSection;
 
28
 
 
29
static uint8_t *roundTripAllocateCodeSection(void *object, uintptr_t size,
 
30
                                             unsigned alignment,
 
31
                                             unsigned sectionID) {
 
32
  didCallAllocateCodeSection = true;
 
33
  return static_cast<SectionMemoryManager*>(object)->allocateCodeSection(
 
34
    size, alignment, sectionID);
 
35
}
 
36
 
 
37
static uint8_t *roundTripAllocateDataSection(void *object, uintptr_t size,
 
38
                                             unsigned alignment,
 
39
                                             unsigned sectionID,
 
40
                                             LLVMBool isReadOnly) {
 
41
  return static_cast<SectionMemoryManager*>(object)->allocateDataSection(
 
42
    size, alignment, sectionID, isReadOnly);
 
43
}
 
44
 
 
45
static LLVMBool roundTripFinalizeMemory(void *object, char **errMsg) {
 
46
  std::string errMsgString;
 
47
  bool result =
 
48
    static_cast<SectionMemoryManager*>(object)->finalizeMemory(&errMsgString);
 
49
  if (result) {
 
50
    *errMsg = LLVMCreateMessage(errMsgString.c_str());
 
51
    return 1;
 
52
  }
 
53
  return 0;
 
54
}
 
55
 
 
56
static void roundTripDestroy(void *object) {
 
57
  delete static_cast<SectionMemoryManager*>(object);
 
58
}
 
59
 
 
60
class MCJITCAPITest : public testing::Test, public MCJITTestAPICommon {
 
61
protected:
 
62
  MCJITCAPITest() {
 
63
    // The architectures below are known to be compatible with MCJIT as they
 
64
    // are copied from test/ExecutionEngine/MCJIT/lit.local.cfg and should be
 
65
    // kept in sync.
 
66
    SupportedArchs.push_back(Triple::aarch64);
 
67
    SupportedArchs.push_back(Triple::arm);
 
68
    SupportedArchs.push_back(Triple::mips);
 
69
    SupportedArchs.push_back(Triple::x86);
 
70
    SupportedArchs.push_back(Triple::x86_64);
 
71
 
 
72
    // Some architectures have sub-architectures in which tests will fail, like
 
73
    // ARM. These two vectors will define if they do have sub-archs (to avoid
 
74
    // extra work for those who don't), and if so, if they are listed to work
 
75
    HasSubArchs.push_back(Triple::arm);
 
76
    SupportedSubArchs.push_back("armv6");
 
77
    SupportedSubArchs.push_back("armv7");
 
78
 
 
79
    // The operating systems below are known to be sufficiently incompatible
 
80
    // that they will fail the MCJIT C API tests.
 
81
    UnsupportedOSs.push_back(Triple::Cygwin);
 
82
  }
 
83
  
 
84
  virtual void SetUp() {
 
85
    didCallAllocateCodeSection = false;
 
86
    Module = 0;
 
87
    Function = 0;
 
88
    Engine = 0;
 
89
    Error = 0;
 
90
  }
 
91
  
 
92
  virtual void TearDown() {
 
93
    if (Engine)
 
94
      LLVMDisposeExecutionEngine(Engine);
 
95
    else if (Module)
 
96
      LLVMDisposeModule(Module);
 
97
  }
 
98
  
 
99
  void buildSimpleFunction() {
 
100
    Module = LLVMModuleCreateWithName("simple_module");
 
101
    
 
102
    LLVMSetTarget(Module, HostTriple.c_str());
 
103
    
 
104
    Function = LLVMAddFunction(
 
105
      Module, "simple_function", LLVMFunctionType(LLVMInt32Type(), 0, 0, 0));
 
106
    LLVMSetFunctionCallConv(Function, LLVMCCallConv);
 
107
    
 
108
    LLVMBasicBlockRef entry = LLVMAppendBasicBlock(Function, "entry");
 
109
    LLVMBuilderRef builder = LLVMCreateBuilder();
 
110
    LLVMPositionBuilderAtEnd(builder, entry);
 
111
    LLVMBuildRet(builder, LLVMConstInt(LLVMInt32Type(), 42, 0));
 
112
    
 
113
    LLVMVerifyModule(Module, LLVMAbortProcessAction, &Error);
 
114
    LLVMDisposeMessage(Error);
 
115
    
 
116
    LLVMDisposeBuilder(builder);
 
117
  }
 
118
  
 
119
  void buildMCJITOptions() {
 
120
    LLVMInitializeMCJITCompilerOptions(&Options, sizeof(Options));
 
121
    Options.OptLevel = 2;
 
122
    
 
123
    // Just ensure that this field still exists.
 
124
    Options.NoFramePointerElim = false;
 
125
  }
 
126
  
 
127
  void useRoundTripSectionMemoryManager() {
 
128
    Options.MCJMM = LLVMCreateSimpleMCJITMemoryManager(
 
129
      new SectionMemoryManager(),
 
130
      roundTripAllocateCodeSection,
 
131
      roundTripAllocateDataSection,
 
132
      roundTripFinalizeMemory,
 
133
      roundTripDestroy);
 
134
  }
 
135
  
 
136
  void buildMCJITEngine() {
 
137
    ASSERT_EQ(
 
138
      0, LLVMCreateMCJITCompilerForModule(&Engine, Module, &Options,
 
139
                                          sizeof(Options), &Error));
 
140
  }
 
141
  
 
142
  void buildAndRunPasses() {
 
143
    LLVMPassManagerRef pass = LLVMCreatePassManager();
 
144
    LLVMAddTargetData(LLVMGetExecutionEngineTargetData(Engine), pass);
 
145
    LLVMAddConstantPropagationPass(pass);
 
146
    LLVMAddInstructionCombiningPass(pass);
 
147
    LLVMRunPassManager(pass, Module);
 
148
    LLVMDisposePassManager(pass);
 
149
  }
 
150
  
 
151
  LLVMModuleRef Module;
 
152
  LLVMValueRef Function;
 
153
  LLVMMCJITCompilerOptions Options;
 
154
  LLVMExecutionEngineRef Engine;
 
155
  char *Error;
 
156
};
 
157
 
 
158
TEST_F(MCJITCAPITest, simple_function) {
 
159
  SKIP_UNSUPPORTED_PLATFORM;
 
160
  
 
161
  buildSimpleFunction();
 
162
  buildMCJITOptions();
 
163
  buildMCJITEngine();
 
164
  buildAndRunPasses();
 
165
  
 
166
  union {
 
167
    void *raw;
 
168
    int (*usable)();
 
169
  } functionPointer;
 
170
  functionPointer.raw = LLVMGetPointerToGlobal(Engine, Function);
 
171
  
 
172
  EXPECT_EQ(42, functionPointer.usable());
 
173
}
 
174
 
 
175
TEST_F(MCJITCAPITest, custom_memory_manager) {
 
176
  SKIP_UNSUPPORTED_PLATFORM;
 
177
  
 
178
  buildSimpleFunction();
 
179
  buildMCJITOptions();
 
180
  useRoundTripSectionMemoryManager();
 
181
  buildMCJITEngine();
 
182
  buildAndRunPasses();
 
183
  
 
184
  union {
 
185
    void *raw;
 
186
    int (*usable)();
 
187
  } functionPointer;
 
188
  functionPointer.raw = LLVMGetPointerToGlobal(Engine, Function);
 
189
  
 
190
  EXPECT_EQ(42, functionPointer.usable());
 
191
  EXPECT_TRUE(didCallAllocateCodeSection);
 
192
}