1 //===-- ExternalFunctions.cpp - Implement External Functions --------------===//
2 //
3 //  This file contains both code to deal with invoking "external" functions, but
4 //  also contains code that implements "exported" external functions.
5 //
6 //  External functions in LLI are implemented by dlopen'ing the lli executable
7 //  and using dlsym to look op the functions that we want to invoke.  If a
8 //  function is found, then the arguments are mangled and passed in to the
9 //  function call.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "Interpreter.h"
14 #include "llvm/DerivedTypes.h"
15 #include <map>
16 #include <dlfcn.h>
17 #include <iostream>
18 #include <link.h>
19 #include <math.h>
20 #include <stdio.h>
21 using std::vector;
22 using std::cout;
23 
24 
25 typedef GenericValue (*ExFunc)(FunctionType *, const vector<GenericValue> &);
26 static std::map<const Function *, ExFunc> Functions;
27 static std::map<std::string, ExFunc> FuncNames;
28 
29 static Interpreter *TheInterpreter;
30 
31 // getCurrentExecutablePath() - Return the directory that the lli executable
32 // lives in.
33 //
34 std::string Interpreter::getCurrentExecutablePath() const {
35   Dl_info Info;
36   if (dladdr(&TheInterpreter, &Info) == 0) return "";
37 
38   std::string LinkAddr(Info.dli_fname);
39   unsigned SlashPos = LinkAddr.rfind('/');
40   if (SlashPos != std::string::npos)
41     LinkAddr.resize(SlashPos);    // Trim the executable name off...
42 
43   return LinkAddr;
44 }
45 
46 
47 static char getTypeID(const Type *Ty) {
48   switch (Ty->getPrimitiveID()) {
49   case Type::VoidTyID:    return 'V';
50   case Type::BoolTyID:    return 'o';
51   case Type::UByteTyID:   return 'B';
52   case Type::SByteTyID:   return 'b';
53   case Type::UShortTyID:  return 'S';
54   case Type::ShortTyID:   return 's';
55   case Type::UIntTyID:    return 'I';
56   case Type::IntTyID:     return 'i';
57   case Type::ULongTyID:   return 'L';
58   case Type::LongTyID:    return 'l';
59   case Type::FloatTyID:   return 'F';
60   case Type::DoubleTyID:  return 'D';
61   case Type::PointerTyID: return 'P';
62   case Type::FunctionTyID:  return 'M';
63   case Type::StructTyID:  return 'T';
64   case Type::ArrayTyID:   return 'A';
65   case Type::OpaqueTyID:  return 'O';
66   default: return 'U';
67   }
68 }
69 
70 static ExFunc lookupFunction(const Function *M) {
71   // Function not found, look it up... start by figuring out what the
72   // composite function name should be.
73   std::string ExtName = "lle_";
74   const FunctionType *MT = M->getFunctionType();
75   for (unsigned i = 0; const Type *Ty = MT->getContainedType(i); ++i)
76     ExtName += getTypeID(Ty);
77   ExtName += "_" + M->getName();
78 
79   //cout << "Tried: '" << ExtName << "'\n";
80   ExFunc FnPtr = FuncNames[ExtName];
81   if (FnPtr == 0)
82     FnPtr = (ExFunc)dlsym(RTLD_DEFAULT, ExtName.c_str());
83   if (FnPtr == 0)
84     FnPtr = FuncNames["lle_X_"+M->getName()];
85   if (FnPtr == 0)  // Try calling a generic function... if it exists...
86     FnPtr = (ExFunc)dlsym(RTLD_DEFAULT, ("lle_X_"+M->getName()).c_str());
87   if (FnPtr != 0)
88     Functions.insert(std::make_pair(M, FnPtr));  // Cache for later
89   return FnPtr;
90 }
91 
92 GenericValue Interpreter::callExternalMethod(Function *M,
93                                          const vector<GenericValue> &ArgVals) {
94   TheInterpreter = this;
95 
96   // Do a lookup to see if the function is in our cache... this should just be a
97   // defered annotation!
98   std::map<const Function *, ExFunc>::iterator FI = Functions.find(M);
99   ExFunc Fn = (FI == Functions.end()) ? lookupFunction(M) : FI->second;
100   if (Fn == 0) {
101     cout << "Tried to execute an unknown external function: "
102 	 << M->getType()->getDescription() << " " << M->getName() << "\n";
103     return GenericValue();
104   }
105 
106   // TODO: FIXME when types are not const!
107   GenericValue Result = Fn(const_cast<FunctionType*>(M->getFunctionType()),
108                            ArgVals);
109   return Result;
110 }
111 
112 
113 //===----------------------------------------------------------------------===//
114 //  Functions "exported" to the running application...
115 //
116 extern "C" {  // Don't add C++ manglings to llvm mangling :)
117 
118 // Implement void printstr([ubyte {x N}] *)
119 GenericValue lle_VP_printstr(FunctionType *M, const vector<GenericValue> &ArgVal){
120   assert(ArgVal.size() == 1 && "printstr only takes one argument!");
121   cout << (char*)ArgVal[0].PointerVal;
122   return GenericValue();
123 }
124 
125 // Implement 'void print(X)' for every type...
126 GenericValue lle_X_print(FunctionType *M, const vector<GenericValue> &ArgVals) {
127   assert(ArgVals.size() == 1 && "generic print only takes one argument!");
128 
129   Interpreter::print(M->getParamTypes()[0], ArgVals[0]);
130   return GenericValue();
131 }
132 
133 // Implement 'void printVal(X)' for every type...
134 GenericValue lle_X_printVal(FunctionType *M, const vector<GenericValue> &ArgVal) {
135   assert(ArgVal.size() == 1 && "generic print only takes one argument!");
136 
137   // Specialize print([ubyte {x N} ] *) and print(sbyte *)
138   if (PointerType *PTy = dyn_cast<PointerType>(M->getParamTypes()[0].get()))
139     if (PTy->getElementType() == Type::SByteTy ||
140         isa<ArrayType>(PTy->getElementType())) {
141       return lle_VP_printstr(M, ArgVal);
142     }
143 
144   Interpreter::printValue(M->getParamTypes()[0], ArgVal[0]);
145   return GenericValue();
146 }
147 
148 // Implement 'void printString(X)'
149 // Argument must be [ubyte {x N} ] * or sbyte *
150 GenericValue lle_X_printString(FunctionType *M, const vector<GenericValue> &ArgVal) {
151   assert(ArgVal.size() == 1 && "generic print only takes one argument!");
152   return lle_VP_printstr(M, ArgVal);
153 }
154 
155 // Implement 'void print<TYPE>(X)' for each primitive type or pointer type
156 #define PRINT_TYPE_FUNC(TYPENAME,TYPEID) \
157   GenericValue lle_X_print##TYPENAME(FunctionType *M,\
158                                      const vector<GenericValue> &ArgVal) {\
159     assert(ArgVal.size() == 1 && "generic print only takes one argument!");\
160     assert(M->getParamTypes()[0].get()->getPrimitiveID() == Type::TYPEID);\
161     Interpreter::printValue(M->getParamTypes()[0], ArgVal[0]);\
162     return GenericValue();\
163   }
164 
165 PRINT_TYPE_FUNC(SByte,   SByteTyID)
166 PRINT_TYPE_FUNC(UByte,   UByteTyID)
167 PRINT_TYPE_FUNC(Short,   ShortTyID)
168 PRINT_TYPE_FUNC(UShort,  UShortTyID)
169 PRINT_TYPE_FUNC(Int,     IntTyID)
170 PRINT_TYPE_FUNC(UInt,    UIntTyID)
171 PRINT_TYPE_FUNC(Long,    LongTyID)
172 PRINT_TYPE_FUNC(ULong,   ULongTyID)
173 PRINT_TYPE_FUNC(Float,   FloatTyID)
174 PRINT_TYPE_FUNC(Double,  DoubleTyID)
175 PRINT_TYPE_FUNC(Pointer, PointerTyID)
176 
177 
178 // void "putchar"(sbyte)
179 GenericValue lle_Vb_putchar(FunctionType *M, const vector<GenericValue> &Args) {
180   cout << Args[0].SByteVal;
181   return GenericValue();
182 }
183 
184 // int "putchar"(int)
185 GenericValue lle_ii_putchar(FunctionType *M, const vector<GenericValue> &Args) {
186   cout << ((char)Args[0].IntVal) << std::flush;
187   return Args[0];
188 }
189 
190 // void "putchar"(ubyte)
191 GenericValue lle_VB_putchar(FunctionType *M, const vector<GenericValue> &Args) {
192   cout << Args[0].SByteVal << std::flush;
193   return Args[0];
194 }
195 
196 // void "__main"()
197 GenericValue lle_V___main(FunctionType *M, const vector<GenericValue> &Args) {
198   return GenericValue();
199 }
200 
201 // void "exit"(int)
202 GenericValue lle_X_exit(FunctionType *M, const vector<GenericValue> &Args) {
203   TheInterpreter->exitCalled(Args[0]);
204   return GenericValue();
205 }
206 
207 // void "abort"(void)
208 GenericValue lle_X_abort(FunctionType *M, const vector<GenericValue> &Args) {
209   std::cerr << "***PROGRAM ABORTED***!\n";
210   GenericValue GV;
211   GV.IntVal = 1;
212   TheInterpreter->exitCalled(GV);
213   return GenericValue();
214 }
215 
216 // void *malloc(uint)
217 GenericValue lle_X_malloc(FunctionType *M, const vector<GenericValue> &Args) {
218   assert(Args.size() == 1 && "Malloc expects one argument!");
219   GenericValue GV;
220   GV.PointerVal = (PointerTy)malloc(Args[0].UIntVal);
221   return GV;
222 }
223 
224 // void free(void *)
225 GenericValue lle_X_free(FunctionType *M, const vector<GenericValue> &Args) {
226   assert(Args.size() == 1);
227   free((void*)Args[0].PointerVal);
228   return GenericValue();
229 }
230 
231 // int atoi(char *)
232 GenericValue lle_X_atoi(FunctionType *M, const vector<GenericValue> &Args) {
233   assert(Args.size() == 1);
234   GenericValue GV;
235   GV.IntVal = atoi((char*)Args[0].PointerVal);
236   return GV;
237 }
238 
239 // double pow(double, double)
240 GenericValue lle_X_pow(FunctionType *M, const vector<GenericValue> &Args) {
241   assert(Args.size() == 2);
242   GenericValue GV;
243   GV.DoubleVal = pow(Args[0].DoubleVal, Args[1].DoubleVal);
244   return GV;
245 }
246 
247 // double exp(double)
248 GenericValue lle_X_exp(FunctionType *M, const vector<GenericValue> &Args) {
249   assert(Args.size() == 1);
250   GenericValue GV;
251   GV.DoubleVal = exp(Args[0].DoubleVal);
252   return GV;
253 }
254 
255 // double sqrt(double)
256 GenericValue lle_X_sqrt(FunctionType *M, const vector<GenericValue> &Args) {
257   assert(Args.size() == 1);
258   GenericValue GV;
259   GV.DoubleVal = sqrt(Args[0].DoubleVal);
260   return GV;
261 }
262 
263 // double log(double)
264 GenericValue lle_X_log(FunctionType *M, const vector<GenericValue> &Args) {
265   assert(Args.size() == 1);
266   GenericValue GV;
267   GV.DoubleVal = log(Args[0].DoubleVal);
268   return GV;
269 }
270 
271 // double floor(double)
272 GenericValue lle_X_floor(FunctionType *M, const vector<GenericValue> &Args) {
273   assert(Args.size() == 1);
274   GenericValue GV;
275   GV.DoubleVal = floor(Args[0].DoubleVal);
276   return GV;
277 }
278 
279 // double drand48()
280 GenericValue lle_X_drand48(FunctionType *M, const vector<GenericValue> &Args) {
281   assert(Args.size() == 0);
282   GenericValue GV;
283   GV.DoubleVal = drand48();
284   return GV;
285 }
286 
287 // long lrand48()
288 GenericValue lle_X_lrand48(FunctionType *M, const vector<GenericValue> &Args) {
289   assert(Args.size() == 0);
290   GenericValue GV;
291   GV.IntVal = lrand48();
292   return GV;
293 }
294 
295 // void srand48(long)
296 GenericValue lle_X_srand48(FunctionType *M, const vector<GenericValue> &Args) {
297   assert(Args.size() == 1);
298   srand48(Args[0].IntVal);
299   return GenericValue();
300 }
301 
302 // void srand(uint)
303 GenericValue lle_X_srand(FunctionType *M, const vector<GenericValue> &Args) {
304   assert(Args.size() == 1);
305   srand(Args[0].UIntVal);
306   return GenericValue();
307 }
308 
309 // int sprintf(sbyte *, sbyte *, ...) - a very rough implementation to make
310 // output useful.
311 GenericValue lle_X_sprintf(FunctionType *M, const vector<GenericValue> &Args) {
312   char *OutputBuffer = (char *)Args[0].PointerVal;
313   const char *FmtStr = (const char *)Args[1].PointerVal;
314   unsigned ArgNo = 2;
315 
316   // printf should return # chars printed.  This is completely incorrect, but
317   // close enough for now.
318   GenericValue GV; GV.IntVal = strlen(FmtStr);
319   while (1) {
320     switch (*FmtStr) {
321     case 0: return GV;             // Null terminator...
322     default:                       // Normal nonspecial character
323       sprintf(OutputBuffer++, "%c", *FmtStr++);
324       break;
325     case '\\': {                   // Handle escape codes
326       sprintf(OutputBuffer, "%c%c", *FmtStr, *(FmtStr+1));
327       FmtStr += 2; OutputBuffer += 2;
328       break;
329     }
330     case '%': {                    // Handle format specifiers
331       char FmtBuf[100] = "", Buffer[1000] = "";
332       char *FB = FmtBuf;
333       *FB++ = *FmtStr++;
334       char Last = *FB++ = *FmtStr++;
335       unsigned HowLong = 0;
336       while (Last != 'c' && Last != 'd' && Last != 'i' && Last != 'u' &&
337              Last != 'o' && Last != 'x' && Last != 'X' && Last != 'e' &&
338              Last != 'E' && Last != 'g' && Last != 'G' && Last != 'f' &&
339              Last != 'p' && Last != 's' && Last != '%') {
340         if (Last == 'l' || Last == 'L') HowLong++;  // Keep track of l's
341         Last = *FB++ = *FmtStr++;
342       }
343       *FB = 0;
344 
345       switch (Last) {
346       case '%':
347         sprintf(Buffer, FmtBuf); break;
348       case 'c':
349         sprintf(Buffer, FmtBuf, Args[ArgNo++].IntVal); break;
350       case 'd': case 'i':
351       case 'u': case 'o':
352       case 'x': case 'X':
353         if (HowLong == 2)
354           sprintf(Buffer, FmtBuf, Args[ArgNo++].ULongVal);
355         else
356           sprintf(Buffer, FmtBuf, Args[ArgNo++].IntVal); break;
357       case 'e': case 'E': case 'g': case 'G': case 'f':
358         sprintf(Buffer, FmtBuf, Args[ArgNo++].DoubleVal); break;
359       case 'p':
360         sprintf(Buffer, FmtBuf, (void*)Args[ArgNo++].PointerVal); break;
361       case 's':
362         sprintf(Buffer, FmtBuf, (char*)Args[ArgNo++].PointerVal); break;
363       default:  cout << "<unknown printf code '" << *FmtStr << "'!>";
364         ArgNo++; break;
365       }
366       strcpy(OutputBuffer, Buffer);
367       OutputBuffer += strlen(Buffer);
368       }
369       break;
370     }
371   }
372 }
373 
374 // int printf(sbyte *, ...) - a very rough implementation to make output useful.
375 GenericValue lle_X_printf(FunctionType *M, const vector<GenericValue> &Args) {
376   char Buffer[10000];
377   vector<GenericValue> NewArgs;
378   GenericValue GV; GV.PointerVal = (PointerTy)Buffer;
379   NewArgs.push_back(GV);
380   NewArgs.insert(NewArgs.end(), Args.begin(), Args.end());
381   GV = lle_X_sprintf(M, NewArgs);
382   cout << Buffer;
383   return GV;
384 }
385 
386 // int sscanf(const char *format, ...);
387 GenericValue lle_X_sscanf(FunctionType *M, const vector<GenericValue> &args) {
388   assert(args.size() < 10 && "Only handle up to 10 args to sscanf right now!");
389 
390   const char *Args[10];
391   for (unsigned i = 0; i < args.size(); ++i)
392     Args[i] = (const char*)args[i].PointerVal;
393 
394   GenericValue GV;
395   GV.IntVal = sscanf(Args[0], Args[1], Args[2], Args[3], Args[4],
396                      Args[5], Args[6], Args[7], Args[8], Args[9]);
397   return GV;
398 }
399 
400 
401 // int clock(void) - Profiling implementation
402 GenericValue lle_i_clock(FunctionType *M, const vector<GenericValue> &Args) {
403   extern int clock(void);
404   GenericValue GV; GV.IntVal = clock();
405   return GV;
406 }
407 
408 //===----------------------------------------------------------------------===//
409 // IO Functions...
410 //===----------------------------------------------------------------------===//
411 
412 // FILE *fopen(const char *filename, const char *mode);
413 GenericValue lle_X_fopen(FunctionType *M, const vector<GenericValue> &Args) {
414   assert(Args.size() == 2);
415   GenericValue GV;
416 
417   GV.PointerVal = (PointerTy)fopen((const char *)Args[0].PointerVal,
418                                    (const char *)Args[1].PointerVal);
419   return GV;
420 }
421 
422 // int fclose(FILE *F);
423 GenericValue lle_X_fclose(FunctionType *M, const vector<GenericValue> &Args) {
424   assert(Args.size() == 1);
425   GenericValue GV;
426 
427   GV.IntVal = fclose((FILE *)Args[0].PointerVal);
428   return GV;
429 }
430 
431 // size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
432 GenericValue lle_X_fread(FunctionType *M, const vector<GenericValue> &Args) {
433   assert(Args.size() == 4);
434   GenericValue GV;
435 
436   GV.UIntVal = fread((void*)Args[0].PointerVal, Args[1].UIntVal,
437                      Args[2].UIntVal, (FILE*)Args[3].PointerVal);
438   return GV;
439 }
440 
441 // size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
442 GenericValue lle_X_fwrite(FunctionType *M, const vector<GenericValue> &Args) {
443   assert(Args.size() == 4);
444   GenericValue GV;
445 
446   GV.UIntVal = fwrite((void*)Args[0].PointerVal, Args[1].UIntVal,
447                       Args[2].UIntVal, (FILE*)Args[3].PointerVal);
448   return GV;
449 }
450 
451 // char *fgets(char *s, int n, FILE *stream);
452 GenericValue lle_X_fgets(FunctionType *M, const vector<GenericValue> &Args) {
453   assert(Args.size() == 3);
454   GenericValue GV;
455 
456   GV.PointerVal = (PointerTy)fgets((char*)Args[0].PointerVal, Args[1].IntVal,
457                                    (FILE*)Args[2].PointerVal);
458   return GV;
459 }
460 
461 // int fflush(FILE *stream);
462 GenericValue lle_X_fflush(FunctionType *M, const vector<GenericValue> &Args) {
463   assert(Args.size() == 1);
464   GenericValue GV;
465 
466   GV.IntVal = fflush((FILE*)Args[0].PointerVal);
467   return GV;
468 }
469 
470 } // End extern "C"
471 
472 
473 void Interpreter::initializeExternalMethods() {
474   FuncNames["lle_VP_printstr"] = lle_VP_printstr;
475   FuncNames["lle_X_print"] = lle_X_print;
476   FuncNames["lle_X_printVal"] = lle_X_printVal;
477   FuncNames["lle_X_printString"] = lle_X_printString;
478   FuncNames["lle_X_printUByte"] = lle_X_printUByte;
479   FuncNames["lle_X_printSByte"] = lle_X_printSByte;
480   FuncNames["lle_X_printUShort"] = lle_X_printUShort;
481   FuncNames["lle_X_printShort"] = lle_X_printShort;
482   FuncNames["lle_X_printInt"] = lle_X_printInt;
483   FuncNames["lle_X_printUInt"] = lle_X_printUInt;
484   FuncNames["lle_X_printLong"] = lle_X_printLong;
485   FuncNames["lle_X_printULong"] = lle_X_printULong;
486   FuncNames["lle_X_printFloat"] = lle_X_printFloat;
487   FuncNames["lle_X_printDouble"] = lle_X_printDouble;
488   FuncNames["lle_X_printPointer"] = lle_X_printPointer;
489   FuncNames["lle_Vb_putchar"]     = lle_Vb_putchar;
490   FuncNames["lle_ii_putchar"]     = lle_ii_putchar;
491   FuncNames["lle_VB_putchar"]     = lle_VB_putchar;
492   FuncNames["lle_V___main"]       = lle_V___main;
493   FuncNames["lle_X_exit"]         = lle_X_exit;
494   FuncNames["lle_X_abort"]        = lle_X_abort;
495   FuncNames["lle_X_malloc"]       = lle_X_malloc;
496   FuncNames["lle_X_free"]         = lle_X_free;
497   FuncNames["lle_X_atoi"]         = lle_X_atoi;
498   FuncNames["lle_X_pow"]          = lle_X_pow;
499   FuncNames["lle_X_exp"]          = lle_X_exp;
500   FuncNames["lle_X_log"]          = lle_X_log;
501   FuncNames["lle_X_floor"]        = lle_X_floor;
502   FuncNames["lle_X_srand"]        = lle_X_srand;
503   FuncNames["lle_X_drand48"]      = lle_X_drand48;
504   FuncNames["lle_X_srand48"]      = lle_X_srand48;
505   FuncNames["lle_X_lrand48"]      = lle_X_lrand48;
506   FuncNames["lle_X_sqrt"]         = lle_X_sqrt;
507   FuncNames["lle_X_printf"]       = lle_X_printf;
508   FuncNames["lle_X_sprintf"]      = lle_X_sprintf;
509   FuncNames["lle_X_sscanf"]       = lle_X_sscanf;
510   FuncNames["lle_i_clock"]        = lle_i_clock;
511   FuncNames["lle_X_fopen"]        = lle_X_fopen;
512   FuncNames["lle_X_fclose"]       = lle_X_fclose;
513   FuncNames["lle_X_fread"]        = lle_X_fread;
514   FuncNames["lle_X_fwrite"]       = lle_X_fwrite;
515   FuncNames["lle_X_fgets"]        = lle_X_fgets;
516   FuncNames["lle_X_fflush"]       = lle_X_fflush;
517 }
518