ExternalFunctions.cpp revision e4a5743d87bb5b389c4505c51714364062704a7b 
1//===-- ExternalFunctions.cpp - Implement External Functions --------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file contains both code to deal with invoking "external" functions, but
11//  also contains code that implements "exported" external functions.
12//
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.
19//
20//===----------------------------------------------------------------------===//
21
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/System/DynamicLibrary.h"
28#include "llvm/Target/TargetData.h"
29#include "llvm/Support/ManagedStatic.h"
30#include "llvm/System/Mutex.h"
31#include <csignal>
32#include <cstdio>
33#include <map>
34#include <cmath>
35#include <cstring>
36// Some platforms may need malloc.h for alloca.
37#ifdef HAVE_MALLOC_H
38#include <malloc.h>
39#endif
40
41#ifdef HAVE_FFI_CALL
42#ifdef HAVE_FFI_H
43#include <ffi.h>
44#define USE_LIBFFI
45#elif HAVE_FFI_FFI_H
46#include <ffi/ffi.h>
47#define USE_LIBFFI
48#endif
49#endif
50
51using namespace llvm;
52
53static ManagedStatic<sys::Mutex> FunctionsLock;
54
55typedef GenericValue (*ExFunc)(const FunctionType *,
56                               const std::vector<GenericValue> &);
57static ManagedStatic<std::map<const Function *, ExFunc> > ExportedFunctions;
58static std::map<std::string, ExFunc> FuncNames;
59
60#ifdef USE_LIBFFI
61typedef void (*RawFunc)();
62static ManagedStatic<std::map<const Function *, RawFunc> > RawFunctions;
63#endif
64
65static Interpreter *TheInterpreter;
66
67static char getTypeID(const Type *Ty) {
68  switch (Ty->getTypeID()) {
69  case Type::VoidTyID:    return 'V';
70  case Type::IntegerTyID:
71    switch (cast<IntegerType>(Ty)->getBitWidth()) {
72      case 1:  return 'o';
73      case 8:  return 'B';
74      case 16: return 'S';
75      case 32: return 'I';
76      case 64: return 'L';
77      default: return 'N';
78    }
79  case Type::FloatTyID:   return 'F';
80  case Type::DoubleTyID:  return 'D';
81  case Type::PointerTyID: return 'P';
82  case Type::FunctionTyID:return 'M';
83  case Type::StructTyID:  return 'T';
84  case Type::ArrayTyID:   return 'A';
85  case Type::OpaqueTyID:  return 'O';
86  default: return 'U';
87  }
88}
89
90// Try to find address of external function given a Function object.
91// Please note, that interpreter doesn't know how to assemble a
92// real call in general case (this is JIT job), that's why it assumes,
93// that all external functions has the same (and pretty "general") signature.
94// The typical example of such functions are "lle_X_" ones.
95static ExFunc lookupFunction(const Function *F) {
96  // Function not found, look it up... start by figuring out what the
97  // composite function name should be.
98  std::string ExtName = "lle_";
99  const FunctionType *FT = F->getFunctionType();
100  for (unsigned i = 0, e = FT->getNumContainedTypes(); i != e; ++i)
101    ExtName += getTypeID(FT->getContainedType(i));
102  ExtName + "_" + F->getNameStr();
103
104  sys::ScopedLock Writer(*FunctionsLock);
105  ExFunc FnPtr = FuncNames[ExtName];
106  if (FnPtr == 0)
107    FnPtr = FuncNames["lle_X_" + F->getNameStr()];
108  if (FnPtr == 0)  // Try calling a generic function... if it exists...
109    FnPtr = (ExFunc)(intptr_t)
110      sys::DynamicLibrary::SearchForAddressOfSymbol("lle_X_"+F->getNameStr());
111  if (FnPtr != 0)
112    ExportedFunctions->insert(std::make_pair(F, FnPtr));  // Cache for later
113  return FnPtr;
114}
115
116#ifdef USE_LIBFFI
117static ffi_type *ffiTypeFor(const Type *Ty) {
118  switch (Ty->getTypeID()) {
119    case Type::VoidTyID: return &ffi_type_void;
120    case Type::IntegerTyID:
121      switch (cast<IntegerType>(Ty)->getBitWidth()) {
122        case 8:  return &ffi_type_sint8;
123        case 16: return &ffi_type_sint16;
124        case 32: return &ffi_type_sint32;
125        case 64: return &ffi_type_sint64;
126      }
127    case Type::FloatTyID:   return &ffi_type_float;
128    case Type::DoubleTyID:  return &ffi_type_double;
129    case Type::PointerTyID: return &ffi_type_pointer;
130    default: break;
131  }
132  // TODO: Support other types such as StructTyID, ArrayTyID, OpaqueTyID, etc.
133  llvm_report_error("Type could not be mapped for use with libffi.");
134  return NULL;
135}
136
137static void *ffiValueFor(const Type *Ty, const GenericValue &AV,
138                         void *ArgDataPtr) {
139  switch (Ty->getTypeID()) {
140    case Type::IntegerTyID:
141      switch (cast<IntegerType>(Ty)->getBitWidth()) {
142        case 8: {
143          int8_t *I8Ptr = (int8_t *) ArgDataPtr;
144          *I8Ptr = (int8_t) AV.IntVal.getZExtValue();
145          return ArgDataPtr;
146        }
147        case 16: {
148          int16_t *I16Ptr = (int16_t *) ArgDataPtr;
149          *I16Ptr = (int16_t) AV.IntVal.getZExtValue();
150          return ArgDataPtr;
151        }
152        case 32: {
153          int32_t *I32Ptr = (int32_t *) ArgDataPtr;
154          *I32Ptr = (int32_t) AV.IntVal.getZExtValue();
155          return ArgDataPtr;
156        }
157        case 64: {
158          int64_t *I64Ptr = (int64_t *) ArgDataPtr;
159          *I64Ptr = (int64_t) AV.IntVal.getZExtValue();
160          return ArgDataPtr;
161        }
162      }
163    case Type::FloatTyID: {
164      float *FloatPtr = (float *) ArgDataPtr;
165      *FloatPtr = AV.DoubleVal;
166      return ArgDataPtr;
167    }
168    case Type::DoubleTyID: {
169      double *DoublePtr = (double *) ArgDataPtr;
170      *DoublePtr = AV.DoubleVal;
171      return ArgDataPtr;
172    }
173    case Type::PointerTyID: {
174      void **PtrPtr = (void **) ArgDataPtr;
175      *PtrPtr = GVTOP(AV);
176      return ArgDataPtr;
177    }
178    default: break;
179  }
180  // TODO: Support other types such as StructTyID, ArrayTyID, OpaqueTyID, etc.
181  llvm_report_error("Type value could not be mapped for use with libffi.");
182  return NULL;
183}
184
185static bool ffiInvoke(RawFunc Fn, Function *F,
186                      const std::vector<GenericValue> &ArgVals,
187                      const TargetData *TD, GenericValue &Result) {
188  ffi_cif cif;
189  const FunctionType *FTy = F->getFunctionType();
190  const unsigned NumArgs = F->arg_size();
191
192  // TODO: We don't have type information about the remaining arguments, because
193  // this information is never passed into ExecutionEngine::runFunction().
194  if (ArgVals.size() > NumArgs && F->isVarArg()) {
195    llvm_report_error("Calling external var arg function '" + F->getName()
196                      + "' is not supported by the Interpreter.");
197  }
198
199  unsigned ArgBytes = 0;
200
201  std::vector<ffi_type*> args(NumArgs);
202  for (Function::const_arg_iterator A = F->arg_begin(), E = F->arg_end();
203       A != E; ++A) {
204    const unsigned ArgNo = A->getArgNo();
205    const Type *ArgTy = FTy->getParamType(ArgNo);
206    args[ArgNo] = ffiTypeFor(ArgTy);
207    ArgBytes += TD->getTypeStoreSize(ArgTy);
208  }
209
210  uint8_t *ArgData = (uint8_t*) alloca(ArgBytes);
211  uint8_t *ArgDataPtr = ArgData;
212  std::vector<void*> values(NumArgs);
213  for (Function::const_arg_iterator A = F->arg_begin(), E = F->arg_end();
214       A != E; ++A) {
215    const unsigned ArgNo = A->getArgNo();
216    const Type *ArgTy = FTy->getParamType(ArgNo);
217    values[ArgNo] = ffiValueFor(ArgTy, ArgVals[ArgNo], ArgDataPtr);
218    ArgDataPtr += TD->getTypeStoreSize(ArgTy);
219  }
220
221  const Type *RetTy = FTy->getReturnType();
222  ffi_type *rtype = ffiTypeFor(RetTy);
223
224  if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, NumArgs, rtype, &args[0]) == FFI_OK) {
225    void *ret = NULL;
226    if (RetTy->getTypeID() != Type::VoidTyID)
227      ret = alloca(TD->getTypeStoreSize(RetTy));
228    ffi_call(&cif, Fn, ret, &values[0]);
229    switch (RetTy->getTypeID()) {
230      case Type::IntegerTyID:
231        switch (cast<IntegerType>(RetTy)->getBitWidth()) {
232          case 8:  Result.IntVal = APInt(8 , *(int8_t *) ret); break;
233          case 16: Result.IntVal = APInt(16, *(int16_t*) ret); break;
234          case 32: Result.IntVal = APInt(32, *(int32_t*) ret); break;
235          case 64: Result.IntVal = APInt(64, *(int64_t*) ret); break;
236        }
237        break;
238      case Type::FloatTyID:   Result.FloatVal   = *(float *) ret; break;
239      case Type::DoubleTyID:  Result.DoubleVal  = *(double*) ret; break;
240      case Type::PointerTyID: Result.PointerVal = *(void **) ret; break;
241      default: break;
242    }
243    return true;
244  }
245
246  return false;
247}
248#endif // USE_LIBFFI
249
250GenericValue Interpreter::callExternalFunction(Function *F,
251                                     const std::vector<GenericValue> &ArgVals) {
252  TheInterpreter = this;
253
254  FunctionsLock->acquire();
255
256  // Do a lookup to see if the function is in our cache... this should just be a
257  // deferred annotation!
258  std::map<const Function *, ExFunc>::iterator FI = ExportedFunctions->find(F);
259  if (ExFunc Fn = (FI == ExportedFunctions->end()) ? lookupFunction(F)
260                                                   : FI->second) {
261    FunctionsLock->release();
262    return Fn(F->getFunctionType(), ArgVals);
263  }
264
265#ifdef USE_LIBFFI
266  std::map<const Function *, RawFunc>::iterator RF = RawFunctions->find(F);
267  RawFunc RawFn;
268  if (RF == RawFunctions->end()) {
269    RawFn = (RawFunc)(intptr_t)
270      sys::DynamicLibrary::SearchForAddressOfSymbol(F->getName());
271    if (RawFn != 0)
272      RawFunctions->insert(std::make_pair(F, RawFn));  // Cache for later
273  } else {
274    RawFn = RF->second;
275  }
276
277  FunctionsLock->release();
278
279  GenericValue Result;
280  if (RawFn != 0 && ffiInvoke(RawFn, F, ArgVals, getTargetData(), Result))
281    return Result;
282#endif // USE_LIBFFI
283
284  if (F->getName() == "__main")
285    errs() << "Tried to execute an unknown external function: "
286      << F->getType()->getDescription() << " __main\n";
287  else
288    llvm_report_error("Tried to execute an unknown external function: " +
289                      F->getType()->getDescription() + " " +F->getName());
290  return GenericValue();
291}
292
293
294//===----------------------------------------------------------------------===//
295//  Functions "exported" to the running application...
296//
297
298// Visual Studio warns about returning GenericValue in extern "C" linkage
299#ifdef _MSC_VER
300    #pragma warning(disable : 4190)
301#endif
302
303extern "C" {  // Don't add C++ manglings to llvm mangling :)
304
305// void atexit(Function*)
306GenericValue lle_X_atexit(const FunctionType *FT,
307                          const std::vector<GenericValue> &Args) {
308  assert(Args.size() == 1);
309  TheInterpreter->addAtExitHandler((Function*)GVTOP(Args[0]));
310  GenericValue GV;
311  GV.IntVal = 0;
312  return GV;
313}
314
315// void exit(int)
316GenericValue lle_X_exit(const FunctionType *FT,
317                        const std::vector<GenericValue> &Args) {
318  TheInterpreter->exitCalled(Args[0]);
319  return GenericValue();
320}
321
322// void abort(void)
323GenericValue lle_X_abort(const FunctionType *FT,
324                         const std::vector<GenericValue> &Args) {
325  //FIXME: should we report or raise here?
326  //llvm_report_error("Interpreted program raised SIGABRT");
327  raise (SIGABRT);
328  return GenericValue();
329}
330
331// int sprintf(char *, const char *, ...) - a very rough implementation to make
332// output useful.
333GenericValue lle_X_sprintf(const FunctionType *FT,
334                           const std::vector<GenericValue> &Args) {
335  char *OutputBuffer = (char *)GVTOP(Args[0]);
336  const char *FmtStr = (const char *)GVTOP(Args[1]);
337  unsigned ArgNo = 2;
338
339  // printf should return # chars printed.  This is completely incorrect, but
340  // close enough for now.
341  GenericValue GV;
342  GV.IntVal = APInt(32, strlen(FmtStr));
343  while (1) {
344    switch (*FmtStr) {
345    case 0: return GV;             // Null terminator...
346    default:                       // Normal nonspecial character
347      sprintf(OutputBuffer++, "%c", *FmtStr++);
348      break;
349    case '\\': {                   // Handle escape codes
350      sprintf(OutputBuffer, "%c%c", *FmtStr, *(FmtStr+1));
351      FmtStr += 2; OutputBuffer += 2;
352      break;
353    }
354    case '%': {                    // Handle format specifiers
355      char FmtBuf[100] = "", Buffer[1000] = "";
356      char *FB = FmtBuf;
357      *FB++ = *FmtStr++;
358      char Last = *FB++ = *FmtStr++;
359      unsigned HowLong = 0;
360      while (Last != 'c' && Last != 'd' && Last != 'i' && Last != 'u' &&
361             Last != 'o' && Last != 'x' && Last != 'X' && Last != 'e' &&
362             Last != 'E' && Last != 'g' && Last != 'G' && Last != 'f' &&
363             Last != 'p' && Last != 's' && Last != '%') {
364        if (Last == 'l' || Last == 'L') HowLong++;  // Keep track of l's
365        Last = *FB++ = *FmtStr++;
366      }
367      *FB = 0;
368
369      switch (Last) {
370      case '%':
371        strcpy(Buffer, "%"); break;
372      case 'c':
373        sprintf(Buffer, FmtBuf, uint32_t(Args[ArgNo++].IntVal.getZExtValue()));
374        break;
375      case 'd': case 'i':
376      case 'u': case 'o':
377      case 'x': case 'X':
378        if (HowLong >= 1) {
379          if (HowLong == 1 &&
380              TheInterpreter->getTargetData()->getPointerSizeInBits() == 64 &&
381              sizeof(long) < sizeof(int64_t)) {
382            // Make sure we use %lld with a 64 bit argument because we might be
383            // compiling LLI on a 32 bit compiler.
384            unsigned Size = strlen(FmtBuf);
385            FmtBuf[Size] = FmtBuf[Size-1];
386            FmtBuf[Size+1] = 0;
387            FmtBuf[Size-1] = 'l';
388          }
389          sprintf(Buffer, FmtBuf, Args[ArgNo++].IntVal.getZExtValue());
390        } else
391          sprintf(Buffer, FmtBuf,uint32_t(Args[ArgNo++].IntVal.getZExtValue()));
392        break;
393      case 'e': case 'E': case 'g': case 'G': case 'f':
394        sprintf(Buffer, FmtBuf, Args[ArgNo++].DoubleVal); break;
395      case 'p':
396        sprintf(Buffer, FmtBuf, (void*)GVTOP(Args[ArgNo++])); break;
397      case 's':
398        sprintf(Buffer, FmtBuf, (char*)GVTOP(Args[ArgNo++])); break;
399      default:
400        errs() << "<unknown printf code '" << *FmtStr << "'!>";
401        ArgNo++; break;
402      }
403      strcpy(OutputBuffer, Buffer);
404      OutputBuffer += strlen(Buffer);
405      }
406      break;
407    }
408  }
409  return GV;
410}
411
412// int printf(const char *, ...) - a very rough implementation to make output
413// useful.
414GenericValue lle_X_printf(const FunctionType *FT,
415                          const std::vector<GenericValue> &Args) {
416  char Buffer[10000];
417  std::vector<GenericValue> NewArgs;
418  NewArgs.push_back(PTOGV((void*)&Buffer[0]));
419  NewArgs.insert(NewArgs.end(), Args.begin(), Args.end());
420  GenericValue GV = lle_X_sprintf(FT, NewArgs);
421  outs() << Buffer;
422  return GV;
423}
424
425static void ByteswapSCANFResults(LLVMContext &C,
426                                 const char *Fmt, void *Arg0, void *Arg1,
427                                 void *Arg2, void *Arg3, void *Arg4, void *Arg5,
428                                 void *Arg6, void *Arg7, void *Arg8) {
429  void *Args[] = { Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, 0 };
430
431  // Loop over the format string, munging read values as appropriate (performs
432  // byteswaps as necessary).
433  unsigned ArgNo = 0;
434  while (*Fmt) {
435    if (*Fmt++ == '%') {
436      // Read any flag characters that may be present...
437      bool Suppress = false;
438      bool Half = false;
439      bool Long = false;
440      bool LongLong = false;  // long long or long double
441
442      while (1) {
443        switch (*Fmt++) {
444        case '*': Suppress = true; break;
445        case 'a': /*Allocate = true;*/ break;  // We don't need to track this
446        case 'h': Half = true; break;
447        case 'l': Long = true; break;
448        case 'q':
449        case 'L': LongLong = true; break;
450        default:
451          if (Fmt[-1] > '9' || Fmt[-1] < '0')   // Ignore field width specs
452            goto Out;
453        }
454      }
455    Out:
456
457      // Read the conversion character
458      if (!Suppress && Fmt[-1] != '%') { // Nothing to do?
459        unsigned Size = 0;
460        const Type *Ty = 0;
461
462        switch (Fmt[-1]) {
463        case 'i': case 'o': case 'u': case 'x': case 'X': case 'n': case 'p':
464        case 'd':
465          if (Long || LongLong) {
466            Size = 8; Ty = Type::getInt64Ty(C);
467          } else if (Half) {
468            Size = 4; Ty = Type::getInt16Ty(C);
469          } else {
470            Size = 4; Ty = Type::getInt32Ty(C);
471          }
472          break;
473
474        case 'e': case 'g': case 'E':
475        case 'f':
476          if (Long || LongLong) {
477            Size = 8; Ty = Type::getDoubleTy(C);
478          } else {
479            Size = 4; Ty = Type::getFloatTy(C);
480          }
481          break;
482
483        case 's': case 'c': case '[':  // No byteswap needed
484          Size = 1;
485          Ty = Type::getInt8Ty(C);
486          break;
487
488        default: break;
489        }
490
491        if (Size) {
492          GenericValue GV;
493          void *Arg = Args[ArgNo++];
494          memcpy(&GV, Arg, Size);
495          TheInterpreter->StoreValueToMemory(GV, (GenericValue*)Arg, Ty);
496        }
497      }
498    }
499  }
500}
501
502// int sscanf(const char *format, ...);
503GenericValue lle_X_sscanf(const FunctionType *FT,
504                          const std::vector<GenericValue> &args) {
505  assert(args.size() < 10 && "Only handle up to 10 args to sscanf right now!");
506
507  char *Args[10];
508  for (unsigned i = 0; i < args.size(); ++i)
509    Args[i] = (char*)GVTOP(args[i]);
510
511  GenericValue GV;
512  GV.IntVal = APInt(32, sscanf(Args[0], Args[1], Args[2], Args[3], Args[4],
513                        Args[5], Args[6], Args[7], Args[8], Args[9]));
514  ByteswapSCANFResults(FT->getContext(),
515                       Args[1], Args[2], Args[3], Args[4],
516                       Args[5], Args[6], Args[7], Args[8], Args[9], 0);
517  return GV;
518}
519
520// int scanf(const char *format, ...);
521GenericValue lle_X_scanf(const FunctionType *FT,
522                         const std::vector<GenericValue> &args) {
523  assert(args.size() < 10 && "Only handle up to 10 args to scanf right now!");
524
525  char *Args[10];
526  for (unsigned i = 0; i < args.size(); ++i)
527    Args[i] = (char*)GVTOP(args[i]);
528
529  GenericValue GV;
530  GV.IntVal = APInt(32, scanf( Args[0], Args[1], Args[2], Args[3], Args[4],
531                        Args[5], Args[6], Args[7], Args[8], Args[9]));
532  ByteswapSCANFResults(FT->getContext(),
533                       Args[0], Args[1], Args[2], Args[3], Args[4],
534                       Args[5], Args[6], Args[7], Args[8], Args[9]);
535  return GV;
536}
537
538// int fprintf(FILE *, const char *, ...) - a very rough implementation to make
539// output useful.
540GenericValue lle_X_fprintf(const FunctionType *FT,
541                           const std::vector<GenericValue> &Args) {
542  assert(Args.size() >= 2);
543  char Buffer[10000];
544  std::vector<GenericValue> NewArgs;
545  NewArgs.push_back(PTOGV(Buffer));
546  NewArgs.insert(NewArgs.end(), Args.begin()+1, Args.end());
547  GenericValue GV = lle_X_sprintf(FT, NewArgs);
548
549  fputs(Buffer, (FILE *) GVTOP(Args[0]));
550  return GV;
551}
552
553} // End extern "C"
554
555// Done with externals; turn the warning back on
556#ifdef _MSC_VER
557    #pragma warning(default: 4190)
558#endif
559
560
561void Interpreter::initializeExternalFunctions() {
562  sys::ScopedLock Writer(*FunctionsLock);
563  FuncNames["lle_X_atexit"]       = lle_X_atexit;
564  FuncNames["lle_X_exit"]         = lle_X_exit;
565  FuncNames["lle_X_abort"]        = lle_X_abort;
566
567  FuncNames["lle_X_printf"]       = lle_X_printf;
568  FuncNames["lle_X_sprintf"]      = lle_X_sprintf;
569  FuncNames["lle_X_sscanf"]       = lle_X_sscanf;
570  FuncNames["lle_X_scanf"]        = lle_X_scanf;
571  FuncNames["lle_X_fprintf"]      = lle_X_fprintf;
572}
573