2002-04-08 04:49:59 +08:00
|
|
|
//===-- ExternalFunctions.cpp - Implement External Functions --------------===//
|
2005-04-22 06:43:08 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 06:43:08 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2005-04-22 06:43:08 +08:00
|
|
|
//
|
2002-04-08 04:49:59 +08:00
|
|
|
// This file contains both code to deal with invoking "external" functions, but
|
|
|
|
// also contains code that implements "exported" external functions.
|
2001-09-10 12:50:17 +08:00
|
|
|
//
|
2009-02-04 14:26:47 +08:00
|
|
|
// There are currently two mechanisms for handling external functions in the
|
|
|
|
// Interpreter. The first is to implement lle_* wrapper functions that are
|
|
|
|
// specific to well-known library functions which manually translate the
|
|
|
|
// arguments from GenericValues and make the call. If such a wrapper does
|
|
|
|
// not exist, and libffi is available, then the Interpreter will attempt to
|
|
|
|
// invoke the function using libffi, after finding its address.
|
2001-09-10 12:50:17 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "Interpreter.h"
|
|
|
|
#include "llvm/DerivedTypes.h"
|
2003-10-15 05:42:11 +08:00
|
|
|
#include "llvm/Module.h"
|
2009-02-04 14:26:47 +08:00
|
|
|
#include "llvm/Config/config.h" // Detect libffi
|
2009-07-11 21:10:19 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2004-11-29 22:11:29 +08:00
|
|
|
#include "llvm/System/DynamicLibrary.h"
|
2002-10-03 05:12:13 +08:00
|
|
|
#include "llvm/Target/TargetData.h"
|
2007-07-28 02:26:35 +08:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2009-06-23 06:30:56 +08:00
|
|
|
#include "llvm/System/Mutex.h"
|
2003-11-05 09:18:49 +08:00
|
|
|
#include <csignal>
|
2008-10-08 15:23:46 +08:00
|
|
|
#include <cstdio>
|
2003-10-15 05:42:11 +08:00
|
|
|
#include <map>
|
2006-12-02 10:22:01 +08:00
|
|
|
#include <cmath>
|
2008-02-20 19:08:44 +08:00
|
|
|
#include <cstring>
|
2007-12-12 14:16:47 +08:00
|
|
|
|
2009-04-13 12:26:06 +08:00
|
|
|
#ifdef HAVE_FFI_CALL
|
2009-02-04 14:26:47 +08:00
|
|
|
#ifdef HAVE_FFI_H
|
|
|
|
#include <ffi.h>
|
2009-04-13 12:26:06 +08:00
|
|
|
#define USE_LIBFFI
|
2009-02-04 14:26:47 +08:00
|
|
|
#elif HAVE_FFI_FFI_H
|
|
|
|
#include <ffi/ffi.h>
|
2009-04-13 12:26:06 +08:00
|
|
|
#define USE_LIBFFI
|
2009-02-04 14:26:47 +08:00
|
|
|
#endif
|
2007-12-12 14:16:47 +08:00
|
|
|
#endif
|
2009-01-23 04:09:20 +08:00
|
|
|
|
2003-12-15 07:25:48 +08:00
|
|
|
using namespace llvm;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2009-06-23 06:30:56 +08:00
|
|
|
static ManagedStatic<sys::Mutex> FunctionsLock;
|
|
|
|
|
2009-02-04 14:26:47 +08:00
|
|
|
typedef GenericValue (*ExFunc)(const FunctionType *,
|
|
|
|
const std::vector<GenericValue> &);
|
|
|
|
static ManagedStatic<std::map<const Function *, ExFunc> > ExportedFunctions;
|
2002-01-21 06:54:45 +08:00
|
|
|
static std::map<std::string, ExFunc> FuncNames;
|
2001-09-10 12:50:17 +08:00
|
|
|
|
2009-04-13 12:26:06 +08:00
|
|
|
#ifdef USE_LIBFFI
|
2009-08-13 06:10:57 +08:00
|
|
|
typedef void (*RawFunc)();
|
2009-02-04 14:26:47 +08:00
|
|
|
static ManagedStatic<std::map<const Function *, RawFunc> > RawFunctions;
|
|
|
|
#endif
|
|
|
|
|
2001-10-27 12:15:57 +08:00
|
|
|
static Interpreter *TheInterpreter;
|
|
|
|
|
2001-09-10 12:50:17 +08:00
|
|
|
static char getTypeID(const Type *Ty) {
|
2004-06-18 02:19:28 +08:00
|
|
|
switch (Ty->getTypeID()) {
|
2001-09-10 12:50:17 +08:00
|
|
|
case Type::VoidTyID: return 'V';
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
case Type::IntegerTyID:
|
|
|
|
switch (cast<IntegerType>(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';
|
|
|
|
}
|
2001-09-10 12:50:17 +08:00
|
|
|
case Type::FloatTyID: return 'F';
|
|
|
|
case Type::DoubleTyID: return 'D';
|
|
|
|
case Type::PointerTyID: return 'P';
|
2006-12-31 13:51:36 +08:00
|
|
|
case Type::FunctionTyID:return 'M';
|
2001-09-10 12:50:17 +08:00
|
|
|
case Type::StructTyID: return 'T';
|
|
|
|
case Type::ArrayTyID: return 'A';
|
|
|
|
case Type::OpaqueTyID: return 'O';
|
|
|
|
default: return 'U';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-31 07:03:25 +08:00
|
|
|
// Try to find address of external function given a Function object.
|
|
|
|
// Please note, that interpreter doesn't know how to assemble a
|
|
|
|
// real call in general case (this is JIT job), that's why it assumes,
|
|
|
|
// that all external functions has the same (and pretty "general") signature.
|
|
|
|
// The typical example of such functions are "lle_X_" ones.
|
2003-10-11 01:03:10 +08:00
|
|
|
static ExFunc lookupFunction(const Function *F) {
|
2001-09-10 12:50:17 +08:00
|
|
|
// Function not found, look it up... start by figuring out what the
|
|
|
|
// composite function name should be.
|
2002-01-21 06:54:45 +08:00
|
|
|
std::string ExtName = "lle_";
|
2003-10-11 01:03:10 +08:00
|
|
|
const FunctionType *FT = F->getFunctionType();
|
|
|
|
for (unsigned i = 0, e = FT->getNumContainedTypes(); i != e; ++i)
|
|
|
|
ExtName += getTypeID(FT->getContainedType(i));
|
2009-07-24 16:24:36 +08:00
|
|
|
ExtName + "_" + F->getNameStr();
|
2001-09-10 12:50:17 +08:00
|
|
|
|
2009-07-08 02:33:04 +08:00
|
|
|
sys::ScopedLock Writer(*FunctionsLock);
|
2001-10-31 04:28:00 +08:00
|
|
|
ExFunc FnPtr = FuncNames[ExtName];
|
|
|
|
if (FnPtr == 0)
|
2009-07-24 16:24:36 +08:00
|
|
|
FnPtr = FuncNames["lle_X_" + F->getNameStr()];
|
2001-09-10 12:50:17 +08:00
|
|
|
if (FnPtr == 0) // Try calling a generic function... if it exists...
|
2009-07-23 05:10:12 +08:00
|
|
|
FnPtr = (ExFunc)(intptr_t)
|
2009-07-24 16:24:36 +08:00
|
|
|
sys::DynamicLibrary::SearchForAddressOfSymbol("lle_X_"+F->getNameStr());
|
2001-09-10 12:50:17 +08:00
|
|
|
if (FnPtr != 0)
|
2009-02-04 14:26:47 +08:00
|
|
|
ExportedFunctions->insert(std::make_pair(F, FnPtr)); // Cache for later
|
2001-09-10 12:50:17 +08:00
|
|
|
return FnPtr;
|
|
|
|
}
|
|
|
|
|
2009-04-13 12:26:06 +08:00
|
|
|
#ifdef USE_LIBFFI
|
2009-02-04 14:26:47 +08:00
|
|
|
static ffi_type *ffiTypeFor(const Type *Ty) {
|
|
|
|
switch (Ty->getTypeID()) {
|
|
|
|
case Type::VoidTyID: return &ffi_type_void;
|
|
|
|
case Type::IntegerTyID:
|
|
|
|
switch (cast<IntegerType>(Ty)->getBitWidth()) {
|
|
|
|
case 8: return &ffi_type_sint8;
|
|
|
|
case 16: return &ffi_type_sint16;
|
|
|
|
case 32: return &ffi_type_sint32;
|
|
|
|
case 64: return &ffi_type_sint64;
|
|
|
|
}
|
|
|
|
case Type::FloatTyID: return &ffi_type_float;
|
|
|
|
case Type::DoubleTyID: return &ffi_type_double;
|
|
|
|
case Type::PointerTyID: return &ffi_type_pointer;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
// TODO: Support other types such as StructTyID, ArrayTyID, OpaqueTyID, etc.
|
2009-07-11 21:10:19 +08:00
|
|
|
llvm_report_error("Type could not be mapped for use with libffi.");
|
2009-02-04 14:26:47 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *ffiValueFor(const Type *Ty, const GenericValue &AV,
|
|
|
|
void *ArgDataPtr) {
|
|
|
|
switch (Ty->getTypeID()) {
|
|
|
|
case Type::IntegerTyID:
|
|
|
|
switch (cast<IntegerType>(Ty)->getBitWidth()) {
|
|
|
|
case 8: {
|
|
|
|
int8_t *I8Ptr = (int8_t *) ArgDataPtr;
|
|
|
|
*I8Ptr = (int8_t) AV.IntVal.getZExtValue();
|
|
|
|
return ArgDataPtr;
|
|
|
|
}
|
|
|
|
case 16: {
|
|
|
|
int16_t *I16Ptr = (int16_t *) ArgDataPtr;
|
|
|
|
*I16Ptr = (int16_t) AV.IntVal.getZExtValue();
|
|
|
|
return ArgDataPtr;
|
|
|
|
}
|
|
|
|
case 32: {
|
|
|
|
int32_t *I32Ptr = (int32_t *) ArgDataPtr;
|
|
|
|
*I32Ptr = (int32_t) AV.IntVal.getZExtValue();
|
|
|
|
return ArgDataPtr;
|
|
|
|
}
|
|
|
|
case 64: {
|
|
|
|
int64_t *I64Ptr = (int64_t *) ArgDataPtr;
|
|
|
|
*I64Ptr = (int64_t) AV.IntVal.getZExtValue();
|
|
|
|
return ArgDataPtr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case Type::FloatTyID: {
|
|
|
|
float *FloatPtr = (float *) ArgDataPtr;
|
2009-11-18 13:43:15 +08:00
|
|
|
*FloatPtr = AV.FloatVal;
|
2009-02-04 14:26:47 +08:00
|
|
|
return ArgDataPtr;
|
|
|
|
}
|
|
|
|
case Type::DoubleTyID: {
|
|
|
|
double *DoublePtr = (double *) ArgDataPtr;
|
|
|
|
*DoublePtr = AV.DoubleVal;
|
|
|
|
return ArgDataPtr;
|
|
|
|
}
|
|
|
|
case Type::PointerTyID: {
|
|
|
|
void **PtrPtr = (void **) ArgDataPtr;
|
|
|
|
*PtrPtr = GVTOP(AV);
|
|
|
|
return ArgDataPtr;
|
|
|
|
}
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
// TODO: Support other types such as StructTyID, ArrayTyID, OpaqueTyID, etc.
|
2009-07-11 21:10:19 +08:00
|
|
|
llvm_report_error("Type value could not be mapped for use with libffi.");
|
2009-02-04 14:26:47 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool ffiInvoke(RawFunc Fn, Function *F,
|
|
|
|
const std::vector<GenericValue> &ArgVals,
|
|
|
|
const TargetData *TD, GenericValue &Result) {
|
|
|
|
ffi_cif cif;
|
|
|
|
const FunctionType *FTy = F->getFunctionType();
|
|
|
|
const unsigned NumArgs = F->arg_size();
|
|
|
|
|
|
|
|
// TODO: We don't have type information about the remaining arguments, because
|
|
|
|
// this information is never passed into ExecutionEngine::runFunction().
|
|
|
|
if (ArgVals.size() > NumArgs && F->isVarArg()) {
|
2009-07-11 21:10:19 +08:00
|
|
|
llvm_report_error("Calling external var arg function '" + F->getName()
|
|
|
|
+ "' is not supported by the Interpreter.");
|
2009-02-04 14:26:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned ArgBytes = 0;
|
|
|
|
|
|
|
|
std::vector<ffi_type*> args(NumArgs);
|
|
|
|
for (Function::const_arg_iterator A = F->arg_begin(), E = F->arg_end();
|
|
|
|
A != E; ++A) {
|
|
|
|
const unsigned ArgNo = A->getArgNo();
|
|
|
|
const Type *ArgTy = FTy->getParamType(ArgNo);
|
|
|
|
args[ArgNo] = ffiTypeFor(ArgTy);
|
|
|
|
ArgBytes += TD->getTypeStoreSize(ArgTy);
|
|
|
|
}
|
|
|
|
|
2009-09-19 00:46:16 +08:00
|
|
|
SmallVector<uint8_t, 128> ArgData;
|
|
|
|
ArgData.resize(ArgBytes);
|
|
|
|
uint8_t *ArgDataPtr = ArgData.data();
|
|
|
|
SmallVector<void*, 16> values(NumArgs);
|
2009-02-04 14:26:47 +08:00
|
|
|
for (Function::const_arg_iterator A = F->arg_begin(), E = F->arg_end();
|
|
|
|
A != E; ++A) {
|
|
|
|
const unsigned ArgNo = A->getArgNo();
|
|
|
|
const Type *ArgTy = FTy->getParamType(ArgNo);
|
|
|
|
values[ArgNo] = ffiValueFor(ArgTy, ArgVals[ArgNo], ArgDataPtr);
|
|
|
|
ArgDataPtr += TD->getTypeStoreSize(ArgTy);
|
|
|
|
}
|
|
|
|
|
|
|
|
const Type *RetTy = FTy->getReturnType();
|
|
|
|
ffi_type *rtype = ffiTypeFor(RetTy);
|
|
|
|
|
|
|
|
if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, NumArgs, rtype, &args[0]) == FFI_OK) {
|
2009-09-19 00:46:16 +08:00
|
|
|
SmallVector<uint8_t, 128> ret;
|
2009-02-04 14:26:47 +08:00
|
|
|
if (RetTy->getTypeID() != Type::VoidTyID)
|
2009-09-19 00:46:16 +08:00
|
|
|
ret.resize(TD->getTypeStoreSize(RetTy));
|
|
|
|
ffi_call(&cif, Fn, ret.data(), values.data());
|
2009-02-04 14:26:47 +08:00
|
|
|
switch (RetTy->getTypeID()) {
|
|
|
|
case Type::IntegerTyID:
|
|
|
|
switch (cast<IntegerType>(RetTy)->getBitWidth()) {
|
2009-09-19 00:46:16 +08:00
|
|
|
case 8: Result.IntVal = APInt(8 , *(int8_t *) ret.data()); break;
|
|
|
|
case 16: Result.IntVal = APInt(16, *(int16_t*) ret.data()); break;
|
|
|
|
case 32: Result.IntVal = APInt(32, *(int32_t*) ret.data()); break;
|
|
|
|
case 64: Result.IntVal = APInt(64, *(int64_t*) ret.data()); break;
|
2009-02-04 14:26:47 +08:00
|
|
|
}
|
|
|
|
break;
|
2009-09-19 00:46:16 +08:00
|
|
|
case Type::FloatTyID: Result.FloatVal = *(float *) ret.data(); break;
|
|
|
|
case Type::DoubleTyID: Result.DoubleVal = *(double*) ret.data(); break;
|
|
|
|
case Type::PointerTyID: Result.PointerVal = *(void **) ret.data(); break;
|
2009-02-04 14:26:47 +08:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2009-04-13 12:26:06 +08:00
|
|
|
#endif // USE_LIBFFI
|
2009-02-04 14:26:47 +08:00
|
|
|
|
2005-01-22 03:59:37 +08:00
|
|
|
GenericValue Interpreter::callExternalFunction(Function *F,
|
2003-05-14 22:21:30 +08:00
|
|
|
const std::vector<GenericValue> &ArgVals) {
|
2001-10-27 12:15:57 +08:00
|
|
|
TheInterpreter = this;
|
|
|
|
|
2009-06-23 06:30:56 +08:00
|
|
|
FunctionsLock->acquire();
|
|
|
|
|
2002-04-08 04:49:59 +08:00
|
|
|
// Do a lookup to see if the function is in our cache... this should just be a
|
2003-10-11 01:42:19 +08:00
|
|
|
// deferred annotation!
|
2009-02-04 14:26:47 +08:00
|
|
|
std::map<const Function *, ExFunc>::iterator FI = ExportedFunctions->find(F);
|
|
|
|
if (ExFunc Fn = (FI == ExportedFunctions->end()) ? lookupFunction(F)
|
2009-06-23 06:30:56 +08:00
|
|
|
: FI->second) {
|
|
|
|
FunctionsLock->release();
|
2009-02-04 14:26:47 +08:00
|
|
|
return Fn(F->getFunctionType(), ArgVals);
|
2009-06-23 06:30:56 +08:00
|
|
|
}
|
2009-02-04 14:26:47 +08:00
|
|
|
|
2009-04-13 12:26:06 +08:00
|
|
|
#ifdef USE_LIBFFI
|
2009-02-04 14:26:47 +08:00
|
|
|
std::map<const Function *, RawFunc>::iterator RF = RawFunctions->find(F);
|
|
|
|
RawFunc RawFn;
|
|
|
|
if (RF == RawFunctions->end()) {
|
|
|
|
RawFn = (RawFunc)(intptr_t)
|
|
|
|
sys::DynamicLibrary::SearchForAddressOfSymbol(F->getName());
|
|
|
|
if (RawFn != 0)
|
|
|
|
RawFunctions->insert(std::make_pair(F, RawFn)); // Cache for later
|
|
|
|
} else {
|
|
|
|
RawFn = RF->second;
|
2001-09-10 12:50:17 +08:00
|
|
|
}
|
2009-09-17 08:14:44 +08:00
|
|
|
|
2009-06-23 06:30:56 +08:00
|
|
|
FunctionsLock->release();
|
2001-09-10 12:50:17 +08:00
|
|
|
|
2009-02-04 14:26:47 +08:00
|
|
|
GenericValue Result;
|
|
|
|
if (RawFn != 0 && ffiInvoke(RawFn, F, ArgVals, getTargetData(), Result))
|
|
|
|
return Result;
|
2009-04-13 12:26:06 +08:00
|
|
|
#endif // USE_LIBFFI
|
2009-02-04 14:26:47 +08:00
|
|
|
|
2009-07-11 21:10:19 +08:00
|
|
|
if (F->getName() == "__main")
|
2010-01-05 09:53:59 +08:00
|
|
|
errs() << "Tried to execute an unknown external function: "
|
2009-07-11 21:10:19 +08:00
|
|
|
<< F->getType()->getDescription() << " __main\n";
|
|
|
|
else
|
|
|
|
llvm_report_error("Tried to execute an unknown external function: " +
|
|
|
|
F->getType()->getDescription() + " " +F->getName());
|
2009-11-17 15:52:09 +08:00
|
|
|
#ifndef USE_LIBFFI
|
2010-01-05 09:53:59 +08:00
|
|
|
errs() << "Recompiling LLVM with --enable-libffi might help.\n";
|
2009-11-17 15:52:09 +08:00
|
|
|
#endif
|
2009-02-04 14:26:47 +08:00
|
|
|
return GenericValue();
|
2001-09-10 12:50:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2002-03-29 11:57:15 +08:00
|
|
|
// Functions "exported" to the running application...
|
2001-09-10 12:50:17 +08:00
|
|
|
//
|
2009-08-08 04:50:09 +08:00
|
|
|
|
|
|
|
// Visual Studio warns about returning GenericValue in extern "C" linkage
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
#pragma warning(disable : 4190)
|
|
|
|
#endif
|
|
|
|
|
2001-09-10 12:50:17 +08:00
|
|
|
extern "C" { // Don't add C++ manglings to llvm mangling :)
|
|
|
|
|
2003-05-14 22:21:30 +08:00
|
|
|
// void atexit(Function*)
|
2009-02-04 14:26:47 +08:00
|
|
|
GenericValue lle_X_atexit(const FunctionType *FT,
|
|
|
|
const std::vector<GenericValue> &Args) {
|
2003-05-14 22:21:30 +08:00
|
|
|
assert(Args.size() == 1);
|
|
|
|
TheInterpreter->addAtExitHandler((Function*)GVTOP(Args[0]));
|
|
|
|
GenericValue GV;
|
2007-03-06 11:08:12 +08:00
|
|
|
GV.IntVal = 0;
|
2003-05-14 22:21:30 +08:00
|
|
|
return GV;
|
2001-10-19 05:55:32 +08:00
|
|
|
}
|
|
|
|
|
2002-10-03 05:12:13 +08:00
|
|
|
// void exit(int)
|
2009-02-04 14:26:47 +08:00
|
|
|
GenericValue lle_X_exit(const FunctionType *FT,
|
|
|
|
const std::vector<GenericValue> &Args) {
|
2001-10-27 12:15:57 +08:00
|
|
|
TheInterpreter->exitCalled(Args[0]);
|
|
|
|
return GenericValue();
|
|
|
|
}
|
|
|
|
|
2002-10-03 05:12:13 +08:00
|
|
|
// void abort(void)
|
2009-02-04 14:26:47 +08:00
|
|
|
GenericValue lle_X_abort(const FunctionType *FT,
|
|
|
|
const std::vector<GenericValue> &Args) {
|
2009-07-11 21:10:19 +08:00
|
|
|
//FIXME: should we report or raise here?
|
|
|
|
//llvm_report_error("Interpreted program raised SIGABRT");
|
2003-11-05 09:18:49 +08:00
|
|
|
raise (SIGABRT);
|
2002-05-21 05:17:16 +08:00
|
|
|
return GenericValue();
|
|
|
|
}
|
|
|
|
|
2009-02-04 14:26:47 +08:00
|
|
|
// int sprintf(char *, const char *, ...) - a very rough implementation to make
|
2001-12-13 08:43:47 +08:00
|
|
|
// output useful.
|
2009-02-04 14:26:47 +08:00
|
|
|
GenericValue lle_X_sprintf(const FunctionType *FT,
|
|
|
|
const std::vector<GenericValue> &Args) {
|
2003-01-13 08:59:47 +08:00
|
|
|
char *OutputBuffer = (char *)GVTOP(Args[0]);
|
|
|
|
const char *FmtStr = (const char *)GVTOP(Args[1]);
|
2001-12-13 08:43:47 +08:00
|
|
|
unsigned ArgNo = 2;
|
2001-10-30 04:27:45 +08:00
|
|
|
|
|
|
|
// printf should return # chars printed. This is completely incorrect, but
|
|
|
|
// close enough for now.
|
2009-09-17 08:14:44 +08:00
|
|
|
GenericValue GV;
|
2007-03-06 11:08:12 +08:00
|
|
|
GV.IntVal = APInt(32, strlen(FmtStr));
|
2001-10-30 04:27:45 +08:00
|
|
|
while (1) {
|
|
|
|
switch (*FmtStr) {
|
|
|
|
case 0: return GV; // Null terminator...
|
|
|
|
default: // Normal nonspecial character
|
2001-12-13 08:43:47 +08:00
|
|
|
sprintf(OutputBuffer++, "%c", *FmtStr++);
|
2001-10-30 04:27:45 +08:00
|
|
|
break;
|
|
|
|
case '\\': { // Handle escape codes
|
2001-12-13 08:43:47 +08:00
|
|
|
sprintf(OutputBuffer, "%c%c", *FmtStr, *(FmtStr+1));
|
|
|
|
FmtStr += 2; OutputBuffer += 2;
|
2001-10-30 04:27:45 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case '%': { // Handle format specifiers
|
2001-11-08 03:46:27 +08:00
|
|
|
char FmtBuf[100] = "", Buffer[1000] = "";
|
|
|
|
char *FB = FmtBuf;
|
|
|
|
*FB++ = *FmtStr++;
|
|
|
|
char Last = *FB++ = *FmtStr++;
|
|
|
|
unsigned HowLong = 0;
|
|
|
|
while (Last != 'c' && Last != 'd' && Last != 'i' && Last != 'u' &&
|
|
|
|
Last != 'o' && Last != 'x' && Last != 'X' && Last != 'e' &&
|
|
|
|
Last != 'E' && Last != 'g' && Last != 'G' && Last != 'f' &&
|
|
|
|
Last != 'p' && Last != 's' && Last != '%') {
|
|
|
|
if (Last == 'l' || Last == 'L') HowLong++; // Keep track of l's
|
|
|
|
Last = *FB++ = *FmtStr++;
|
2001-10-30 04:27:45 +08:00
|
|
|
}
|
2001-11-08 03:46:27 +08:00
|
|
|
*FB = 0;
|
2005-04-22 06:43:08 +08:00
|
|
|
|
2001-11-08 03:46:27 +08:00
|
|
|
switch (Last) {
|
|
|
|
case '%':
|
2008-08-06 07:36:35 +08:00
|
|
|
strcpy(Buffer, "%"); break;
|
2001-11-08 03:46:27 +08:00
|
|
|
case 'c':
|
2007-03-06 11:08:12 +08:00
|
|
|
sprintf(Buffer, FmtBuf, uint32_t(Args[ArgNo++].IntVal.getZExtValue()));
|
|
|
|
break;
|
2001-11-08 03:46:27 +08:00
|
|
|
case 'd': case 'i':
|
|
|
|
case 'u': case 'o':
|
|
|
|
case 'x': case 'X':
|
2002-08-03 07:08:32 +08:00
|
|
|
if (HowLong >= 1) {
|
2003-08-24 22:02:47 +08:00
|
|
|
if (HowLong == 1 &&
|
2006-08-16 09:24:12 +08:00
|
|
|
TheInterpreter->getTargetData()->getPointerSizeInBits() == 64 &&
|
2006-05-25 03:21:13 +08:00
|
|
|
sizeof(long) < sizeof(int64_t)) {
|
2002-08-03 07:08:32 +08:00
|
|
|
// 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);
|
|
|
|
FmtBuf[Size] = FmtBuf[Size-1];
|
|
|
|
FmtBuf[Size+1] = 0;
|
|
|
|
FmtBuf[Size-1] = 'l';
|
|
|
|
}
|
2007-03-06 11:08:12 +08:00
|
|
|
sprintf(Buffer, FmtBuf, Args[ArgNo++].IntVal.getZExtValue());
|
2002-08-03 07:08:32 +08:00
|
|
|
} else
|
2007-03-06 11:08:12 +08:00
|
|
|
sprintf(Buffer, FmtBuf,uint32_t(Args[ArgNo++].IntVal.getZExtValue()));
|
|
|
|
break;
|
2001-11-08 03:46:27 +08:00
|
|
|
case 'e': case 'E': case 'g': case 'G': case 'f':
|
|
|
|
sprintf(Buffer, FmtBuf, Args[ArgNo++].DoubleVal); break;
|
|
|
|
case 'p':
|
2003-01-13 08:59:47 +08:00
|
|
|
sprintf(Buffer, FmtBuf, (void*)GVTOP(Args[ArgNo++])); break;
|
2005-04-22 06:43:08 +08:00
|
|
|
case 's':
|
2003-01-13 08:59:47 +08:00
|
|
|
sprintf(Buffer, FmtBuf, (char*)GVTOP(Args[ArgNo++])); break;
|
2009-08-23 16:43:55 +08:00
|
|
|
default:
|
2010-01-05 09:53:59 +08:00
|
|
|
errs() << "<unknown printf code '" << *FmtStr << "'!>";
|
2001-11-08 03:46:27 +08:00
|
|
|
ArgNo++; break;
|
|
|
|
}
|
2001-12-13 08:43:47 +08:00
|
|
|
strcpy(OutputBuffer, Buffer);
|
|
|
|
OutputBuffer += strlen(Buffer);
|
2001-10-30 04:27:45 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-04-22 01:11:45 +08:00
|
|
|
return GV;
|
2001-10-30 04:27:45 +08:00
|
|
|
}
|
|
|
|
|
2009-02-04 14:26:47 +08:00
|
|
|
// int printf(const char *, ...) - a very rough implementation to make output
|
|
|
|
// useful.
|
|
|
|
GenericValue lle_X_printf(const FunctionType *FT,
|
|
|
|
const std::vector<GenericValue> &Args) {
|
2001-12-13 08:43:47 +08:00
|
|
|
char Buffer[10000];
|
2009-02-04 14:26:47 +08:00
|
|
|
std::vector<GenericValue> NewArgs;
|
2007-04-22 01:11:45 +08:00
|
|
|
NewArgs.push_back(PTOGV((void*)&Buffer[0]));
|
2001-12-13 08:43:47 +08:00
|
|
|
NewArgs.insert(NewArgs.end(), Args.begin(), Args.end());
|
2007-03-31 00:41:50 +08:00
|
|
|
GenericValue GV = lle_X_sprintf(FT, NewArgs);
|
2009-08-23 16:43:55 +08:00
|
|
|
outs() << Buffer;
|
2001-12-13 08:43:47 +08:00
|
|
|
return GV;
|
|
|
|
}
|
|
|
|
|
2002-03-09 06:51:07 +08:00
|
|
|
// int sscanf(const char *format, ...);
|
2009-02-04 14:26:47 +08:00
|
|
|
GenericValue lle_X_sscanf(const FunctionType *FT,
|
|
|
|
const std::vector<GenericValue> &args) {
|
2002-03-09 06:51:07 +08:00
|
|
|
assert(args.size() < 10 && "Only handle up to 10 args to sscanf right now!");
|
|
|
|
|
2003-04-01 06:12:37 +08:00
|
|
|
char *Args[10];
|
2002-03-09 06:51:07 +08:00
|
|
|
for (unsigned i = 0; i < args.size(); ++i)
|
2003-04-01 06:12:37 +08:00
|
|
|
Args[i] = (char*)GVTOP(args[i]);
|
2002-03-09 06:51:07 +08:00
|
|
|
|
|
|
|
GenericValue GV;
|
2007-03-06 11:08:12 +08:00
|
|
|
GV.IntVal = APInt(32, sscanf(Args[0], Args[1], Args[2], Args[3], Args[4],
|
|
|
|
Args[5], Args[6], Args[7], Args[8], Args[9]));
|
2003-04-01 06:12:37 +08:00
|
|
|
return GV;
|
|
|
|
}
|
|
|
|
|
|
|
|
// int scanf(const char *format, ...);
|
2009-02-04 14:26:47 +08:00
|
|
|
GenericValue lle_X_scanf(const FunctionType *FT,
|
|
|
|
const std::vector<GenericValue> &args) {
|
2003-04-01 06:12:37 +08:00
|
|
|
assert(args.size() < 10 && "Only handle up to 10 args to scanf right now!");
|
|
|
|
|
|
|
|
char *Args[10];
|
|
|
|
for (unsigned i = 0; i < args.size(); ++i)
|
|
|
|
Args[i] = (char*)GVTOP(args[i]);
|
|
|
|
|
|
|
|
GenericValue GV;
|
2007-03-06 11:08:12 +08:00
|
|
|
GV.IntVal = APInt(32, scanf( Args[0], Args[1], Args[2], Args[3], Args[4],
|
|
|
|
Args[5], Args[6], Args[7], Args[8], Args[9]));
|
2002-03-09 06:51:07 +08:00
|
|
|
return GV;
|
|
|
|
}
|
|
|
|
|
2009-02-04 14:26:47 +08:00
|
|
|
// int fprintf(FILE *, const char *, ...) - a very rough implementation to make
|
|
|
|
// output useful.
|
|
|
|
GenericValue lle_X_fprintf(const FunctionType *FT,
|
|
|
|
const std::vector<GenericValue> &Args) {
|
2003-04-22 06:43:20 +08:00
|
|
|
assert(Args.size() >= 2);
|
2002-11-07 07:05:03 +08:00
|
|
|
char Buffer[10000];
|
2009-02-04 14:26:47 +08:00
|
|
|
std::vector<GenericValue> NewArgs;
|
2003-01-13 08:59:47 +08:00
|
|
|
NewArgs.push_back(PTOGV(Buffer));
|
2002-11-07 07:05:03 +08:00
|
|
|
NewArgs.insert(NewArgs.end(), Args.begin()+1, Args.end());
|
2007-03-31 00:41:50 +08:00
|
|
|
GenericValue GV = lle_X_sprintf(FT, NewArgs);
|
2002-11-07 07:05:03 +08:00
|
|
|
|
2009-02-04 14:26:47 +08:00
|
|
|
fputs(Buffer, (FILE *) GVTOP(Args[0]));
|
2002-11-07 07:05:03 +08:00
|
|
|
return GV;
|
|
|
|
}
|
|
|
|
|
2001-09-10 12:50:17 +08:00
|
|
|
} // End extern "C"
|
2001-10-31 04:28:00 +08:00
|
|
|
|
2009-08-08 04:50:09 +08:00
|
|
|
// Done with externals; turn the warning back on
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
#pragma warning(default: 4190)
|
|
|
|
#endif
|
|
|
|
|
2001-10-31 04:28:00 +08:00
|
|
|
|
2003-05-09 00:18:31 +08:00
|
|
|
void Interpreter::initializeExternalFunctions() {
|
2009-07-08 02:33:04 +08:00
|
|
|
sys::ScopedLock Writer(*FunctionsLock);
|
2009-02-04 14:26:47 +08:00
|
|
|
FuncNames["lle_X_atexit"] = lle_X_atexit;
|
2001-11-03 18:15:32 +08:00
|
|
|
FuncNames["lle_X_exit"] = lle_X_exit;
|
2002-05-21 05:17:16 +08:00
|
|
|
FuncNames["lle_X_abort"] = lle_X_abort;
|
2009-02-04 14:26:47 +08:00
|
|
|
|
2001-11-03 18:15:32 +08:00
|
|
|
FuncNames["lle_X_printf"] = lle_X_printf;
|
2001-12-13 08:43:47 +08:00
|
|
|
FuncNames["lle_X_sprintf"] = lle_X_sprintf;
|
2002-03-09 06:51:07 +08:00
|
|
|
FuncNames["lle_X_sscanf"] = lle_X_sscanf;
|
2003-04-01 06:12:37 +08:00
|
|
|
FuncNames["lle_X_scanf"] = lle_X_scanf;
|
2002-11-07 07:05:03 +08:00
|
|
|
FuncNames["lle_X_fprintf"] = lle_X_fprintf;
|
2001-10-31 04:28:00 +08:00
|
|
|
}
|