1 //===-- ExternalFunctions.cpp - Implement External Functions --------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file contains both code to deal with invoking "external" functions, but
10 // also contains code that implements "exported" external functions.
12 // There are currently two mechanisms for handling external functions in the
13 // Interpreter. The first is to implement lle_* wrapper functions that are
14 // specific to well-known library functions which manually translate the
15 // arguments from GenericValues and make the call. If such a wrapper does
16 // not exist, and libffi is available, then the Interpreter will attempt to
17 // invoke the function using libffi, after finding its address.
19 //===----------------------------------------------------------------------===//
21 #include "Interpreter.h"
22 #include "llvm/ADT/APInt.h"
23 #include "llvm/ADT/ArrayRef.h"
24 #include "llvm/Config/config.h" // Detect libffi
25 #include "llvm/ExecutionEngine/GenericValue.h"
26 #include "llvm/IR/DataLayout.h"
27 #include "llvm/IR/DerivedTypes.h"
28 #include "llvm/IR/Function.h"
29 #include "llvm/IR/Type.h"
30 #include "llvm/Support/Casting.h"
31 #include "llvm/Support/DynamicLibrary.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/ManagedStatic.h"
34 #include "llvm/Support/Mutex.h"
35 #include "llvm/Support/raw_ostream.h"
60 static ManagedStatic
<sys::Mutex
> FunctionsLock
;
62 typedef GenericValue (*ExFunc
)(FunctionType
*, ArrayRef
<GenericValue
>);
63 static ManagedStatic
<std::map
<const Function
*, ExFunc
> > ExportedFunctions
;
64 static ManagedStatic
<std::map
<std::string
, ExFunc
> > FuncNames
;
67 typedef void (*RawFunc
)();
68 static ManagedStatic
<std::map
<const Function
*, RawFunc
> > RawFunctions
;
71 static Interpreter
*TheInterpreter
;
73 static char getTypeID(Type
*Ty
) {
74 switch (Ty
->getTypeID()) {
75 case Type::VoidTyID
: return 'V';
76 case Type::IntegerTyID
:
77 switch (cast
<IntegerType
>(Ty
)->getBitWidth()) {
85 case Type::FloatTyID
: return 'F';
86 case Type::DoubleTyID
: return 'D';
87 case Type::PointerTyID
: return 'P';
88 case Type::FunctionTyID
:return 'M';
89 case Type::StructTyID
: return 'T';
90 case Type::ArrayTyID
: return 'A';
95 // Try to find address of external function given a Function object.
96 // Please note, that interpreter doesn't know how to assemble a
97 // real call in general case (this is JIT job), that's why it assumes,
98 // that all external functions has the same (and pretty "general") signature.
99 // The typical example of such functions are "lle_X_" ones.
100 static ExFunc
lookupFunction(const Function
*F
) {
101 // Function not found, look it up... start by figuring out what the
102 // composite function name should be.
103 std::string ExtName
= "lle_";
104 FunctionType
*FT
= F
->getFunctionType();
105 ExtName
+= getTypeID(FT
->getReturnType());
106 for (Type
*T
: FT
->params())
107 ExtName
+= getTypeID(T
);
108 ExtName
+= ("_" + F
->getName()).str();
110 sys::ScopedLock
Writer(*FunctionsLock
);
111 ExFunc FnPtr
= (*FuncNames
)[ExtName
];
113 FnPtr
= (*FuncNames
)[("lle_X_" + F
->getName()).str()];
114 if (!FnPtr
) // Try calling a generic function... if it exists...
115 FnPtr
= (ExFunc
)(intptr_t)sys::DynamicLibrary::SearchForAddressOfSymbol(
116 ("lle_X_" + F
->getName()).str());
118 ExportedFunctions
->insert(std::make_pair(F
, FnPtr
)); // Cache for later
123 static ffi_type
*ffiTypeFor(Type
*Ty
) {
124 switch (Ty
->getTypeID()) {
125 case Type::VoidTyID
: return &ffi_type_void
;
126 case Type::IntegerTyID
:
127 switch (cast
<IntegerType
>(Ty
)->getBitWidth()) {
128 case 8: return &ffi_type_sint8
;
129 case 16: return &ffi_type_sint16
;
130 case 32: return &ffi_type_sint32
;
131 case 64: return &ffi_type_sint64
;
133 case Type::FloatTyID
: return &ffi_type_float
;
134 case Type::DoubleTyID
: return &ffi_type_double
;
135 case Type::PointerTyID
: return &ffi_type_pointer
;
138 // TODO: Support other types such as StructTyID, ArrayTyID, OpaqueTyID, etc.
139 report_fatal_error("Type could not be mapped for use with libffi.");
143 static void *ffiValueFor(Type
*Ty
, const GenericValue
&AV
,
145 switch (Ty
->getTypeID()) {
146 case Type::IntegerTyID
:
147 switch (cast
<IntegerType
>(Ty
)->getBitWidth()) {
149 int8_t *I8Ptr
= (int8_t *) ArgDataPtr
;
150 *I8Ptr
= (int8_t) AV
.IntVal
.getZExtValue();
154 int16_t *I16Ptr
= (int16_t *) ArgDataPtr
;
155 *I16Ptr
= (int16_t) AV
.IntVal
.getZExtValue();
159 int32_t *I32Ptr
= (int32_t *) ArgDataPtr
;
160 *I32Ptr
= (int32_t) AV
.IntVal
.getZExtValue();
164 int64_t *I64Ptr
= (int64_t *) ArgDataPtr
;
165 *I64Ptr
= (int64_t) AV
.IntVal
.getZExtValue();
169 case Type::FloatTyID
: {
170 float *FloatPtr
= (float *) ArgDataPtr
;
171 *FloatPtr
= AV
.FloatVal
;
174 case Type::DoubleTyID
: {
175 double *DoublePtr
= (double *) ArgDataPtr
;
176 *DoublePtr
= AV
.DoubleVal
;
179 case Type::PointerTyID
: {
180 void **PtrPtr
= (void **) ArgDataPtr
;
186 // TODO: Support other types such as StructTyID, ArrayTyID, OpaqueTyID, etc.
187 report_fatal_error("Type value could not be mapped for use with libffi.");
191 static bool ffiInvoke(RawFunc Fn
, Function
*F
, ArrayRef
<GenericValue
> ArgVals
,
192 const DataLayout
&TD
, GenericValue
&Result
) {
194 FunctionType
*FTy
= F
->getFunctionType();
195 const unsigned NumArgs
= F
->arg_size();
197 // TODO: We don't have type information about the remaining arguments, because
198 // this information is never passed into ExecutionEngine::runFunction().
199 if (ArgVals
.size() > NumArgs
&& F
->isVarArg()) {
200 report_fatal_error("Calling external var arg function '" + F
->getName()
201 + "' is not supported by the Interpreter.");
204 unsigned ArgBytes
= 0;
206 std::vector
<ffi_type
*> args(NumArgs
);
207 for (Function::const_arg_iterator A
= F
->arg_begin(), E
= F
->arg_end();
209 const unsigned ArgNo
= A
->getArgNo();
210 Type
*ArgTy
= FTy
->getParamType(ArgNo
);
211 args
[ArgNo
] = ffiTypeFor(ArgTy
);
212 ArgBytes
+= TD
.getTypeStoreSize(ArgTy
);
215 SmallVector
<uint8_t, 128> ArgData
;
216 ArgData
.resize(ArgBytes
);
217 uint8_t *ArgDataPtr
= ArgData
.data();
218 SmallVector
<void*, 16> values(NumArgs
);
219 for (Function::const_arg_iterator A
= F
->arg_begin(), E
= F
->arg_end();
221 const unsigned ArgNo
= A
->getArgNo();
222 Type
*ArgTy
= FTy
->getParamType(ArgNo
);
223 values
[ArgNo
] = ffiValueFor(ArgTy
, ArgVals
[ArgNo
], ArgDataPtr
);
224 ArgDataPtr
+= TD
.getTypeStoreSize(ArgTy
);
227 Type
*RetTy
= FTy
->getReturnType();
228 ffi_type
*rtype
= ffiTypeFor(RetTy
);
230 if (ffi_prep_cif(&cif
, FFI_DEFAULT_ABI
, NumArgs
, rtype
, args
.data()) ==
232 SmallVector
<uint8_t, 128> ret
;
233 if (RetTy
->getTypeID() != Type::VoidTyID
)
234 ret
.resize(TD
.getTypeStoreSize(RetTy
));
235 ffi_call(&cif
, Fn
, ret
.data(), values
.data());
236 switch (RetTy
->getTypeID()) {
237 case Type::IntegerTyID
:
238 switch (cast
<IntegerType
>(RetTy
)->getBitWidth()) {
239 case 8: Result
.IntVal
= APInt(8 , *(int8_t *) ret
.data()); break;
240 case 16: Result
.IntVal
= APInt(16, *(int16_t*) ret
.data()); break;
241 case 32: Result
.IntVal
= APInt(32, *(int32_t*) ret
.data()); break;
242 case 64: Result
.IntVal
= APInt(64, *(int64_t*) ret
.data()); break;
245 case Type::FloatTyID
: Result
.FloatVal
= *(float *) ret
.data(); break;
246 case Type::DoubleTyID
: Result
.DoubleVal
= *(double*) ret
.data(); break;
247 case Type::PointerTyID
: Result
.PointerVal
= *(void **) ret
.data(); break;
257 GenericValue
Interpreter::callExternalFunction(Function
*F
,
258 ArrayRef
<GenericValue
> ArgVals
) {
259 TheInterpreter
= this;
261 std::unique_lock
<sys::Mutex
> Guard(*FunctionsLock
);
263 // Do a lookup to see if the function is in our cache... this should just be a
264 // deferred annotation!
265 std::map
<const Function
*, ExFunc
>::iterator FI
= ExportedFunctions
->find(F
);
266 if (ExFunc Fn
= (FI
== ExportedFunctions
->end()) ? lookupFunction(F
)
269 return Fn(F
->getFunctionType(), ArgVals
);
273 std::map
<const Function
*, RawFunc
>::iterator RF
= RawFunctions
->find(F
);
275 if (RF
== RawFunctions
->end()) {
276 RawFn
= (RawFunc
)(intptr_t)
277 sys::DynamicLibrary::SearchForAddressOfSymbol(F
->getName());
279 RawFn
= (RawFunc
)(intptr_t)getPointerToGlobalIfAvailable(F
);
281 RawFunctions
->insert(std::make_pair(F
, RawFn
)); // Cache for later
289 if (RawFn
!= 0 && ffiInvoke(RawFn
, F
, ArgVals
, getDataLayout(), Result
))
293 if (F
->getName() == "__main")
294 errs() << "Tried to execute an unknown external function: "
295 << *F
->getType() << " __main\n";
297 report_fatal_error("Tried to execute an unknown external function: " +
300 errs() << "Recompiling LLVM with --enable-libffi might help.\n";
302 return GenericValue();
305 //===----------------------------------------------------------------------===//
306 // Functions "exported" to the running application...
309 // void atexit(Function*)
310 static GenericValue
lle_X_atexit(FunctionType
*FT
,
311 ArrayRef
<GenericValue
> Args
) {
312 assert(Args
.size() == 1);
313 TheInterpreter
->addAtExitHandler((Function
*)GVTOP(Args
[0]));
320 static GenericValue
lle_X_exit(FunctionType
*FT
, ArrayRef
<GenericValue
> Args
) {
321 TheInterpreter
->exitCalled(Args
[0]);
322 return GenericValue();
326 static GenericValue
lle_X_abort(FunctionType
*FT
, ArrayRef
<GenericValue
> Args
) {
327 //FIXME: should we report or raise here?
328 //report_fatal_error("Interpreted program raised SIGABRT");
330 return GenericValue();
333 // int sprintf(char *, const char *, ...) - a very rough implementation to make
335 static GenericValue
lle_X_sprintf(FunctionType
*FT
,
336 ArrayRef
<GenericValue
> Args
) {
337 char *OutputBuffer
= (char *)GVTOP(Args
[0]);
338 const char *FmtStr
= (const char *)GVTOP(Args
[1]);
341 // printf should return # chars printed. This is completely incorrect, but
342 // close enough for now.
344 GV
.IntVal
= APInt(32, strlen(FmtStr
));
347 case 0: return GV
; // Null terminator...
348 default: // Normal nonspecial character
349 sprintf(OutputBuffer
++, "%c", *FmtStr
++);
351 case '\\': { // Handle escape codes
352 sprintf(OutputBuffer
, "%c%c", *FmtStr
, *(FmtStr
+1));
353 FmtStr
+= 2; OutputBuffer
+= 2;
356 case '%': { // Handle format specifiers
357 char FmtBuf
[100] = "", Buffer
[1000] = "";
360 char Last
= *FB
++ = *FmtStr
++;
361 unsigned HowLong
= 0;
362 while (Last
!= 'c' && Last
!= 'd' && Last
!= 'i' && Last
!= 'u' &&
363 Last
!= 'o' && Last
!= 'x' && Last
!= 'X' && Last
!= 'e' &&
364 Last
!= 'E' && Last
!= 'g' && Last
!= 'G' && Last
!= 'f' &&
365 Last
!= 'p' && Last
!= 's' && Last
!= '%') {
366 if (Last
== 'l' || Last
== 'L') HowLong
++; // Keep track of l's
367 Last
= *FB
++ = *FmtStr
++;
373 memcpy(Buffer
, "%", 2); break;
375 sprintf(Buffer
, FmtBuf
, uint32_t(Args
[ArgNo
++].IntVal
.getZExtValue()));
382 TheInterpreter
->getDataLayout().getPointerSizeInBits() == 64 &&
383 sizeof(long) < sizeof(int64_t)) {
384 // Make sure we use %lld with a 64 bit argument because we might be
385 // compiling LLI on a 32 bit compiler.
386 unsigned Size
= strlen(FmtBuf
);
387 FmtBuf
[Size
] = FmtBuf
[Size
-1];
389 FmtBuf
[Size
-1] = 'l';
391 sprintf(Buffer
, FmtBuf
, Args
[ArgNo
++].IntVal
.getZExtValue());
393 sprintf(Buffer
, FmtBuf
,uint32_t(Args
[ArgNo
++].IntVal
.getZExtValue()));
395 case 'e': case 'E': case 'g': case 'G': case 'f':
396 sprintf(Buffer
, FmtBuf
, Args
[ArgNo
++].DoubleVal
); break;
398 sprintf(Buffer
, FmtBuf
, (void*)GVTOP(Args
[ArgNo
++])); break;
400 sprintf(Buffer
, FmtBuf
, (char*)GVTOP(Args
[ArgNo
++])); break;
402 errs() << "<unknown printf code '" << *FmtStr
<< "'!>";
405 size_t Len
= strlen(Buffer
);
406 memcpy(OutputBuffer
, Buffer
, Len
+ 1);
415 // int printf(const char *, ...) - a very rough implementation to make output
417 static GenericValue
lle_X_printf(FunctionType
*FT
,
418 ArrayRef
<GenericValue
> Args
) {
420 std::vector
<GenericValue
> NewArgs
;
421 NewArgs
.push_back(PTOGV((void*)&Buffer
[0]));
422 NewArgs
.insert(NewArgs
.end(), Args
.begin(), Args
.end());
423 GenericValue GV
= lle_X_sprintf(FT
, NewArgs
);
428 // int sscanf(const char *format, ...);
429 static GenericValue
lle_X_sscanf(FunctionType
*FT
,
430 ArrayRef
<GenericValue
> args
) {
431 assert(args
.size() < 10 && "Only handle up to 10 args to sscanf right now!");
434 for (unsigned i
= 0; i
< args
.size(); ++i
)
435 Args
[i
] = (char*)GVTOP(args
[i
]);
438 GV
.IntVal
= APInt(32, sscanf(Args
[0], Args
[1], Args
[2], Args
[3], Args
[4],
439 Args
[5], Args
[6], Args
[7], Args
[8], Args
[9]));
443 // int scanf(const char *format, ...);
444 static GenericValue
lle_X_scanf(FunctionType
*FT
, ArrayRef
<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 static GenericValue
lle_X_fprintf(FunctionType
*FT
,
460 ArrayRef
<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]));
472 static GenericValue
lle_X_memset(FunctionType
*FT
,
473 ArrayRef
<GenericValue
> Args
) {
474 int val
= (int)Args
[1].IntVal
.getSExtValue();
475 size_t len
= (size_t)Args
[2].IntVal
.getZExtValue();
476 memset((void *)GVTOP(Args
[0]), val
, len
);
477 // llvm.memset.* returns void, lle_X_* returns GenericValue,
478 // so here we return GenericValue with IntVal set to zero
484 static GenericValue
lle_X_memcpy(FunctionType
*FT
,
485 ArrayRef
<GenericValue
> Args
) {
486 memcpy(GVTOP(Args
[0]), GVTOP(Args
[1]),
487 (size_t)(Args
[2].IntVal
.getLimitedValue()));
489 // llvm.memcpy* returns void, lle_X_* returns GenericValue,
490 // so here we return GenericValue with IntVal set to zero
496 void Interpreter::initializeExternalFunctions() {
497 sys::ScopedLock
Writer(*FunctionsLock
);
498 (*FuncNames
)["lle_X_atexit"] = lle_X_atexit
;
499 (*FuncNames
)["lle_X_exit"] = lle_X_exit
;
500 (*FuncNames
)["lle_X_abort"] = lle_X_abort
;
502 (*FuncNames
)["lle_X_printf"] = lle_X_printf
;
503 (*FuncNames
)["lle_X_sprintf"] = lle_X_sprintf
;
504 (*FuncNames
)["lle_X_sscanf"] = lle_X_sscanf
;
505 (*FuncNames
)["lle_X_scanf"] = lle_X_scanf
;
506 (*FuncNames
)["lle_X_fprintf"] = lle_X_fprintf
;
507 (*FuncNames
)["lle_X_memset"] = lle_X_memset
;
508 (*FuncNames
)["lle_X_memcpy"] = lle_X_memcpy
;