diff --git a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
index 5b57aa75664..bde32bd2691 100644
--- a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
+++ b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
@@ -11,7 +11,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "Interpreter.h"
+#include "ExecutionAnnotations.h"
 #include "llvm/DerivedTypes.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Target/TargetData.h"
 #include <map>
 #include <dlfcn.h>
 #include <link.h>
@@ -20,6 +23,7 @@
 using std::vector;
 using std::cout;
 
+extern TargetData TD;
 
 typedef GenericValue (*ExFunc)(FunctionType *, const vector<GenericValue> &);
 static std::map<const Function *, ExFunc> Functions;
@@ -175,36 +179,36 @@ PRINT_TYPE_FUNC(Double,  DoubleTyID)
 PRINT_TYPE_FUNC(Pointer, PointerTyID)
 
 
-// void "putchar"(sbyte)
+// void putchar(sbyte)
 GenericValue lle_Vb_putchar(FunctionType *M, const vector<GenericValue> &Args) {
   cout << Args[0].SByteVal;
   return GenericValue();
 }
 
-// int "putchar"(int)
+// int putchar(int)
 GenericValue lle_ii_putchar(FunctionType *M, const vector<GenericValue> &Args) {
   cout << ((char)Args[0].IntVal) << std::flush;
   return Args[0];
 }
 
-// void "putchar"(ubyte)
+// void putchar(ubyte)
 GenericValue lle_VB_putchar(FunctionType *M, const vector<GenericValue> &Args) {
   cout << Args[0].SByteVal << std::flush;
   return Args[0];
 }
 
-// void "__main"()
+// void __main()
 GenericValue lle_V___main(FunctionType *M, const vector<GenericValue> &Args) {
   return GenericValue();
 }
 
-// void "exit"(int)
+// void exit(int)
 GenericValue lle_X_exit(FunctionType *M, const vector<GenericValue> &Args) {
   TheInterpreter->exitCalled(Args[0]);
   return GenericValue();
 }
 
-// void "abort"(void)
+// void abort(void)
 GenericValue lle_X_abort(FunctionType *M, const vector<GenericValue> &Args) {
   std::cerr << "***PROGRAM ABORTED***!\n";
   GenericValue GV;
@@ -417,6 +421,67 @@ GenericValue lle_i_clock(FunctionType *M, const vector<GenericValue> &Args) {
 // IO Functions...
 //===----------------------------------------------------------------------===//
 
+// getFILE - Turn a pointer in the host address space into a legit pointer in
+// the interpreter address space.  For the most part, this is an identity
+// transformation, but if the program refers to stdio, stderr, stdin then they
+// have pointers that are relative to the __iob array.  If this is the case,
+// change the FILE into the REAL stdio stream.
+// 
+static FILE *getFILE(PointerTy Ptr) {
+  static Module *LastMod = 0;
+  static PointerTy IOBBase = 0;
+  static unsigned FILESize;
+
+  if (LastMod != TheInterpreter->getModule()) {  // Module change or initialize?
+    Module *M = LastMod = TheInterpreter->getModule();
+
+    // Check to see if the currently loaded module contains an __iob symbol...
+    GlobalVariable *IOB = 0;
+    if (SymbolTable *ST = M->getSymbolTable()) {
+      for (SymbolTable::iterator I = ST->begin(), E = ST->end(); I != E; ++I) {
+        SymbolTable::VarMap &M = I->second;
+        for (SymbolTable::VarMap::iterator J = M.begin(), E = M.end();
+             J != E; ++J)
+          if (J->first == "__iob")
+            if ((IOB = dyn_cast<GlobalVariable>(J->second)))
+              break;
+        if (IOB) break;
+      }
+    }
+
+    // If we found an __iob symbol now, find out what the actual address it's
+    // held in is...
+    if (IOB) {
+      // Get the address the array lives in...
+      GlobalAddress *Address = 
+        (GlobalAddress*)IOB->getOrCreateAnnotation(GlobalAddressAID);
+      IOBBase = (PointerTy)(GenericValue*)Address->Ptr;
+
+      // Figure out how big each element of the array is...
+      const ArrayType *AT =
+        dyn_cast<ArrayType>(IOB->getType()->getElementType());
+      if (AT)
+        FILESize = TD.getTypeSize(AT->getElementType());
+      else
+        FILESize = 16*8;  // Default size
+    }
+  }
+
+  // Check to see if this is a reference to __iob...
+  if (IOBBase) {
+    unsigned FDNum = (Ptr-IOBBase)/FILESize;
+    if (FDNum == 0)
+      return stdin;
+    else if (FDNum == 1)
+      return stdout;
+    else if (FDNum == 2)
+      return stderr;
+  }
+
+  return (FILE*)Ptr;
+}
+
+
 // FILE *fopen(const char *filename, const char *mode);
 GenericValue lle_X_fopen(FunctionType *M, const vector<GenericValue> &Args) {
   assert(Args.size() == 2);
@@ -432,7 +497,7 @@ GenericValue lle_X_fclose(FunctionType *M, const vector<GenericValue> &Args) {
   assert(Args.size() == 1);
   GenericValue GV;
 
-  GV.IntVal = fclose((FILE *)Args[0].PointerVal);
+  GV.IntVal = fclose(getFILE(Args[0].PointerVal));
   return GV;
 }
 
@@ -442,7 +507,7 @@ GenericValue lle_X_fread(FunctionType *M, const vector<GenericValue> &Args) {
   GenericValue GV;
 
   GV.UIntVal = fread((void*)Args[0].PointerVal, Args[1].UIntVal,
-                     Args[2].UIntVal, (FILE*)Args[3].PointerVal);
+                     Args[2].UIntVal, getFILE(Args[3].PointerVal));
   return GV;
 }
 
@@ -452,7 +517,7 @@ GenericValue lle_X_fwrite(FunctionType *M, const vector<GenericValue> &Args) {
   GenericValue GV;
 
   GV.UIntVal = fwrite((void*)Args[0].PointerVal, Args[1].UIntVal,
-                      Args[2].UIntVal, (FILE*)Args[3].PointerVal);
+                      Args[2].UIntVal, getFILE(Args[3].PointerVal));
   return GV;
 }
 
@@ -462,7 +527,7 @@ GenericValue lle_X_fgets(FunctionType *M, const vector<GenericValue> &Args) {
   GenericValue GV;
 
   GV.PointerVal = (PointerTy)fgets((char*)Args[0].PointerVal, Args[1].IntVal,
-                                   (FILE*)Args[2].PointerVal);
+                                   getFILE(Args[2].PointerVal));
   return GV;
 }
 
@@ -471,7 +536,16 @@ GenericValue lle_X_fflush(FunctionType *M, const vector<GenericValue> &Args) {
   assert(Args.size() == 1);
   GenericValue GV;
 
-  GV.IntVal = fflush((FILE*)Args[0].PointerVal);
+  GV.IntVal = fflush(getFILE(Args[0].PointerVal));
+  return GV;
+}
+
+// int getc(FILE *stream);
+GenericValue lle_X_getc(FunctionType *M, const vector<GenericValue> &Args) {
+  assert(Args.size() == 1);
+  GenericValue GV;
+
+  GV.IntVal = getc(getFILE(Args[0].PointerVal));
   return GV;
 }
 
@@ -522,4 +596,5 @@ void Interpreter::initializeExternalMethods() {
   FuncNames["lle_X_fwrite"]       = lle_X_fwrite;
   FuncNames["lle_X_fgets"]        = lle_X_fgets;
   FuncNames["lle_X_fflush"]       = lle_X_fflush;
+  FuncNames["lle_X_getc"]         = lle_X_getc;
 }