1 //===-- ExternalFunctions.cpp - Implement External Functions --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains both code to deal with invoking "external" functions, but
11 // also contains code that implements "exported" external functions.
13 // There are currently two mechanisms for handling external functions in the
14 // Interpreter. The first is to implement lle_* wrapper functions that are
15 // specific to well-known library functions which manually translate the
16 // arguments from GenericValues and make the call. If such a wrapper does
17 // not exist, and libffi is available, then the Interpreter will attempt to
18 // invoke the function using libffi, after finding its address.
20 //===----------------------------------------------------------------------===//
22 #include "Interpreter.h"
23 #include "llvm/DerivedTypes.h"
24 #include "llvm/Module.h"
25 #include "llvm/Config/config.h" // Detect libffi
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/DynamicLibrary.h"
28 #include "llvm/Target/TargetData.h"
29 #include "llvm/Support/ManagedStatic.h"
30 #include "llvm/Support/Mutex.h"
49 static ManagedStatic
<sys::Mutex
> FunctionsLock
;
51 typedef GenericValue (*ExFunc
)(const FunctionType
*,
52 const std::vector
<GenericValue
> &);
53 static ManagedStatic
<std::map
<const Function
*, ExFunc
> > ExportedFunctions
;
54 static std::map
<std::string
, ExFunc
> FuncNames
;
57 typedef void (*RawFunc
)();
58 static ManagedStatic
<std::map
<const Function
*, RawFunc
> > RawFunctions
;
61 static Interpreter
*TheInterpreter
;
63 static char getTypeID(const Type
*Ty
) {
64 switch (Ty
->getTypeID()) {
65 case Type::VoidTyID
: return 'V';
66 case Type::IntegerTyID
:
67 switch (cast
<IntegerType
>(Ty
)->getBitWidth()) {
75 case Type::FloatTyID
: return 'F';
76 case Type::DoubleTyID
: return 'D';
77 case Type::PointerTyID
: return 'P';
78 case Type::FunctionTyID
:return 'M';
79 case Type::StructTyID
: return 'T';
80 case Type::ArrayTyID
: return 'A';
85 // Try to find address of external function given a Function object.
86 // Please note, that interpreter doesn't know how to assemble a
87 // real call in general case (this is JIT job), that's why it assumes,
88 // that all external functions has the same (and pretty "general") signature.
89 // The typical example of such functions are "lle_X_" ones.
90 static ExFunc
lookupFunction(const Function
*F
) {
91 // Function not found, look it up... start by figuring out what the
92 // composite function name should be.
93 std::string ExtName
= "lle_";
94 const FunctionType
*FT
= F
->getFunctionType();
95 for (unsigned i
= 0, e
= FT
->getNumContainedTypes(); i
!= e
; ++i
)
96 ExtName
+= getTypeID(FT
->getContainedType(i
));
97 ExtName
+ "_" + F
->getNameStr();
99 sys::ScopedLock
Writer(*FunctionsLock
);
100 ExFunc FnPtr
= FuncNames
[ExtName
];
102 FnPtr
= FuncNames
["lle_X_" + F
->getNameStr()];
103 if (FnPtr
== 0) // Try calling a generic function... if it exists...
104 FnPtr
= (ExFunc
)(intptr_t)
105 sys::DynamicLibrary::SearchForAddressOfSymbol("lle_X_"+F
->getNameStr());
107 ExportedFunctions
->insert(std::make_pair(F
, FnPtr
)); // Cache for later
112 static ffi_type
*ffiTypeFor(const Type
*Ty
) {
113 switch (Ty
->getTypeID()) {
114 case Type::VoidTyID
: return &ffi_type_void
;
115 case Type::IntegerTyID
:
116 switch (cast
<IntegerType
>(Ty
)->getBitWidth()) {
117 case 8: return &ffi_type_sint8
;
118 case 16: return &ffi_type_sint16
;
119 case 32: return &ffi_type_sint32
;
120 case 64: return &ffi_type_sint64
;
122 case Type::FloatTyID
: return &ffi_type_float
;
123 case Type::DoubleTyID
: return &ffi_type_double
;
124 case Type::PointerTyID
: return &ffi_type_pointer
;
127 // TODO: Support other types such as StructTyID, ArrayTyID, OpaqueTyID, etc.
128 report_fatal_error("Type could not be mapped for use with libffi.");
132 static void *ffiValueFor(const Type
*Ty
, const GenericValue
&AV
,
134 switch (Ty
->getTypeID()) {
135 case Type::IntegerTyID
:
136 switch (cast
<IntegerType
>(Ty
)->getBitWidth()) {
138 int8_t *I8Ptr
= (int8_t *) ArgDataPtr
;
139 *I8Ptr
= (int8_t) AV
.IntVal
.getZExtValue();
143 int16_t *I16Ptr
= (int16_t *) ArgDataPtr
;
144 *I16Ptr
= (int16_t) AV
.IntVal
.getZExtValue();
148 int32_t *I32Ptr
= (int32_t *) ArgDataPtr
;
149 *I32Ptr
= (int32_t) AV
.IntVal
.getZExtValue();
153 int64_t *I64Ptr
= (int64_t *) ArgDataPtr
;
154 *I64Ptr
= (int64_t) AV
.IntVal
.getZExtValue();
158 case Type::FloatTyID
: {
159 float *FloatPtr
= (float *) ArgDataPtr
;
160 *FloatPtr
= AV
.FloatVal
;
163 case Type::DoubleTyID
: {
164 double *DoublePtr
= (double *) ArgDataPtr
;
165 *DoublePtr
= AV
.DoubleVal
;
168 case Type::PointerTyID
: {
169 void **PtrPtr
= (void **) ArgDataPtr
;
175 // TODO: Support other types such as StructTyID, ArrayTyID, OpaqueTyID, etc.
176 report_fatal_error("Type value could not be mapped for use with libffi.");
180 static bool ffiInvoke(RawFunc Fn
, Function
*F
,
181 const std::vector
<GenericValue
> &ArgVals
,
182 const TargetData
*TD
, GenericValue
&Result
) {
184 const FunctionType
*FTy
= F
->getFunctionType();
185 const unsigned NumArgs
= F
->arg_size();
187 // TODO: We don't have type information about the remaining arguments, because
188 // this information is never passed into ExecutionEngine::runFunction().
189 if (ArgVals
.size() > NumArgs
&& F
->isVarArg()) {
190 report_fatal_error("Calling external var arg function '" + F
->getName()
191 + "' is not supported by the Interpreter.");
194 unsigned ArgBytes
= 0;
196 std::vector
<ffi_type
*> args(NumArgs
);
197 for (Function::const_arg_iterator A
= F
->arg_begin(), E
= F
->arg_end();
199 const unsigned ArgNo
= A
->getArgNo();
200 const Type
*ArgTy
= FTy
->getParamType(ArgNo
);
201 args
[ArgNo
] = ffiTypeFor(ArgTy
);
202 ArgBytes
+= TD
->getTypeStoreSize(ArgTy
);
205 SmallVector
<uint8_t, 128> ArgData
;
206 ArgData
.resize(ArgBytes
);
207 uint8_t *ArgDataPtr
= ArgData
.data();
208 SmallVector
<void*, 16> values(NumArgs
);
209 for (Function::const_arg_iterator A
= F
->arg_begin(), E
= F
->arg_end();
211 const unsigned ArgNo
= A
->getArgNo();
212 const Type
*ArgTy
= FTy
->getParamType(ArgNo
);
213 values
[ArgNo
] = ffiValueFor(ArgTy
, ArgVals
[ArgNo
], ArgDataPtr
);
214 ArgDataPtr
+= TD
->getTypeStoreSize(ArgTy
);
217 const Type
*RetTy
= FTy
->getReturnType();
218 ffi_type
*rtype
= ffiTypeFor(RetTy
);
220 if (ffi_prep_cif(&cif
, FFI_DEFAULT_ABI
, NumArgs
, rtype
, &args
[0]) == FFI_OK
) {
221 SmallVector
<uint8_t, 128> ret
;
222 if (RetTy
->getTypeID() != Type::VoidTyID
)
223 ret
.resize(TD
->getTypeStoreSize(RetTy
));
224 ffi_call(&cif
, Fn
, ret
.data(), values
.data());
225 switch (RetTy
->getTypeID()) {
226 case Type::IntegerTyID
:
227 switch (cast
<IntegerType
>(RetTy
)->getBitWidth()) {
228 case 8: Result
.IntVal
= APInt(8 , *(int8_t *) ret
.data()); break;
229 case 16: Result
.IntVal
= APInt(16, *(int16_t*) ret
.data()); break;
230 case 32: Result
.IntVal
= APInt(32, *(int32_t*) ret
.data()); break;
231 case 64: Result
.IntVal
= APInt(64, *(int64_t*) ret
.data()); break;
234 case Type::FloatTyID
: Result
.FloatVal
= *(float *) ret
.data(); break;
235 case Type::DoubleTyID
: Result
.DoubleVal
= *(double*) ret
.data(); break;
236 case Type::PointerTyID
: Result
.PointerVal
= *(void **) ret
.data(); break;
246 GenericValue
Interpreter::callExternalFunction(Function
*F
,
247 const std::vector
<GenericValue
> &ArgVals
) {
248 TheInterpreter
= this;
250 FunctionsLock
->acquire();
252 // Do a lookup to see if the function is in our cache... this should just be a
253 // deferred annotation!
254 std::map
<const Function
*, ExFunc
>::iterator FI
= ExportedFunctions
->find(F
);
255 if (ExFunc Fn
= (FI
== ExportedFunctions
->end()) ? lookupFunction(F
)
257 FunctionsLock
->release();
258 return Fn(F
->getFunctionType(), ArgVals
);
262 std::map
<const Function
*, RawFunc
>::iterator RF
= RawFunctions
->find(F
);
264 if (RF
== RawFunctions
->end()) {
265 RawFn
= (RawFunc
)(intptr_t)
266 sys::DynamicLibrary::SearchForAddressOfSymbol(F
->getName());
268 RawFn
= (RawFunc
)(intptr_t)getPointerToGlobalIfAvailable(F
);
270 RawFunctions
->insert(std::make_pair(F
, RawFn
)); // Cache for later
275 FunctionsLock
->release();
278 if (RawFn
!= 0 && ffiInvoke(RawFn
, F
, ArgVals
, getTargetData(), Result
))
282 if (F
->getName() == "__main")
283 errs() << "Tried to execute an unknown external function: "
284 << *F
->getType() << " __main\n";
286 report_fatal_error("Tried to execute an unknown external function: " +
289 errs() << "Recompiling LLVM with --enable-libffi might help.\n";
291 return GenericValue();
295 //===----------------------------------------------------------------------===//
296 // Functions "exported" to the running application...
299 // Visual Studio warns about returning GenericValue in extern "C" linkage
301 #pragma warning(disable : 4190)
304 extern "C" { // Don't add C++ manglings to llvm mangling :)
306 // void atexit(Function*)
307 GenericValue
lle_X_atexit(const FunctionType
*FT
,
308 const std::vector
<GenericValue
> &Args
) {
309 assert(Args
.size() == 1);
310 TheInterpreter
->addAtExitHandler((Function
*)GVTOP(Args
[0]));
317 GenericValue
lle_X_exit(const FunctionType
*FT
,
318 const std::vector
<GenericValue
> &Args
) {
319 TheInterpreter
->exitCalled(Args
[0]);
320 return GenericValue();
324 GenericValue
lle_X_abort(const FunctionType
*FT
,
325 const std::vector
<GenericValue
> &Args
) {
326 //FIXME: should we report or raise here?
327 //report_fatal_error("Interpreted program raised SIGABRT");
329 return GenericValue();
332 // int sprintf(char *, const char *, ...) - a very rough implementation to make
334 GenericValue
lle_X_sprintf(const FunctionType
*FT
,
335 const std::vector
<GenericValue
> &Args
) {
336 char *OutputBuffer
= (char *)GVTOP(Args
[0]);
337 const char *FmtStr
= (const char *)GVTOP(Args
[1]);
340 // printf should return # chars printed. This is completely incorrect, but
341 // close enough for now.
343 GV
.IntVal
= APInt(32, strlen(FmtStr
));
346 case 0: return GV
; // Null terminator...
347 default: // Normal nonspecial character
348 sprintf(OutputBuffer
++, "%c", *FmtStr
++);
350 case '\\': { // Handle escape codes
351 sprintf(OutputBuffer
, "%c%c", *FmtStr
, *(FmtStr
+1));
352 FmtStr
+= 2; OutputBuffer
+= 2;
355 case '%': { // Handle format specifiers
356 char FmtBuf
[100] = "", Buffer
[1000] = "";
359 char Last
= *FB
++ = *FmtStr
++;
360 unsigned HowLong
= 0;
361 while (Last
!= 'c' && Last
!= 'd' && Last
!= 'i' && Last
!= 'u' &&
362 Last
!= 'o' && Last
!= 'x' && Last
!= 'X' && Last
!= 'e' &&
363 Last
!= 'E' && Last
!= 'g' && Last
!= 'G' && Last
!= 'f' &&
364 Last
!= 'p' && Last
!= 's' && Last
!= '%') {
365 if (Last
== 'l' || Last
== 'L') HowLong
++; // Keep track of l's
366 Last
= *FB
++ = *FmtStr
++;
372 memcpy(Buffer
, "%", 2); break;
374 sprintf(Buffer
, FmtBuf
, uint32_t(Args
[ArgNo
++].IntVal
.getZExtValue()));
381 TheInterpreter
->getTargetData()->getPointerSizeInBits() == 64 &&
382 sizeof(long) < sizeof(int64_t)) {
383 // Make sure we use %lld with a 64 bit argument because we might be
384 // compiling LLI on a 32 bit compiler.
385 unsigned Size
= strlen(FmtBuf
);
386 FmtBuf
[Size
] = FmtBuf
[Size
-1];
388 FmtBuf
[Size
-1] = 'l';
390 sprintf(Buffer
, FmtBuf
, Args
[ArgNo
++].IntVal
.getZExtValue());
392 sprintf(Buffer
, FmtBuf
,uint32_t(Args
[ArgNo
++].IntVal
.getZExtValue()));
394 case 'e': case 'E': case 'g': case 'G': case 'f':
395 sprintf(Buffer
, FmtBuf
, Args
[ArgNo
++].DoubleVal
); break;
397 sprintf(Buffer
, FmtBuf
, (void*)GVTOP(Args
[ArgNo
++])); break;
399 sprintf(Buffer
, FmtBuf
, (char*)GVTOP(Args
[ArgNo
++])); break;
401 errs() << "<unknown printf code '" << *FmtStr
<< "'!>";
404 size_t Len
= strlen(Buffer
);
405 memcpy(OutputBuffer
, Buffer
, Len
+ 1);
414 // int printf(const char *, ...) - a very rough implementation to make output
416 GenericValue
lle_X_printf(const FunctionType
*FT
,
417 const std::vector
<GenericValue
> &Args
) {
419 std::vector
<GenericValue
> NewArgs
;
420 NewArgs
.push_back(PTOGV((void*)&Buffer
[0]));
421 NewArgs
.insert(NewArgs
.end(), Args
.begin(), Args
.end());
422 GenericValue GV
= lle_X_sprintf(FT
, NewArgs
);
427 // int sscanf(const char *format, ...);
428 GenericValue
lle_X_sscanf(const FunctionType
*FT
,
429 const std::vector
<GenericValue
> &args
) {
430 assert(args
.size() < 10 && "Only handle up to 10 args to sscanf right now!");
433 for (unsigned i
= 0; i
< args
.size(); ++i
)
434 Args
[i
] = (char*)GVTOP(args
[i
]);
437 GV
.IntVal
= APInt(32, sscanf(Args
[0], Args
[1], Args
[2], Args
[3], Args
[4],
438 Args
[5], Args
[6], Args
[7], Args
[8], Args
[9]));
442 // int scanf(const char *format, ...);
443 GenericValue
lle_X_scanf(const FunctionType
*FT
,
444 const std::vector
<GenericValue
> &args
) {
445 assert(args
.size() < 10 && "Only handle up to 10 args to scanf right now!");
448 for (unsigned i
= 0; i
< args
.size(); ++i
)
449 Args
[i
] = (char*)GVTOP(args
[i
]);
452 GV
.IntVal
= APInt(32, scanf( Args
[0], Args
[1], Args
[2], Args
[3], Args
[4],
453 Args
[5], Args
[6], Args
[7], Args
[8], Args
[9]));
457 // int fprintf(FILE *, const char *, ...) - a very rough implementation to make
459 GenericValue
lle_X_fprintf(const FunctionType
*FT
,
460 const std::vector
<GenericValue
> &Args
) {
461 assert(Args
.size() >= 2);
463 std::vector
<GenericValue
> NewArgs
;
464 NewArgs
.push_back(PTOGV(Buffer
));
465 NewArgs
.insert(NewArgs
.end(), Args
.begin()+1, Args
.end());
466 GenericValue GV
= lle_X_sprintf(FT
, NewArgs
);
468 fputs(Buffer
, (FILE *) GVTOP(Args
[0]));
474 // Done with externals; turn the warning back on
476 #pragma warning(default: 4190)
480 void Interpreter::initializeExternalFunctions() {
481 sys::ScopedLock
Writer(*FunctionsLock
);
482 FuncNames
["lle_X_atexit"] = lle_X_atexit
;
483 FuncNames
["lle_X_exit"] = lle_X_exit
;
484 FuncNames
["lle_X_abort"] = lle_X_abort
;
486 FuncNames
["lle_X_printf"] = lle_X_printf
;
487 FuncNames
["lle_X_sprintf"] = lle_X_sprintf
;
488 FuncNames
["lle_X_sscanf"] = lle_X_sscanf
;
489 FuncNames
["lle_X_scanf"] = lle_X_scanf
;
490 FuncNames
["lle_X_fprintf"] = lle_X_fprintf
;