JITEmitter.cpp revision d0fde30ce850b78371fd1386338350591f9ff494
1bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner//===-- Emitter.cpp - Write machine code to executable memory -------------===// 2b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 5b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// This file was developed by the LLVM research group and is distributed under 6b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// the University of Illinois Open Source License. See LICENSE.TXT for details. 7b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// 10bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// This file defines a MachineCodeEmitter object that is used by Jello to write 11bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// machine code to memory and remember where relocatable values lie. 12bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// 13bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner//===----------------------------------------------------------------------===// 14bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 153785fad56eb90284d4e930d40e9306391630deb1Chris Lattner#define DEBUG_TYPE "jit" 1636d10ef7e7c7267a9289c6f5904fcf85640926f4Misha Brukman#ifndef _POSIX_MAPPED_FILES 1736d10ef7e7c7267a9289c6f5904fcf85640926f4Misha Brukman#define _POSIX_MAPPED_FILES 1836d10ef7e7c7267a9289c6f5904fcf85640926f4Misha Brukman#endif 19bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner#include "VM.h" 20bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner#include "llvm/CodeGen/MachineCodeEmitter.h" 21bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 221cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner#include "llvm/CodeGen/MachineConstantPool.h" 231cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner#include "llvm/Target/TargetData.h" 24d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman#include "llvm/Module.h" 25c648dabf65c67d20c208ed0b39b9622387e636c7Chris Lattner#include "Support/Debug.h" 26bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner#include "Support/Statistic.h" 2736d10ef7e7c7267a9289c6f5904fcf85640926f4Misha Brukman#include "Config/unistd.h" 2836d10ef7e7c7267a9289c6f5904fcf85640926f4Misha Brukman#include "Config/sys/mman.h" 29bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 30d0fde30ce850b78371fd1386338350591f9ff494Brian Gaekenamespace llvm { 31d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 32bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattnernamespace { 33e738656c0b380e5059cb522927aeb49554d01e46Chris Lattner Statistic<> NumBytes("jit", "Number of bytes of machine code compiled"); 34d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman VM *TheVM = 0; 35bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 36688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /// JITMemoryManager - Manage memory for the JIT code generation in a logical, 37688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /// sane way. This splits a large block of MAP_NORESERVE'd memory into two 38688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /// sections, one for function stubs, one for the functions themselves. We 39688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /// have to do this because we may need to emit a function stub while in the 40688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /// middle of emitting a function, and we don't know how large the function we 41688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /// are emitting is. This never bothers to release the memory, because when 42688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /// we are ready to destroy the JIT, the program exits. 43688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner class JITMemoryManager { 44688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner unsigned char *MemBase; // Base of block of memory, start of stub mem 45688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner unsigned char *FunctionBase; // Start of the function body area 46688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner unsigned char *CurStubPtr, *CurFunctionPtr; 47688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner public: 48688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner JITMemoryManager(); 49688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 50688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner inline unsigned char *allocateStub(unsigned StubSize); 51688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner inline unsigned char *startFunctionBody(); 52688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner inline void endFunctionBody(unsigned char *FunctionEnd); 53688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner }; 54688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner} 55688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 56688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner// getMemory - Return a pointer to the specified number of bytes, which is 57688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner// mapped as executable readable and writable. 58688506de24f04682f9d8563a7d20ab15ab85340bChris Lattnerstatic void *getMemory(unsigned NumBytes) { 59688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner if (NumBytes == 0) return 0; 60688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner static const long pageSize = sysconf(_SC_PAGESIZE); 61688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner unsigned NumPages = (NumBytes+pageSize-1)/pageSize; 62688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 63688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner#if defined(i386) || defined(__i386__) || defined(__x86__) 64688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /* Linux and *BSD tend to have these flags named differently. */ 65688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner#if defined(MAP_ANON) && !defined(MAP_ANONYMOUS) 66688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner# define MAP_ANONYMOUS MAP_ANON 67688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner#endif /* defined(MAP_ANON) && !defined(MAP_ANONYMOUS) */ 68688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner#elif defined(sparc) || defined(__sparc__) || defined(__sparcv9) 69364f86d4dff7ec203afcef6ae09f64c468e57804Brian Gaeke/* nothing */ 70688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner#else 71688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner std::cerr << "This architecture is not supported by the JIT!\n"; 72688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner abort(); 73688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner#endif 74364f86d4dff7ec203afcef6ae09f64c468e57804Brian Gaeke 75364f86d4dff7ec203afcef6ae09f64c468e57804Brian Gaeke#if defined(__linux__) 76364f86d4dff7ec203afcef6ae09f64c468e57804Brian Gaeke#define fd 0 77364f86d4dff7ec203afcef6ae09f64c468e57804Brian Gaeke#else 78364f86d4dff7ec203afcef6ae09f64c468e57804Brian Gaeke#define fd -1 79364f86d4dff7ec203afcef6ae09f64c468e57804Brian Gaeke#endif 80688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 81688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner unsigned mmapFlags = MAP_PRIVATE|MAP_ANONYMOUS; 82688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner#ifdef MAP_NORESERVE 83688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner mmapFlags |= MAP_NORESERVE; 84688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner#endif 85688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 86688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner void *pa = mmap(0, pageSize*NumPages, PROT_READ|PROT_WRITE|PROT_EXEC, 87011efae2f0ff141064e305c55940c9cbec5396c7Chris Lattner mmapFlags, fd, 0); 88688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner if (pa == MAP_FAILED) { 89688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner perror("mmap"); 90688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner abort(); 91688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner } 92688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner return pa; 93688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner} 94688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 95688506de24f04682f9d8563a7d20ab15ab85340bChris LattnerJITMemoryManager::JITMemoryManager() { 96688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner // Allocate a 16M block of memory... 97688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner MemBase = (unsigned char*)getMemory(16 << 20); 98688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner FunctionBase = MemBase + 512*1024; // Use 512k for stubs 99688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 100688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner // Allocate stubs backwards from the function base, allocate functions forward 101688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner // from the function base. 102688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner CurStubPtr = CurFunctionPtr = FunctionBase; 103688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner} 104688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 105688506de24f04682f9d8563a7d20ab15ab85340bChris Lattnerunsigned char *JITMemoryManager::allocateStub(unsigned StubSize) { 106688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner CurStubPtr -= StubSize; 107688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner if (CurStubPtr < MemBase) { 108688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner std::cerr << "JIT ran out of memory for function stubs!\n"; 109688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner abort(); 110688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner } 111688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner return CurStubPtr; 112688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner} 113688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 114688506de24f04682f9d8563a7d20ab15ab85340bChris Lattnerunsigned char *JITMemoryManager::startFunctionBody() { 115688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner // Round up to an even multiple of 4 bytes, this should eventually be target 116688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner // specific. 117688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner return (unsigned char*)(((intptr_t)CurFunctionPtr + 3) & ~3); 118688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner} 119688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 120688506de24f04682f9d8563a7d20ab15ab85340bChris Lattnervoid JITMemoryManager::endFunctionBody(unsigned char *FunctionEnd) { 121688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner assert(FunctionEnd > CurFunctionPtr); 122688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner CurFunctionPtr = FunctionEnd; 123688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner} 124688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 125688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 126688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 127688506de24f04682f9d8563a7d20ab15ab85340bChris Lattnernamespace { 1286020ddd57e62a8da3eee1210040a3611d52d2889Brian Gaeke /// Emitter - The JIT implementation of the MachineCodeEmitter, which is used 129688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner /// to output functions to memory for execution. 130bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner class Emitter : public MachineCodeEmitter { 131688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner JITMemoryManager MemMgr; 132688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner 133bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // CurBlock - The start of the current block of memory. CurByte - The 134bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // current byte being emitted to. 1356125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner unsigned char *CurBlock, *CurByte; 1366125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner 1376125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner // When outputting a function stub in the context of some other function, we 1386125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner // save CurBlock and CurByte here. 1396125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner unsigned char *SavedCurBlock, *SavedCurByte; 140bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner 141bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // ConstantPoolAddresses - Contains the location for each entry in the 142bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // constant pool. 1431cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner std::vector<void*> ConstantPoolAddresses; 144bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner public: 145bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner Emitter(VM &vm) { TheVM = &vm; } 146bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 147bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner virtual void startFunction(MachineFunction &F); 148bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner virtual void finishFunction(MachineFunction &F); 1491cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner virtual void emitConstantPool(MachineConstantPool *MCP); 1506125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner virtual void startFunctionStub(const Function &F, unsigned StubSize); 1516125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner virtual void* finishFunctionStub(const Function &F); 152bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner virtual void emitByte(unsigned char B); 153bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner virtual void emitWord(unsigned W); 154bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner 155bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner virtual uint64_t getGlobalValueAddress(GlobalValue *V); 156bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner virtual uint64_t getGlobalValueAddress(const std::string &Name); 157bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner virtual uint64_t getConstantPoolEntryAddress(unsigned Entry); 158bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner virtual uint64_t getCurrentPCValue(); 159bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner 160bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // forceCompilationOf - Force the compilation of the specified function, and 161bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // return its address, because we REALLY need the address now. 162bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // 163bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // FIXME: This is JIT specific! 164bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // 165bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner virtual uint64_t forceCompilationOf(Function *F); 166bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner }; 167bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 168bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 169906f5fa5c8bb790201c79a33ea6d906f9f57f827Misha BrukmanMachineCodeEmitter *VM::createEmitter(VM &V) { 170bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner return new Emitter(V); 171bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 172bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 173bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattnervoid Emitter::startFunction(MachineFunction &F) { 174688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner CurByte = CurBlock = MemMgr.startFunctionBody(); 175bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner TheVM->addGlobalMapping(F.getFunction(), CurBlock); 176bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 177bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 178bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattnervoid Emitter::finishFunction(MachineFunction &F) { 179688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner MemMgr.endFunctionBody(CurByte); 1801cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner ConstantPoolAddresses.clear(); 181bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner NumBytes += CurByte-CurBlock; 182bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 18302c26b681ec70538fba8b273326e696e6a3dc4d2Brian Gaeke DEBUG(std::cerr << "Finished CodeGen of [" << (void*)CurBlock 1841d4408506b5704a64ad76a295ee8f7b94b79ffd0Misha Brukman << "] Function: " << F.getFunction()->getName() 185bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner << ": " << CurByte-CurBlock << " bytes of text\n"); 186bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 187bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 1881cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattnervoid Emitter::emitConstantPool(MachineConstantPool *MCP) { 1891cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner const std::vector<Constant*> &Constants = MCP->getConstants(); 1901cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner for (unsigned i = 0, e = Constants.size(); i != e; ++i) { 1911cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner // For now we just allocate some memory on the heap, this can be 1921cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner // dramatically improved. 1931cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner const Type *Ty = ((Value*)Constants[i])->getType(); 194bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner void *Addr = malloc(TheVM->getTargetData().getTypeSize(Ty)); 195bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner TheVM->InitializeMemory(Constants[i], Addr); 1961cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner ConstantPoolAddresses.push_back(Addr); 1971cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner } 1981cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner} 1991cc08381f1ab57efdf07248fd5e9fd75ef6f0f99Chris Lattner 2006125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattnervoid Emitter::startFunctionStub(const Function &F, unsigned StubSize) { 2016125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner SavedCurBlock = CurBlock; SavedCurByte = CurByte; 202688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner CurByte = CurBlock = MemMgr.allocateStub(StubSize); 2036125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner} 2046125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner 2056125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattnervoid *Emitter::finishFunctionStub(const Function &F) { 2066125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner NumBytes += CurByte-CurBlock; 2076125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner DEBUG(std::cerr << "Finished CodeGen of [0x" << std::hex 2086125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner << (unsigned)(intptr_t)CurBlock 2096125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner << std::dec << "] Function stub for: " << F.getName() 2106125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner << ": " << CurByte-CurBlock << " bytes of text\n"); 2116125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner std::swap(CurBlock, SavedCurBlock); 2126125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner CurByte = SavedCurByte; 2136125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner return SavedCurBlock; 2146125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner} 2156125fddb52c3d821a4e4c000cbd210428b0009f6Chris Lattner 216bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattnervoid Emitter::emitByte(unsigned char B) { 217bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner *CurByte++ = B; // Write the byte to memory 218bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 219bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 220bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattnervoid Emitter::emitWord(unsigned W) { 221688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner // This won't work if the endianness of the host and target don't agree! (For 222688506de24f04682f9d8563a7d20ab15ab85340bChris Lattner // a JIT this can't happen though. :) 223bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner *(unsigned*)CurByte = W; 224bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner CurByte += sizeof(unsigned); 225bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner} 226bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner 227bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattneruint64_t Emitter::getGlobalValueAddress(GlobalValue *V) { 228bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // Try looking up the function to see if it is already compiled, if not return 229bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner // 0. 230bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner return (intptr_t)TheVM->getPointerToGlobalIfAvailable(V); 231bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner} 232bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattneruint64_t Emitter::getGlobalValueAddress(const std::string &Name) { 233bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner return (intptr_t)TheVM->getPointerToNamedFunction(Name); 234bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner} 235bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner 236bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner// getConstantPoolEntryAddress - Return the address of the 'ConstantNum' entry 237bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner// in the constant pool that was last emitted with the 'emitConstantPool' 238bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner// method. 239bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner// 240bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattneruint64_t Emitter::getConstantPoolEntryAddress(unsigned ConstantNum) { 241bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner assert(ConstantNum < ConstantPoolAddresses.size() && 242bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner "Invalid ConstantPoolIndex!"); 243bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner return (intptr_t)ConstantPoolAddresses[ConstantNum]; 244bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner} 245bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner 246bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner// getCurrentPCValue - This returns the address that the next emitted byte 247bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner// will be output to. 248bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner// 249bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattneruint64_t Emitter::getCurrentPCValue() { 250bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner return (intptr_t)CurByte; 251bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner} 252bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner 253bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattneruint64_t Emitter::forceCompilationOf(Function *F) { 254bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner return (intptr_t)TheVM->getPointerToFunction(F); 255bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner} 256bba1b6df9a7ac36e3a479dfe953a9618c87db7bbChris Lattner 257d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman// getPointerToNamedFunction - This function is used as a global wrapper to 258d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman// VM::getPointerToNamedFunction for the purpose of resolving symbols when 259d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman// bugpoint is debugging the JIT. In that scenario, we are loading an .so and 260d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman// need to resolve function(s) that are being mis-codegenerated, so we need to 261d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman// resolve their addresses at runtime, and this is the way to do it. 262d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukmanextern "C" { 263d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman void *getPointerToNamedFunction(const char *Name) { 264d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman Module &M = TheVM->getModule(); 265d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman if (Function *F = M.getNamedFunction(Name)) 266d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman return TheVM->getPointerToFunction(F); 267d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman return TheVM->getPointerToNamedFunction(Name); 268d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman } 269d69c1e6dc28bed3c156f78fee5253748e3d509e2Misha Brukman} 270d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 271d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke} // End llvm namespace 272