X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FExecutionEngine%2FInterpreter%2FExternalFunctions.cpp;h=b1c2ee4b6a84f5e0205a44e33ab7655402bcf131;hb=23e28836edaa6750a48dc318c8e2bbe6dc1529c8;hp=d24557abe05ccabe73cbaf77e354415fcb6abde9;hpb=1543e40cea50d244979f0667f453cf3466a6106c;p=oota-llvm.git diff --git a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp index d24557abe05..b1c2ee4b6a8 100644 --- a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp +++ b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp @@ -1,66 +1,59 @@ //===-- ExternalFunctions.cpp - Implement External Functions --------------===// -// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // This file contains both code to deal with invoking "external" functions, but // also contains code that implements "exported" external functions. // -// External functions in LLI are implemented by dlopen'ing the lli executable -// and using dlsym to look op the functions that we want to invoke. If a -// function is found, then the arguments are mangled and passed in to the -// function call. +// External functions in the interpreter are implemented by +// using the system's dynamic loader to look up the address of the function +// we want to invoke. If a function is found, then one of the +// many lle_* wrapper functions in this file will translate its arguments from +// GenericValues to the types the function is actually expecting, before the +// function is called. // //===----------------------------------------------------------------------===// #include "Interpreter.h" -#include "ExecutionAnnotations.h" -#include "llvm/Module.h" #include "llvm/DerivedTypes.h" -#include "llvm/SymbolTable.h" +#include "llvm/Module.h" +#include "llvm/Support/Streams.h" +#include "llvm/System/DynamicLibrary.h" #include "llvm/Target/TargetData.h" +#include #include -#include "Config/dlfcn.h" -#include "Config/link.h" #include -#include "Config/stdio.h" using std::vector; +using namespace llvm; + typedef GenericValue (*ExFunc)(FunctionType *, const vector &); static std::map Functions; static std::map FuncNames; static Interpreter *TheInterpreter; -// getCurrentExecutablePath() - Return the directory that the lli executable -// lives in. -// -std::string Interpreter::getCurrentExecutablePath() const { - Dl_info Info; - if (dladdr(&TheInterpreter, &Info) == 0) return ""; - - std::string LinkAddr(Info.dli_fname); - unsigned SlashPos = LinkAddr.rfind('/'); - if (SlashPos != std::string::npos) - LinkAddr.resize(SlashPos); // Trim the executable name off... - - return LinkAddr; -} - - static char getTypeID(const Type *Ty) { - switch (Ty->getPrimitiveID()) { + switch (Ty->getTypeID()) { case Type::VoidTyID: return 'V'; - case Type::BoolTyID: return 'o'; - case Type::UByteTyID: return 'B'; - case Type::SByteTyID: return 'b'; - case Type::UShortTyID: return 'S'; - case Type::ShortTyID: return 's'; - case Type::UIntTyID: return 'I'; - case Type::IntTyID: return 'i'; - case Type::ULongTyID: return 'L'; - case Type::LongTyID: return 'l'; + case Type::IntegerTyID: + switch (cast(Ty)->getBitWidth()) { + case 1: return 'o'; + case 8: return 'B'; + case 16: return 'S'; + case 32: return 'I'; + case 64: return 'L'; + default: return 'N'; + } case Type::FloatTyID: return 'F'; case Type::DoubleTyID: return 'D'; case Type::PointerTyID: return 'P'; - case Type::FunctionTyID: return 'M'; + case Type::FunctionTyID:return 'M'; case Type::StructTyID: return 'T'; case Type::ArrayTyID: return 'A'; case Type::OpaqueTyID: return 'O'; @@ -68,44 +61,47 @@ static char getTypeID(const Type *Ty) { } } -static ExFunc lookupFunction(const Function *M) { +static ExFunc lookupFunction(const Function *F) { // Function not found, look it up... start by figuring out what the // composite function name should be. std::string ExtName = "lle_"; - const FunctionType *MT = M->getFunctionType(); - for (unsigned i = 0; const Type *Ty = MT->getContainedType(i); ++i) - ExtName += getTypeID(Ty); - ExtName += "_" + M->getName(); + const FunctionType *FT = F->getFunctionType(); + for (unsigned i = 0, e = FT->getNumContainedTypes(); i != e; ++i) + ExtName += getTypeID(FT->getContainedType(i)); + ExtName += "_" + F->getName(); - //std::cout << "Tried: '" << ExtName << "'\n"; ExFunc FnPtr = FuncNames[ExtName]; if (FnPtr == 0) - FnPtr = (ExFunc)dlsym(RTLD_DEFAULT, ExtName.c_str()); + FnPtr = + (ExFunc)(intptr_t)sys::DynamicLibrary::SearchForAddressOfSymbol(ExtName); if (FnPtr == 0) - FnPtr = FuncNames["lle_X_"+M->getName()]; + FnPtr = FuncNames["lle_X_"+F->getName()]; if (FnPtr == 0) // Try calling a generic function... if it exists... - FnPtr = (ExFunc)dlsym(RTLD_DEFAULT, ("lle_X_"+M->getName()).c_str()); + FnPtr = (ExFunc)(intptr_t)sys::DynamicLibrary::SearchForAddressOfSymbol( + ("lle_X_"+F->getName()).c_str()); if (FnPtr != 0) - Functions.insert(std::make_pair(M, FnPtr)); // Cache for later + Functions.insert(std::make_pair(F, FnPtr)); // Cache for later return FnPtr; } -GenericValue Interpreter::callExternalFunction(Function *M, +GenericValue Interpreter::callExternalFunction(Function *F, const std::vector &ArgVals) { TheInterpreter = this; // Do a lookup to see if the function is in our cache... this should just be a - // defered annotation! - std::map::iterator FI = Functions.find(M); - ExFunc Fn = (FI == Functions.end()) ? lookupFunction(M) : FI->second; + // deferred annotation! + std::map::iterator FI = Functions.find(F); + ExFunc Fn = (FI == Functions.end()) ? lookupFunction(F) : FI->second; if (Fn == 0) { - std::cout << "Tried to execute an unknown external function: " - << M->getType()->getDescription() << " " << M->getName() << "\n"; - return GenericValue(); + cerr << "Tried to execute an unknown external function: " + << F->getType()->getDescription() << " " << F->getName() << "\n"; + if (F->getName() == "__main") + return GenericValue(); + abort(); } // TODO: FIXME when types are not const! - GenericValue Result = Fn(const_cast(M->getFunctionType()), + GenericValue Result = Fn(const_cast(F->getFunctionType()), ArgVals); return Result; } @@ -117,20 +113,20 @@ GenericValue Interpreter::callExternalFunction(Function *M, extern "C" { // Don't add C++ manglings to llvm mangling :) // void putchar(sbyte) -GenericValue lle_Vb_putchar(FunctionType *M, const vector &Args) { - std::cout << Args[0].SByteVal; +GenericValue lle_VB_putchar(FunctionType *M, const vector &Args) { + cout << Args[0].Int8Val; return GenericValue(); } // int putchar(int) GenericValue lle_ii_putchar(FunctionType *M, const vector &Args) { - std::cout << ((char)Args[0].IntVal) << std::flush; + cout << ((char)Args[0].Int32Val) << std::flush; return Args[0]; } // void putchar(ubyte) -GenericValue lle_VB_putchar(FunctionType *M, const vector &Args) { - std::cout << Args[0].SByteVal << std::flush; +GenericValue lle_Vb_putchar(FunctionType *M, const vector &Args) { + cout << Args[0].Int8Val << std::flush; return Args[0]; } @@ -139,7 +135,7 @@ GenericValue lle_X_atexit(FunctionType *M, const vector &Args) { assert(Args.size() == 1); TheInterpreter->addAtExitHandler((Function*)GVTOP(Args[0])); GenericValue GV; - GV.IntVal = 0; + GV.Int32Val = 0; return GV; } @@ -151,23 +147,20 @@ GenericValue lle_X_exit(FunctionType *M, const vector &Args) { // void abort(void) GenericValue lle_X_abort(FunctionType *M, const vector &Args) { - std::cerr << "***PROGRAM ABORTED***!\n"; - GenericValue GV; - GV.IntVal = 1; - TheInterpreter->exitCalled(GV); + raise (SIGABRT); return GenericValue(); } // void *malloc(uint) GenericValue lle_X_malloc(FunctionType *M, const vector &Args) { assert(Args.size() == 1 && "Malloc expects one argument!"); - return PTOGV(malloc(Args[0].UIntVal)); + return PTOGV(malloc(Args[0].Int32Val)); } // void *calloc(uint, uint) GenericValue lle_X_calloc(FunctionType *M, const vector &Args) { assert(Args.size() == 2 && "calloc expects two arguments!"); - return PTOGV(calloc(Args[0].UIntVal, Args[1].UIntVal)); + return PTOGV(calloc(Args[0].Int32Val, Args[1].Int32Val)); } // void free(void *) @@ -181,7 +174,7 @@ GenericValue lle_X_free(FunctionType *M, const vector &Args) { GenericValue lle_X_atoi(FunctionType *M, const vector &Args) { assert(Args.size() == 1); GenericValue GV; - GV.IntVal = atoi((char*)GVTOP(Args[0])); + GV.Int32Val = atoi((char*)GVTOP(Args[0])); return GV; } @@ -225,6 +218,8 @@ GenericValue lle_X_floor(FunctionType *M, const vector &Args) { return GV; } +#ifdef HAVE_RAND48 + // double drand48() GenericValue lle_X_drand48(FunctionType *M, const vector &Args) { assert(Args.size() == 0); @@ -237,21 +232,31 @@ GenericValue lle_X_drand48(FunctionType *M, const vector &Args) { GenericValue lle_X_lrand48(FunctionType *M, const vector &Args) { assert(Args.size() == 0); GenericValue GV; - GV.IntVal = lrand48(); + GV.Int32Val = lrand48(); return GV; } // void srand48(long) GenericValue lle_X_srand48(FunctionType *M, const vector &Args) { assert(Args.size() == 1); - srand48(Args[0].IntVal); + srand48(Args[0].Int32Val); return GenericValue(); } +#endif + +// int rand() +GenericValue lle_X_rand(FunctionType *M, const vector &Args) { + assert(Args.size() == 0); + GenericValue GV; + GV.Int32Val = rand(); + return GV; +} + // void srand(uint) GenericValue lle_X_srand(FunctionType *M, const vector &Args) { assert(Args.size() == 1); - srand(Args[0].UIntVal); + srand(Args[0].Int32Val); return GenericValue(); } @@ -259,7 +264,7 @@ GenericValue lle_X_srand(FunctionType *M, const vector &Args) { GenericValue lle_X_puts(FunctionType *M, const vector &Args) { assert(Args.size() == 1); GenericValue GV; - GV.IntVal = puts((char*)GVTOP(Args[0])); + GV.Int32Val = puts((char*)GVTOP(Args[0])); return GV; } @@ -272,7 +277,7 @@ GenericValue lle_X_sprintf(FunctionType *M, const vector &Args) { // printf should return # chars printed. This is completely incorrect, but // close enough for now. - GenericValue GV; GV.IntVal = strlen(FmtStr); + GenericValue GV; GV.Int32Val = strlen(FmtStr); while (1) { switch (*FmtStr) { case 0: return GV; // Null terminator... @@ -298,19 +303,19 @@ GenericValue lle_X_sprintf(FunctionType *M, const vector &Args) { Last = *FB++ = *FmtStr++; } *FB = 0; - + switch (Last) { case '%': sprintf(Buffer, FmtBuf); break; case 'c': - sprintf(Buffer, FmtBuf, Args[ArgNo++].IntVal); break; + sprintf(Buffer, FmtBuf, Args[ArgNo++].Int32Val); break; case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': if (HowLong >= 1) { if (HowLong == 1 && - TheInterpreter->getModule().getPointerSize()==Module::Pointer64 && - sizeof(long) < sizeof(long long)) { + TheInterpreter->getTargetData()->getPointerSizeInBits() == 64 && + sizeof(long) < sizeof(int64_t)) { // Make sure we use %lld with a 64 bit argument because we might be // compiling LLI on a 32 bit compiler. unsigned Size = strlen(FmtBuf); @@ -318,16 +323,16 @@ GenericValue lle_X_sprintf(FunctionType *M, const vector &Args) { FmtBuf[Size+1] = 0; FmtBuf[Size-1] = 'l'; } - sprintf(Buffer, FmtBuf, Args[ArgNo++].ULongVal); + sprintf(Buffer, FmtBuf, Args[ArgNo++].Int64Val); } else - sprintf(Buffer, FmtBuf, Args[ArgNo++].IntVal); break; + sprintf(Buffer, FmtBuf, Args[ArgNo++].Int32Val); break; case 'e': case 'E': case 'g': case 'G': case 'f': sprintf(Buffer, FmtBuf, Args[ArgNo++].DoubleVal); break; case 'p': sprintf(Buffer, FmtBuf, (void*)GVTOP(Args[ArgNo++])); break; - case 's': + case 's': sprintf(Buffer, FmtBuf, (char*)GVTOP(Args[ArgNo++])); break; - default: std::cout << ""; + default: cerr << ""; ArgNo++; break; } strcpy(OutputBuffer, Buffer); @@ -345,7 +350,7 @@ GenericValue lle_X_printf(FunctionType *M, const vector &Args) { NewArgs.push_back(PTOGV(Buffer)); NewArgs.insert(NewArgs.end(), Args.begin(), Args.end()); GenericValue GV = lle_X_sprintf(M, NewArgs); - std::cout << Buffer; + cout << Buffer; return GV; } @@ -389,11 +394,11 @@ static void ByteswapSCANFResults(const char *Fmt, void *Arg0, void *Arg1, case 'i': case 'o': case 'u': case 'x': case 'X': case 'n': case 'p': case 'd': if (Long || LongLong) { - Size = 8; Ty = Type::ULongTy; + Size = 8; Ty = Type::Int64Ty; } else if (Half) { - Size = 4; Ty = Type::UShortTy; + Size = 4; Ty = Type::Int16Ty; } else { - Size = 4; Ty = Type::UIntTy; + Size = 4; Ty = Type::Int32Ty; } break; @@ -408,7 +413,7 @@ static void ByteswapSCANFResults(const char *Fmt, void *Arg0, void *Arg1, case 's': case 'c': case '[': // No byteswap needed Size = 1; - Ty = Type::SByteTy; + Ty = Type::Int8Ty; break; default: break; @@ -434,8 +439,8 @@ GenericValue lle_X_sscanf(FunctionType *M, const vector &args) { Args[i] = (char*)GVTOP(args[i]); GenericValue GV; - GV.IntVal = sscanf(Args[0], Args[1], Args[2], Args[3], Args[4], - Args[5], Args[6], Args[7], Args[8], Args[9]); + GV.Int32Val = sscanf(Args[0], Args[1], Args[2], Args[3], Args[4], + Args[5], Args[6], Args[7], Args[8], Args[9]); ByteswapSCANFResults(Args[1], Args[2], Args[3], Args[4], Args[5], Args[6], Args[7], Args[8], Args[9], 0); return GV; @@ -450,8 +455,8 @@ GenericValue lle_X_scanf(FunctionType *M, const vector &args) { Args[i] = (char*)GVTOP(args[i]); GenericValue GV; - GV.IntVal = scanf(Args[0], Args[1], Args[2], Args[3], Args[4], - Args[5], Args[6], Args[7], Args[8], Args[9]); + GV.Int32Val = scanf( Args[0], Args[1], Args[2], Args[3], Args[4], + Args[5], Args[6], Args[7], Args[8], Args[9]); ByteswapSCANFResults(Args[0], Args[1], Args[2], Args[3], Args[4], Args[5], Args[6], Args[7], Args[8], Args[9]); return GV; @@ -460,8 +465,8 @@ GenericValue lle_X_scanf(FunctionType *M, const vector &args) { // int clock(void) - Profiling implementation GenericValue lle_i_clock(FunctionType *M, const vector &Args) { - extern int clock(void); - GenericValue GV; GV.IntVal = clock(); + extern unsigned int clock(void); + GenericValue GV; GV.Int32Val = clock(); return GV; } @@ -474,7 +479,7 @@ GenericValue lle_i_clock(FunctionType *M, const vector &Args) { GenericValue lle_X_strcmp(FunctionType *M, const vector &Args) { assert(Args.size() == 2); GenericValue Ret; - Ret.IntVal = strcmp((char*)GVTOP(Args[0]), (char*)GVTOP(Args[1])); + Ret.Int32Val = strcmp((char*)GVTOP(Args[0]), (char*)GVTOP(Args[1])); return Ret; } @@ -490,14 +495,41 @@ GenericValue lle_X_strcpy(FunctionType *M, const vector &Args) { return PTOGV(strcpy((char*)GVTOP(Args[0]), (char*)GVTOP(Args[1]))); } -// long strlen(const char *src); -GenericValue lle_X_strlen(FunctionType *M, const vector &Args) { - assert(Args.size() == 1); +static GenericValue size_t_to_GV (size_t n) { GenericValue Ret; - Ret.LongVal = strlen((char*)GVTOP(Args[0])); + if (sizeof (size_t) == sizeof (uint64_t)) { + Ret.Int64Val = n; + } else { + assert (sizeof (size_t) == sizeof (unsigned int)); + Ret.Int32Val = n; + } return Ret; } +static size_t GV_to_size_t (GenericValue GV) { + size_t count; + if (sizeof (size_t) == sizeof (uint64_t)) { + count = (size_t)GV.Int64Val; + } else { + assert (sizeof (size_t) == sizeof (unsigned int)); + count = (size_t)GV.Int32Val; + } + return count; +} + +// size_t strlen(const char *src); +GenericValue lle_X_strlen(FunctionType *M, const vector &Args) { + assert(Args.size() == 1); + size_t strlenResult = strlen ((char *) GVTOP (Args[0])); + return size_t_to_GV (strlenResult); +} + +// char *strdup(const char *src); +GenericValue lle_X_strdup(FunctionType *M, const vector &Args) { + assert(Args.size() == 1); + return PTOGV(strdup((char*)GVTOP(Args[0]))); +} + // char *__strdup(const char *src); GenericValue lle_X___strdup(FunctionType *M, const vector &Args) { assert(Args.size() == 1); @@ -507,14 +539,15 @@ GenericValue lle_X___strdup(FunctionType *M, const vector &Args) { // void *memset(void *S, int C, size_t N) GenericValue lle_X_memset(FunctionType *M, const vector &Args) { assert(Args.size() == 3); - return PTOGV(memset(GVTOP(Args[0]), Args[1].IntVal, Args[2].UIntVal)); + size_t count = GV_to_size_t (Args[2]); + return PTOGV(memset(GVTOP(Args[0]), Args[1].Int32Val, count)); } // void *memcpy(void *Dest, void *src, size_t Size); GenericValue lle_X_memcpy(FunctionType *M, const vector &Args) { assert(Args.size() == 3); - return PTOGV(memcpy((char*)GVTOP(Args[0]), (char*)GVTOP(Args[1]), - Args[2].UIntVal)); + size_t count = GV_to_size_t (Args[2]); + return PTOGV(memcpy((char*)GVTOP(Args[0]), (char*)GVTOP(Args[1]), count)); } //===----------------------------------------------------------------------===// @@ -522,79 +555,21 @@ GenericValue lle_X_memcpy(FunctionType *M, const vector &Args) { //===----------------------------------------------------------------------===// // getFILE - Turn a pointer in the host address space into a legit pointer in -// the interpreter address space. For the most part, this is an identity -// transformation, but if the program refers to stdio, stderr, stdin then they -// have pointers that are relative to the __iob array. If this is the case, -// change the FILE into the REAL stdio stream. -// -static FILE *getFILE(void *Ptr) { - static Module *LastMod = 0; - static PointerTy IOBBase = 0; - static unsigned FILESize; - - if (LastMod != &TheInterpreter->getModule()) { // Module change or initialize? - Module *M = LastMod = &TheInterpreter->getModule(); - - // Check to see if the currently loaded module contains an __iob symbol... - GlobalVariable *IOB = 0; - SymbolTable &ST = M->getSymbolTable(); - for (SymbolTable::iterator I = ST.begin(), E = ST.end(); I != E; ++I) { - SymbolTable::VarMap &M = I->second; - for (SymbolTable::VarMap::iterator J = M.begin(), E = M.end(); - J != E; ++J) - if (J->first == "__iob") - if ((IOB = dyn_cast(J->second))) - break; - if (IOB) break; - } - -#if 0 /// FIXME! __iob support for LLI - // If we found an __iob symbol now, find out what the actual address it's - // held in is... - if (IOB) { - // Get the address the array lives in... - GlobalAddress *Address = - (GlobalAddress*)IOB->getOrCreateAnnotation(GlobalAddressAID); - IOBBase = (PointerTy)(GenericValue*)Address->Ptr; - - // Figure out how big each element of the array is... - const ArrayType *AT = - dyn_cast(IOB->getType()->getElementType()); - if (AT) - FILESize = TD.getTypeSize(AT->getElementType()); - else - FILESize = 16*8; // Default size - } -#endif - } - - // Check to see if this is a reference to __iob... - if (IOBBase) { - unsigned FDNum = ((unsigned long)Ptr-IOBBase)/FILESize; - if (FDNum == 0) - return stdin; - else if (FDNum == 1) - return stdout; - else if (FDNum == 2) - return stderr; - } - - return (FILE*)Ptr; -} - +// the interpreter address space. This is an identity transformation. +#define getFILE(ptr) ((FILE*)ptr) // FILE *fopen(const char *filename, const char *mode); GenericValue lle_X_fopen(FunctionType *M, const vector &Args) { assert(Args.size() == 2); return PTOGV(fopen((const char *)GVTOP(Args[0]), - (const char *)GVTOP(Args[1]))); + (const char *)GVTOP(Args[1]))); } // int fclose(FILE *F); GenericValue lle_X_fclose(FunctionType *M, const vector &Args) { assert(Args.size() == 1); GenericValue GV; - GV.IntVal = fclose(getFILE(GVTOP(Args[0]))); + GV.Int32Val = fclose(getFILE(GVTOP(Args[0]))); return GV; } @@ -603,49 +578,49 @@ GenericValue lle_X_feof(FunctionType *M, const vector &Args) { assert(Args.size() == 1); GenericValue GV; - GV.IntVal = feof(getFILE(GVTOP(Args[0]))); + GV.Int32Val = feof(getFILE(GVTOP(Args[0]))); return GV; } // size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream); GenericValue lle_X_fread(FunctionType *M, const vector &Args) { assert(Args.size() == 4); - GenericValue GV; + size_t result; - GV.UIntVal = fread((void*)GVTOP(Args[0]), Args[1].UIntVal, - Args[2].UIntVal, getFILE(GVTOP(Args[3]))); - return GV; + result = fread((void*)GVTOP(Args[0]), GV_to_size_t (Args[1]), + GV_to_size_t (Args[2]), getFILE(GVTOP(Args[3]))); + return size_t_to_GV (result); } // size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream); GenericValue lle_X_fwrite(FunctionType *M, const vector &Args) { assert(Args.size() == 4); - GenericValue GV; + size_t result; - GV.UIntVal = fwrite((void*)GVTOP(Args[0]), Args[1].UIntVal, - Args[2].UIntVal, getFILE(GVTOP(Args[3]))); - return GV; + result = fwrite((void*)GVTOP(Args[0]), GV_to_size_t (Args[1]), + GV_to_size_t (Args[2]), getFILE(GVTOP(Args[3]))); + return size_t_to_GV (result); } // char *fgets(char *s, int n, FILE *stream); GenericValue lle_X_fgets(FunctionType *M, const vector &Args) { assert(Args.size() == 3); - return GVTOP(fgets((char*)GVTOP(Args[0]), Args[1].IntVal, - getFILE(GVTOP(Args[2])))); + return GVTOP(fgets((char*)GVTOP(Args[0]), Args[1].Int32Val, + getFILE(GVTOP(Args[2])))); } // FILE *freopen(const char *path, const char *mode, FILE *stream); GenericValue lle_X_freopen(FunctionType *M, const vector &Args) { assert(Args.size() == 3); return PTOGV(freopen((char*)GVTOP(Args[0]), (char*)GVTOP(Args[1]), - getFILE(GVTOP(Args[2])))); + getFILE(GVTOP(Args[2])))); } // int fflush(FILE *stream); GenericValue lle_X_fflush(FunctionType *M, const vector &Args) { assert(Args.size() == 1); GenericValue GV; - GV.IntVal = fflush(getFILE(GVTOP(Args[0]))); + GV.Int32Val = fflush(getFILE(GVTOP(Args[0]))); return GV; } @@ -653,7 +628,7 @@ GenericValue lle_X_fflush(FunctionType *M, const vector &Args) { GenericValue lle_X_getc(FunctionType *M, const vector &Args) { assert(Args.size() == 1); GenericValue GV; - GV.IntVal = getc(getFILE(GVTOP(Args[0]))); + GV.Int32Val = getc(getFILE(GVTOP(Args[0]))); return GV; } @@ -666,7 +641,7 @@ GenericValue lle_X__IO_getc(FunctionType *F, const vector &Args) { GenericValue lle_X_fputc(FunctionType *M, const vector &Args) { assert(Args.size() == 2); GenericValue GV; - GV.IntVal = fputc(Args[0].IntVal, getFILE(GVTOP(Args[1]))); + GV.Int32Val = fputc(Args[0].Int32Val, getFILE(GVTOP(Args[1]))); return GV; } @@ -674,7 +649,15 @@ GenericValue lle_X_fputc(FunctionType *M, const vector &Args) { GenericValue lle_X_ungetc(FunctionType *M, const vector &Args) { assert(Args.size() == 2); GenericValue GV; - GV.IntVal = ungetc(Args[0].IntVal, getFILE(GVTOP(Args[1]))); + GV.Int32Val = ungetc(Args[0].Int32Val, getFILE(GVTOP(Args[1]))); + return GV; +} + +// int ferror (FILE *stream); +GenericValue lle_X_ferror(FunctionType *M, const vector &Args) { + assert(Args.size() == 1); + GenericValue GV; + GV.Int32Val = ferror (getFILE(GVTOP(Args[0]))); return GV; } @@ -692,35 +675,6 @@ GenericValue lle_X_fprintf(FunctionType *M, const vector &Args) { return GV; } -//===----------------------------------------------------------------------===// -// LLVM Intrinsic Functions... -//===----------------------------------------------------------------------===// - -// void llvm.va_start( *) - Implement the va_start operation... -GenericValue llvm_va_start(FunctionType *F, const vector &Args) { - assert(Args.size() == 1); - GenericValue *VAListP = (GenericValue *)GVTOP(Args[0]); - GenericValue Val; - Val.UIntVal = 0; // Start at the first '...' argument... - TheInterpreter->StoreValueToMemory(Val, VAListP, Type::UIntTy); - return GenericValue(); -} - -// void llvm.va_end( *) - Implement the va_end operation... -GenericValue llvm_va_end(FunctionType *F, const vector &Args) { - assert(Args.size() == 1); - return GenericValue(); // Noop! -} - -// void llvm.va_copy( *, ) - Implement the va_copy -// operation... -GenericValue llvm_va_copy(FunctionType *F, const vector &Args) { - assert(Args.size() == 2); - GenericValue *DestVAList = (GenericValue*)GVTOP(Args[0]); - TheInterpreter->StoreValueToMemory(Args[1], DestVAList, Type::UIntTy); - return GenericValue(); -} - } // End extern "C" @@ -739,9 +693,12 @@ void Interpreter::initializeExternalFunctions() { FuncNames["lle_X_log"] = lle_X_log; FuncNames["lle_X_floor"] = lle_X_floor; FuncNames["lle_X_srand"] = lle_X_srand; + FuncNames["lle_X_rand"] = lle_X_rand; +#ifdef HAVE_RAND48 FuncNames["lle_X_drand48"] = lle_X_drand48; FuncNames["lle_X_srand48"] = lle_X_srand48; FuncNames["lle_X_lrand48"] = lle_X_lrand48; +#endif FuncNames["lle_X_sqrt"] = lle_X_sqrt; FuncNames["lle_X_puts"] = lle_X_puts; FuncNames["lle_X_printf"] = lle_X_printf; @@ -772,8 +729,5 @@ void Interpreter::initializeExternalFunctions() { FuncNames["lle_X_ungetc"] = lle_X_ungetc; FuncNames["lle_X_fprintf"] = lle_X_fprintf; FuncNames["lle_X_freopen"] = lle_X_freopen; - - FuncNames["lle_X_llvm.va_start"]= llvm_va_start; - FuncNames["lle_X_llvm.va_end"] = llvm_va_end; - FuncNames["lle_X_llvm.va_copy"] = llvm_va_copy; } +