[LLVMdev] Problem linking and JITing code through C++-API
Andy Jost
Andrew.Jost at synopsys.com
Tue Sep 9 20:09:55 PDT 2014
Thank you for the suggestions, Lang. I was able to make each change except the last one. There is no getFunctionAddress is the version of LLVM I have (3.3).
If I run without that last change, I get (on x86_64):
LLVM ERROR: Target does not support MC emission!
I suppose there’s no reason to debug the original issue any further, since the old JIT has been removed. When I have the time, I’ll see if my project works with a newer version of LLVM.
-Andy
From: Lang Hames [mailto:lhames at gmail.com]
Sent: Monday, September 08, 2014 2:18 PM
To: Reed Kotler
Cc: Andy Jost; LLVMdev at cs.uiuc.edu
Subject: Re: [LLVMdev] Problem linking and JITing code through C++-API
Hi Andy,
It looks like you're using LLVM's old JIT, rather than MCJIT? The old JIT has been removed from the mainline, and is no longer supported. I'd recommend building your own copy of LLVM from the development branch (as Reed suggested) where MCJIT is used by default - this may fix your issue.
If you want to stick with the precompiled binaries, then you should change:
#include "llvm/ExecutionEngine/JIT.h"
to
#include "llvm/ExecutionEngine/MCJIT.h"
and add:
.setUseMCJIT(true)
to your EngineBuilder invocation.
And finally change:
jit->getPointerToFunction(rtlib->getFunction("main"));
to
jit->getFunctionAddress("main");
Cheers,
Lang.
On Tue, Sep 2, 2014 at 4:28 PM, Reed Kotler <Reed.Kotler at imgtec.com<mailto:Reed.Kotler at imgtec.com>> wrote:
It's really easy to build LLVM from source on any linux environment.
________________________________________
From: Andy Jost [Andrew.Jost at synopsys.com<mailto:Andrew.Jost at synopsys.com>]
Sent: Tuesday, September 02, 2014 4:00 PM
To: Reed Kotler; Andy Jost; LLVMdev at cs.uiuc.edu<mailto:LLVMdev at cs.uiuc.edu>
Subject: RE: Problem linking and JITing code through C++-API
Yes. It appears that a bad reference to DataLayout was passed to MachineJumpTableInfo::getEntrySize. I'm using LLVM as a pre-compiled Ubuntu package for this work, so I can't do much more in GDB without building from source.
Program received signal SIGSEGV, Segmentation fault.
0x00000000007565f0 in llvm::MachineJumpTableInfo::getEntrySize(llvm::DataLayout const&) const ()
(gdb) where
#0 0x00000000007565f0 in llvm::MachineJumpTableInfo::getEntrySize(llvm::DataLayout const&) const ()
#1 0x0000000000704313 in (anonymous namespace)::JITEmitter::getJumpTableEntryAddress(unsigned int) const ()
#2 0x000000000070bce1 in (anonymous namespace)::JITEmitter::finishFunction(llvm::MachineFunction&) ()
#3 0x0000000000474430 in (anonymous namespace)::Emitter<llvm::JITCodeEmitter>::runOnMachineFunction(llvm::MachineFunction&) ()
#4 0x0000000000b214dc in llvm::FPPassManager::runOnFunction(llvm::Function&) ()
#5 0x0000000000b21610 in llvm::FunctionPassManagerImpl::run(llvm::Function&) ()
#6 0x0000000000b216f4 in llvm::FunctionPassManager::run(llvm::Function&) ()
#7 0x00000000006fe26e in llvm::JIT::jitTheFunction(llvm::Function*, llvm::MutexGuard const&) ()
#8 0x00000000006fe8cf in llvm::JIT::runJITOnFunctionUnlocked(llvm::Function*, llvm::MutexGuard const&) ()
#9 0x00000000006fead2 in llvm::JIT::getPointerToFunction(llvm::Function*) ()
#10 0x00000000006fd63f in llvm::JIT::getPointerToBasicBlock(llvm::BasicBlock*) ()
#11 0x00000000009e14ee in llvm::ExecutionEngine::getConstantValue(llvm::Constant const*) ()
#12 0x00000000009e265f in llvm::ExecutionEngine::InitializeMemory(llvm::Constant const*, void*) ()
#13 0x00000000009e27e3 in llvm::ExecutionEngine::InitializeMemory(llvm::Constant const*, void*) ()
#14 0x00000000009e3628 in llvm::ExecutionEngine::EmitGlobalVariable(llvm::GlobalVariable const*) ()
#15 0x00000000006fd559 in llvm::JIT::getOrEmitGlobalVariable(llvm::GlobalVariable const*) ()
#16 0x000000000070b8cd in (anonymous namespace)::JITEmitter::getPointerToGlobal(llvm::GlobalValue*, void*, bool) [clone .isra.439] ()
#17 0x000000000070c505 in (anonymous namespace)::JITEmitter::finishFunction(llvm::MachineFunction&) ()
#18 0x0000000000474430 in (anonymous namespace)::Emitter<llvm::JITCodeEmitter>::runOnMachineFunction(llvm::MachineFunction&) ()
#19 0x0000000000b214dc in llvm::FPPassManager::runOnFunction(llvm::Function&) ()
#20 0x0000000000b21610 in llvm::FunctionPassManagerImpl::run(llvm::Function&) ()
#21 0x0000000000b216f4 in llvm::FunctionPassManager::run(llvm::Function&) ()
#22 0x00000000006fe26e in llvm::JIT::jitTheFunction(llvm::Function*, llvm::MutexGuard const&) ()
#23 0x00000000006fe8fa in llvm::JIT::runJITOnFunctionUnlocked(llvm::Function*, llvm::MutexGuard const&) ()
#24 0x00000000006fead2 in llvm::JIT::getPointerToFunction(llvm::Function*) ()
#25 0x00000000004285e7 in main () at sprite.cpp:172
(gdb) x/10i $pc
=> 0x7565f0 <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE>: cmpl $0x5,(%rdi)
0x7565f3 <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+3>: mov (%rdi),%edx
0x7565f5 <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+5>: lea 0x4ccc5c(%rip),%rax # 0xc23258
0x7565fc <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+12>: movslq (%rax,%rdx,4),%rdx
0x756600 <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+16>: add %rdx,%rax
0x756603 <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+19>: jmpq *%rax
0x756605 <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+21>: nopl (%rax)
0x756608 <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+24>: mov $0x4,%eax
0x75660d <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+29>: retq
0x75660e <_ZNK4llvm20MachineJumpTableInfo12getEntrySizeERKNS_10DataLayoutE+30>: xchg %ax,%ax
(gdb) x $rdi
0x3eb000003ec: Cannot access memory at address 0x3eb000003ec
-----Original Message-----
From: Reed Kotler [mailto:rkotler at mips.com<mailto:rkotler at mips.com>]
Sent: Tuesday, September 02, 2014 3:33 PM
To: Andy Jost; LLVMdev at cs.uiuc.edu<mailto:LLVMdev at cs.uiuc.edu>
Subject: Re: Problem linking and JITing code through C++-API
Have you tried running this under gdb and looking at where the segmentation fault occurs?
On 09/01/2014 04:41 PM, Andy Jost wrote:
> I have a frontend that generates some LLVM bitcode that needs to be
> linked with other bitcode (its runtime library), which I generate from
> C++ source using Clang.
>
> If I write the output of my program to disk, link it with llvm-link, and
> then run it with lli, everything works perfectly. But if I try to
> perform the linking and running steps in my main program, I get this
> error during llvm::ExecutionEngine::getPointerToFunction:
>
> Stack dump:
>
> 0. Running pass 'X86 Machine Code Emitter' on function
> '@.step.myappend'
>
> 1. Running pass 'X86 Machine Code Emitter' on function
> '@.step.myappend'
>
> Segmentation fault (core dumped)
>
> There are no other messages. Any idea what I'm doing wrong? I'll copy
> the source of my main C++ file and the bitcode for .step.myappend
> below. I can send the full bitcode file, too, if someone asks for it,
> but it is around 800 lines.
>
> ####################
>
> #include <fstream>
>
> #include <iostream>
>
> #include "llvm/Bitcode/ReaderWriter.h"
>
> #include "llvm/ExecutionEngine/JIT.h"
>
> #include "llvm/IR/DataLayout.h"
>
> #include "llvm/Linker.h"
>
> #include "llvm/PassManager.h"
>
> #include "llvm/Support/MemoryBuffer.h"
>
> #include "llvm/Support/raw_ostream.h"
>
> #include "llvm/Support/system_error.h"
>
> #include "llvm/Support/TargetSelect.h"
>
> #include "llvm/Transforms/IPO.h"
>
> #include "llvm/Transforms/Scalar.h"
>
> #include "sprite/compiler.hpp"
>
> #include "sprite/config.hpp"
>
> #include "sprite/curryinput.hpp"
>
> #include "sprite/icurry_parser.hpp"
>
> namespace
>
> {
>
> std::string dirname(std::string const & path)
>
> {
>
> size_t const pos = path.find_last_of("/");
>
> return path.substr(0, pos == std::string::npos ? 0 : pos);
>
> }
>
> std::string basename(std::string const & path)
>
> {
>
> size_t const pos = path.find_last_of("/");
>
> return path.substr(pos == std::string::npos ? 0 : pos + 1);
>
> }
>
> std::string remove_extension(std::string const & path)
>
> {
>
> size_t const pos = path.find_last_of(".");
>
> return pos == std::string::npos ? path : path.substr(0, pos);
>
> }
>
> std::string joinpath(std::string const & dirname, std::string const &
> path)
>
> {
>
> if(!path.empty() && path.front() == '/')
>
> return path;
>
> if(dirname.empty())
>
> return path;
>
> return dirname.back() == '/' ? dirname + path : dirname + "/" + path;
>
> }
>
> }
>
> int main(int argc, char const *argv[])
>
> {
>
> if(argc != 2)
>
> {
>
> std::cerr << "Usage: " << argv[0] << " <file.curry>" << std::endl;
>
> return 1;
>
> }
>
> std::string const curry2read =
>
> std::string(SPRITE_LIBINSTALL) + "/cmc/translator/bin/curry2read";
>
> std::string const curryfile(argv[1]);
>
> std::string const readablefile = joinpath(
>
> dirname(curryfile)
>
> , ".curry/" + remove_extension(basename(curryfile)) + ".read"
>
> );
>
> // Generate the readable Curry file.
>
> int ok = std::system((curry2read + " -q " + curryfile).c_str());
>
> if(ok != 0) return 1;
>
> std::ifstream input(readablefile);
>
> if(!input)
>
> {
>
> std::cerr << "Could not open \"" << readablefile << "\"" << std::endl;
>
> return 1;
>
> }
>
> // Parse the input program.
>
> sprite::curry::Library lib;
>
> input >> lib;
>
> std::string topmodule = lib.modules.front().name;
>
> // sprite::compiler::prettyprint(lib);
>
> // Compile the program.
>
> sprite::compiler::LibrarySTab stab;
>
> sprite::compiler::compile(lib, stab);
>
> // Declare the main function.
>
> namespace tgt = sprite::backend;
>
> auto & module_stab = stab.modules.at<http://stab.modules.at>(topmodule);
>
> auto & compiler = *module_stab.compiler;
>
> tgt::scope _ = module_stab.module_ir;
>
> tgt::extern_(
>
> tgt::types::int_(32)(), "main", {}
>
> , [&]{
>
> // Construct the root expression (just the "main" symbol).
>
> tgt::value root_p = compiler.node_alloc();
>
> sprite::curry::Qname const main_{topmodule, "main"};
>
> root_p = construct(compiler, root_p, {main_, {}});
>
> // Evaluate and then print the root expression.
>
> compiler.rt.normalize(root_p);
>
> compiler.rt.printexpr(root_p, "\n");
>
> tgt::return_(0);
>
> }
>
> );
>
> // module_stab.module_ir->dump();
>
> // Load the runtime library.
>
> llvm::OwningPtr<llvm::MemoryBuffer> buffer;
>
> llvm::error_code err = llvm::MemoryBuffer::getFile(
>
> SPRITE_LIBINSTALL "/sprite-rt.bc", buffer
>
> );
>
> if(err)
>
> {
>
> std::cerr << err.message() << std::endl;
>
> return EXIT_FAILURE;
>
> }
>
> // Make the runtime library into a module.
>
> std::string errmsg;
>
> llvm::Module *rtlib = llvm::ParseBitcodeFile(
>
> buffer.get(), module_stab.module_ir.context(), &errmsg
>
> );
>
> if(!rtlib)
>
> {
>
> std::cerr << errmsg << std::endl;
>
> return EXIT_FAILURE;
>
> }
>
> // Link the compiled program code into the runtime module.
>
> bool failed = llvm::Linker::LinkModules(
>
> rtlib, module_stab.module_ir.ptr(), llvm::Linker::PreserveSource,
> &errmsg
>
> );
>
> if(failed)
>
> {
>
> std::cerr << errmsg << std::endl;
>
> return EXIT_FAILURE;
>
> }
>
> std::cout << "Linking done..." << std::endl;
>
> rtlib->dump();
>
> // Run optimization passes.
>
> // std::vector<const char *> exportList;
>
> // llvm::PassManager Passes;
>
> // Passes.add(new llvm::DataLayout(rtlib));
>
> // Passes.add(llvm::createDemoteRegisterToMemoryPass());
>
> // Passes.add(llvm::createInternalizePass(exportList));
>
> // Passes.add(llvm::createScalarReplAggregatesPass());
>
> // Passes.add(llvm::createInstructionCombiningPass());
>
> // Passes.add(llvm::createGlobalOptimizerPass());
>
> // Passes.add(llvm::createFunctionInliningPass());
>
> // Passes.run(*rtlib);
>
> // Create the JIT
>
> llvm::InitializeNativeTarget();
>
> llvm::ExecutionEngine * jit = llvm::EngineBuilder(rtlib)
>
> .setErrorStr(&errmsg)
>
> .setEngineKind(llvm::EngineKind::JIT)
>
> .create();
>
> if(!jit)
>
> {
>
> std::cerr << "Failed to create JIT compiler: " << errmsg << std::endl;
>
> return EXIT_FAILURE;
>
> }
>
> // Execute the program.
>
> std::cout << "Begin Execution..." << std::endl;
>
> // rtlib->dump();
>
> void * main_fp = jit->getPointerToFunction(rtlib->getFunction("main"));
>
> int32_t (*target_program)() = (int32_t(*)())(intptr_t)(main_fp);
>
> std::cout << "Ready..." << std::endl;
>
> return target_program();
>
> #if 0
>
> // Write a bitcode file and interpret it.
>
> {
>
> std::string err;
>
> llvm::raw_fd_ostream fout("sprite-out.bc", err,
> llvm::raw_fd_ostream::F_Binary);
>
> llvm::WriteBitcodeToFile(module_stab.module_ir.ptr(), fout);
>
> }
>
> std::system("llvm-link-3.3 sprite-out.bc " SPRITE_LIBINSTALL
> "/sprite-rt.bc > tmp.bc");
>
> std::system("mv tmp.bc sprite-out.bc");
>
> int const status = std::system("lli-3.3 sprite-out.bc");
>
> return WEXITSTATUS(status);
>
> #endif
>
> }
>
> ####################
>
> define linkonce void @.step.myappend(%"struct.sprite::compiler::node"*
> %root_p) {
>
> .entry:
>
> %0 = alloca %"struct.sprite::compiler::node"*
>
> %1 = alloca %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %root_p,
> %"struct.sprite::compiler::node"** %0
>
> %2 = load %"struct.sprite::compiler::node"** %0
>
> %3 = getelementptr %"struct.sprite::compiler::node"* %2, i32 0, i32 2
>
> %4 = load i8** %3
>
> %5 = bitcast i8* %4 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %5,
> %"struct.sprite::compiler::node"** %0
>
> br label %11
>
> ; <label>:6 ; preds = %11
>
> %7 = load %"struct.sprite::compiler::node"** %0
>
> %8 = getelementptr %"struct.sprite::compiler::node"* %7, i32 0, i32 2
>
> %9 = load i8** %8
>
> %10 = bitcast i8* %9 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %10,
> %"struct.sprite::compiler::node"** %0
>
> br label %11, !sprite.implied !0
>
> ; <label>:11 ; preds = %6, %.entry
>
> %12 = load %"struct.sprite::compiler::node"** %0
>
> %13 = getelementptr %"struct.sprite::compiler::node"* %12, i32 0, i32 1
>
> %14 = load i64* %13
>
> %15 = load i64* %13
>
> %16 = icmp eq i64 %15, -3
>
> br i1 %16, label %6, label %17
>
> ; <label>:17 ; preds = %11
>
> %18 = load %"struct.sprite::compiler::node"** %0
>
> store %"struct.sprite::compiler::node"* %18,
> %"struct.sprite::compiler::node"** %1
>
> %19 = getelementptr %"struct.sprite::compiler::node"* %18, i32 0, i32 1
>
> %20 = load i64* %19
>
> %21 = add i64 %20, 4
>
> %22 = getelementptr [6 x i8*]* @.jtable, i32 0, i64 %21
>
> %23 = load i8** %22
>
> indirectbr i8* %23, [label %24, label %26, label %36, label %38,
> label %44, label %66]
>
> ; <label>:24 ; preds = %26, %17
>
> %25 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([16 x
> i8]* @.str21, i32 0, i32 0))
>
> ret void, !case...FAIL !1
>
> ; <label>:26 ; preds = %26, %17
>
> %27 = load %"struct.sprite::compiler::node"** %1
>
> %28 = getelementptr %"struct.sprite::compiler::node"* %27, i32 0, i32 2
>
> %29 = load i8** %28
>
> %30 = bitcast i8* %29 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %30,
> %"struct.sprite::compiler::node"** %1
>
> %31 = getelementptr %"struct.sprite::compiler::node"* %30, i32 0, i32 1
>
> %32 = load i64* %31
>
> %33 = add i64 %32, 4
>
> %34 = getelementptr [6 x i8*]* @.jtable, i32 0, i64 %33
>
> %35 = load i8** %34
>
> indirectbr i8* %35, [label %24, label %26, label %36, label %38,
> label %44, label %66]
>
> ; <label>:36 ; preds = %26, %17
>
> %37 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([18 x
> i8]* @.str22, i32 0, i32 0))
>
> ret void, !case...CHOICE !1
>
> ; <label>:38 ; preds = %26, %17
>
> %39 = load %"struct.sprite::compiler::node"** %1
>
> %40 = getelementptr %"struct.sprite::compiler::node"* %39, i32 0, i32 0
>
> %41 = load %"struct.sprite::compiler::vtable"** %40
>
> %42 = getelementptr %"struct.sprite::compiler::vtable"* %41, i32 0, i32 4
>
> %43 = load void (%"struct.sprite::compiler::node"*)** %42
>
> tail call void %43(%"struct.sprite::compiler::node"* %39)
>
> ret void
>
> ; <label>:44 ; preds = %26, %17
>
> store %"struct.sprite::compiler::node"* %root_p,
> %"struct.sprite::compiler::node"** %0
>
> %45 = load %"struct.sprite::compiler::node"** %0
>
> %46 = getelementptr %"struct.sprite::compiler::node"* %45, i32 0, i32 3
>
> %47 = load i8** %46
>
> %48 = bitcast i8* %47 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %48,
> %"struct.sprite::compiler::node"** %0
>
> br label %54
>
> ; <label>:49 ; preds = %54
>
> %50 = load %"struct.sprite::compiler::node"** %0
>
> %51 = getelementptr %"struct.sprite::compiler::node"* %50, i32 0, i32 2
>
> %52 = load i8** %51
>
> %53 = bitcast i8* %52 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %53,
> %"struct.sprite::compiler::node"** %0
>
> br label %54, !sprite.implied !0
>
> ; <label>:54 ; preds = %49, %44
>
> %55 = load %"struct.sprite::compiler::node"** %0
>
> %56 = getelementptr %"struct.sprite::compiler::node"* %55, i32 0, i32 1
>
> %57 = load i64* %56
>
> %58 = load i64* %56
>
> %59 = icmp eq i64 %58, -3
>
> br i1 %59, label %49, label %60
>
> ; <label>:60 ; preds = %54
>
> %61 = load %"struct.sprite::compiler::node"** %0
>
> %62 = bitcast %"struct.sprite::compiler::node"* %61 to i8*
>
> %63 = getelementptr %"struct.sprite::compiler::node"* %root_p, i32 0,
> i32 0
>
> store %"struct.sprite::compiler::vtable"* @.fwd.vt,
> %"struct.sprite::compiler::vtable"** %63
>
> %64 = getelementptr %"struct.sprite::compiler::node"* %root_p, i32 0,
> i32 1
>
> store i64 -3, i64* %64
>
> %65 = getelementptr %"struct.sprite::compiler::node"* %root_p, i32 0,
> i32 2
>
> store i8* %62, i8** %65
>
> ret void
>
> ; <label>:66 ; preds = %26, %17
>
> store %"struct.sprite::compiler::node"* %root_p,
> %"struct.sprite::compiler::node"** %0
>
> %67 = load %"struct.sprite::compiler::node"** %0
>
> %68 = getelementptr %"struct.sprite::compiler::node"* %67, i32 0, i32 2
>
> %69 = load i8** %68
>
> %70 = bitcast i8* %69 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %70,
> %"struct.sprite::compiler::node"** %0
>
> br label %76
>
> ; <label>:71 ; preds = %76
>
> %72 = load %"struct.sprite::compiler::node"** %0
>
> %73 = getelementptr %"struct.sprite::compiler::node"* %72, i32 0, i32 2
>
> %74 = load i8** %73
>
> %75 = bitcast i8* %74 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %75,
> %"struct.sprite::compiler::node"** %0
>
> br label %76, !sprite.implied !0
>
> ; <label>:76 ; preds = %71, %66
>
> %77 = load %"struct.sprite::compiler::node"** %0
>
> %78 = getelementptr %"struct.sprite::compiler::node"* %77, i32 0, i32 1
>
> %79 = load i64* %78
>
> %80 = load i64* %78
>
> %81 = icmp eq i64 %80, -3
>
> br i1 %81, label %71, label %82
>
> ; <label>:82 ; preds = %76
>
> %83 = load %"struct.sprite::compiler::node"** %0
>
> %84 = getelementptr %"struct.sprite::compiler::node"* %83, i32 0, i32 2
>
> %85 = load i8** %84
>
> %86 = bitcast i8* %85 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %86,
> %"struct.sprite::compiler::node"** %0
>
> br label %92
>
> ; <label>:87 ; preds = %92
>
> %88 = load %"struct.sprite::compiler::node"** %0
>
> %89 = getelementptr %"struct.sprite::compiler::node"* %88, i32 0, i32 2
>
> %90 = load i8** %89
>
> %91 = bitcast i8* %90 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %91,
> %"struct.sprite::compiler::node"** %0
>
> br label %92, !sprite.implied !0
>
> ; <label>:92 ; preds = %87, %82
>
> %93 = load %"struct.sprite::compiler::node"** %0
>
> %94 = getelementptr %"struct.sprite::compiler::node"* %93, i32 0, i32 1
>
> %95 = load i64* %94
>
> %96 = load i64* %94
>
> %97 = icmp eq i64 %96, -3
>
> br i1 %97, label %87, label %98
>
> ; <label>:98 ; preds = %92
>
> %99 = load %"struct.sprite::compiler::node"** %0
>
> %100 = bitcast %"struct.sprite::compiler::node"* %99 to i8*
>
> %101 = call i8* @malloc(i64 32)
>
> %102 = bitcast i8* %101 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %root_p,
> %"struct.sprite::compiler::node"** %0
>
> %103 = load %"struct.sprite::compiler::node"** %0
>
> %104 = getelementptr %"struct.sprite::compiler::node"* %103, i32 0, i32 2
>
> %105 = load i8** %104
>
> %106 = bitcast i8* %105 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %106,
> %"struct.sprite::compiler::node"** %0
>
> br label %112
>
> ; <label>:107 ; preds = %112
>
> %108 = load %"struct.sprite::compiler::node"** %0
>
> %109 = getelementptr %"struct.sprite::compiler::node"* %108, i32 0, i32 2
>
> %110 = load i8** %109
>
> %111 = bitcast i8* %110 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %111,
> %"struct.sprite::compiler::node"** %0
>
> br label %112, !sprite.implied !0
>
> ; <label>:112 ; preds = %107, %98
>
> %113 = load %"struct.sprite::compiler::node"** %0
>
> %114 = getelementptr %"struct.sprite::compiler::node"* %113, i32 0, i32 1
>
> %115 = load i64* %114
>
> %116 = load i64* %114
>
> %117 = icmp eq i64 %116, -3
>
> br i1 %117, label %107, label %118
>
> ; <label>:118 ; preds = %112
>
> %119 = load %"struct.sprite::compiler::node"** %0
>
> %120 = getelementptr %"struct.sprite::compiler::node"* %119, i32 0, i32 3
>
> %121 = load i8** %120
>
> %122 = bitcast i8* %121 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %122,
> %"struct.sprite::compiler::node"** %0
>
> br label %128
>
> ; <label>:123 ; preds = %128
>
> %124 = load %"struct.sprite::compiler::node"** %0
>
> %125 = getelementptr %"struct.sprite::compiler::node"* %124, i32 0, i32 2
>
> %126 = load i8** %125
>
> %127 = bitcast i8* %126 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %127,
> %"struct.sprite::compiler::node"** %0
>
> br label %128, !sprite.implied !0
>
> ; <label>:128 ; preds = %123, %118
>
> %129 = load %"struct.sprite::compiler::node"** %0
>
> %130 = getelementptr %"struct.sprite::compiler::node"* %129, i32 0, i32 1
>
> %131 = load i64* %130
>
> %132 = load i64* %130
>
> %133 = icmp eq i64 %132, -3
>
> br i1 %133, label %123, label %134
>
> ; <label>:134 ; preds = %128
>
> %135 = load %"struct.sprite::compiler::node"** %0
>
> %136 = bitcast %"struct.sprite::compiler::node"* %135 to i8*
>
> store %"struct.sprite::compiler::node"* %root_p,
> %"struct.sprite::compiler::node"** %0
>
> %137 = load %"struct.sprite::compiler::node"** %0
>
> %138 = getelementptr %"struct.sprite::compiler::node"* %137, i32 0, i32 3
>
> %139 = load i8** %138
>
> %140 = bitcast i8* %139 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %140,
> %"struct.sprite::compiler::node"** %0
>
> br label %146
>
> ; <label>:141 ; preds = %146
>
> %142 = load %"struct.sprite::compiler::node"** %0
>
> %143 = getelementptr %"struct.sprite::compiler::node"* %142, i32 0, i32 2
>
> %144 = load i8** %143
>
> %145 = bitcast i8* %144 to %"struct.sprite::compiler::node"*
>
> store %"struct.sprite::compiler::node"* %145,
> %"struct.sprite::compiler::node"** %0
>
> br label %146, !sprite.implied !0
>
> ; <label>:146 ; preds = %141, %134
>
> %147 = load %"struct.sprite::compiler::node"** %0
>
> %148 = getelementptr %"struct.sprite::compiler::node"* %147, i32 0, i32 1
>
> %149 = load i64* %148
>
> %150 = load i64* %148
>
> %151 = icmp eq i64 %150, -3
>
> br i1 %151, label %141, label %152
>
> ; <label>:152 ; preds = %146
>
> %153 = load %"struct.sprite::compiler::node"** %0
>
> %154 = bitcast %"struct.sprite::compiler::node"* %153 to i8*
>
> %155 = getelementptr %"struct.sprite::compiler::node"* %102, i32 0, i32 0
>
> store %"struct.sprite::compiler::vtable"* @.vtable.for.myappend,
> %"struct.sprite::compiler::vtable"** %155
>
> %156 = getelementptr %"struct.sprite::compiler::node"* %102, i32 0, i32 1
>
> store i64 -1, i64* %156
>
> %157 = getelementptr %"struct.sprite::compiler::node"* %102, i32 0, i32 2
>
> store i8* %136, i8** %157
>
> %158 = getelementptr %"struct.sprite::compiler::node"* %102, i32 0, i32 3
>
> store i8* %154, i8** %158
>
> %159 = getelementptr %"struct.sprite::compiler::node"* %root_p, i32
> 0, i32 0
>
> store %"struct.sprite::compiler::vtable"* @.vt.CTOR.MyCons,
> %"struct.sprite::compiler::vtable"** %159
>
> %160 = getelementptr %"struct.sprite::compiler::node"* %root_p, i32
> 0, i32 1
>
> store i64 1, i64* %160
>
> %161 = getelementptr %"struct.sprite::compiler::node"* %root_p, i32
> 0, i32 2
>
> store i8* %100, i8** %161
>
> %162 = getelementptr %"struct.sprite::compiler::node"* %root_p, i32
> 0, i32 3
>
> store i8* %101, i8** %162
>
> ret void
>
> }
>
>
>
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu<mailto:LLVMdev at cs.uiuc.edu> http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>
_______________________________________________
LLVM Developers mailing list
LLVMdev at cs.uiuc.edu<mailto:LLVMdev at cs.uiuc.edu> http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20140910/65a4b960/attachment.html>
More information about the llvm-dev
mailing list