Changeset 630 for trunk

Timestamp:

08/15/08 12:39:56 (5 months ago)

Author:

weyrick

Message:

some work on the runtime output buffering and some llvm module work gives us a hello world module

Location:

trunk/rphp

Files:

• compiler/pDriver.cpp (modified) (6 diffs)
• runtime/include/pOutputBuffer.h (modified) (2 diffs)
• runtime/include/pOutputManager.h (modified) (1 diff)
• runtime/include/pRuntime.h (modified) (3 diffs)
• runtime/pOutputManager.cpp (modified) (1 diff)
• runtime/pRuntime.cpp (modified) (5 diffs)

trunk/rphp/compiler/pDriver.cpp

@@ -27 +27 @@
 #include <boost/algorithm/string.hpp>
 
+#include "llvm/GlobalVariable.h"
 #include "llvm/System/DynamicLibrary.h"
 #include "llvm/Bitcode/ReaderWriter.h"
@@ -56 +57 @@
  */
 void pDriver::execute(string fileName) {
-    cout << "executing file: " << fileName << endl;
+    //cout << "executing file: " << fileName << endl;
     // TODO: determine file type, then run executeBC or executePHP
     executeBC(fileName);
@@ -65 +66 @@
  */
 void pDriver::executeBC(string fileName) {
-
-    cout << "executing compiled bytecode: " << fileName << endl;
 
     // Now we create the JIT.
@@ -123 +122 @@
     EE->runStaticConstructorsDestructors(true);
 
-    cout << "module ran, return value is: " << gv.IntVal.toStringSigned(10) << endl;
-
     delete EE;
 
@@ -185 +182 @@
 
     // Create the main function: first create the type 'int ()'
-    llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::Int32Ty, std::vector<const llvm::Type*>(),
+    llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::VoidTy, std::vector<const llvm::Type*>(),
                                         /*not vararg*/false);
 
@@ -196 +193 @@
     llvm::BasicBlock *BB = llvm::BasicBlock::Create("EntryBlock", F);
 
-    // RUNTIME startup/shutdown test
+    // ** STARTUP **
+    // runtime engine pointer type
     const llvm::Type* rEnginePointer = llvm::PointerType::get(llvm::Type::Int8Ty,0);
+
+    // startup function type
     llvm::FunctionType *runtimeStartupFuncType = llvm::FunctionType::get(rEnginePointer, std::vector<const llvm::Type*>(), false);
+    // startup function
     llvm::Function *runtimeStartupFunc = llvm::Function::Create(runtimeStartupFuncType, llvm::Function::ExternalLinkage, "rphp_newRuntimeEngine", M);
-
+    // startup instruction call
     llvm::Instruction *runtimeStartInstr = llvm::CallInst::Create(runtimeStartupFunc, "runtime");
 
+    // ** hello world **
+    llvm::ArrayType* ArrayTy_0 = llvm::ArrayType::get(llvm::IntegerType::get(8), 12);
+    llvm::PointerType* PointerTy_4 = llvm::PointerType::get(llvm::IntegerType::get(8), 0);
+    llvm::GlobalVariable* gvar_array__str = new llvm::GlobalVariable(
+    /*Type=*/ArrayTy_0,
+    /*isConstant=*/true,
+    /*Linkage=*/llvm::GlobalValue::InternalLinkage,
+    /*Initializer=*/0, // has initializer, specified below
+    /*Name=*/".str",
+    M);
+
+    // Constant Definitions
+    llvm::Constant* const_array_7 = llvm::ConstantArray::get("hello world", true);
+    std::vector<llvm::Constant*> const_ptr_8_indices;
+    llvm::Constant* const_int32_9 = llvm::Constant::getNullValue(llvm::IntegerType::get(32));
+    const_ptr_8_indices.push_back(const_int32_9);
+    const_ptr_8_indices.push_back(const_int32_9);
+    llvm::Constant* const_ptr_8 = llvm::ConstantExpr::getGetElementPtr(gvar_array__str, &const_ptr_8_indices[0], const_ptr_8_indices.size() );
+    llvm::UndefValue* const_int32_10 = llvm::UndefValue::get(llvm::IntegerType::get(32));
+
+    // Global Variable Definitions
+    gvar_array__str->setInitializer(const_array_7);
+
+    // argument sig for print function
+    std::vector<const llvm::Type*> printSig;
+    printSig.push_back(rEnginePointer);
+    printSig.push_back(PointerTy_4);
+    // print function type
+    llvm::FunctionType *printFuncType = llvm::FunctionType::get(llvm::Type::VoidTy, printSig, false);
+    // print function
+    llvm::Function *printFunc = llvm::Function::Create(printFuncType, llvm::Function::ExternalLinkage, "rphp_print_cstr", M);
+    // push args
+    std::vector<llvm::Value*> printArgsV;
+    printArgsV.push_back(runtimeStartInstr);
+    printArgsV.push_back(const_ptr_8);
+    // print instruction call
+    llvm::Instruction *printInstr = llvm::CallInst::Create(printFunc, printArgsV.begin(), printArgsV.end());
+
+
+    //  ** SHUTDOWN **
+    // argument sig for shutdown function
     std::vector<const llvm::Type*> engineSig(1, rEnginePointer);
+    // shutdown function type
     llvm::FunctionType *runtimeDeleteFuncType = llvm::FunctionType::get(llvm::Type::VoidTy, engineSig, false);
+    // shutdown function
     llvm::Function *runtimeDeleteFunc = llvm::Function::Create(runtimeDeleteFuncType, llvm::Function::ExternalLinkage, "rphp_deleteRuntimeEngine", M);
 
-    std::vector<llvm::Value*> ArgsV;
-    ArgsV.push_back(runtimeStartInstr);
-
-    llvm::Instruction *runtimeDeleteInstr = llvm::CallInst::Create(runtimeDeleteFunc, ArgsV.begin(), ArgsV.end());
+    // push args
+    std::vector<llvm::Value*> shutdownArgsV;
+    shutdownArgsV.push_back(runtimeStartInstr);
+
+    // shutdown instruction call
+    llvm::Instruction *runtimeDeleteInstr = llvm::CallInst::Create(runtimeDeleteFunc, shutdownArgsV.begin(), shutdownArgsV.end());
 
     // Get pointers to the constant integers...
-    llvm::Value *Two = llvm::ConstantInt::get(llvm::Type::Int32Ty, 2);
-    llvm::Value *Three = llvm::ConstantInt::get(llvm::Type::Int32Ty, 3);
+    //llvm::Value *Two = llvm::ConstantInt::get(llvm::Type::Int32Ty, 2);
+    //llvm::Value *Three = llvm::ConstantInt::get(llvm::Type::Int32Ty, 3);
 
     // Create the add instruction... does not insert...
-    llvm::Instruction *Add = llvm::BinaryOperator::create(llvm::Instruction::Add, Two, Three,
-                                                "addresult");
+    //llvm::Instruction *Add = llvm::BinaryOperator::create(llvm::Instruction::Add, Two, Three, "addresult");
 
     // explicitly insert it into the basic block...
-    BB->getInstList().push_back(Add);
+    //BB->getInstList().push_back(Add);
 
     BB->getInstList().push_back(runtimeStartInstr);
+    BB->getInstList().push_back(printInstr);
     BB->getInstList().push_back(runtimeDeleteInstr);
 
     // Create the return instruction and add it to the basic block
-    BB->getInstList().push_back(llvm::ReturnInst::Create(Add));
+    BB->getInstList().push_back(llvm::ReturnInst::Create());
+    //BB->getInstList().push_back(llvm::ReturnInst::Create(Add));
 
     if (llvm::verifyModule(*M, llvm::PrintMessageAction)) {

trunk/rphp/runtime/include/pOutputBuffer.h

@@ -26 +26 @@
     class pOutputBuffer {
 
-        // default size of a new output buffer
-        // note that for unicode strings, memory space is 2*defBufSize
-        static const std::size_t defBufSize = 512;
+    public:
 
         typedef enum { bufTypeBinary, bufTypeUnicode } bufTypeT;
 
-        private:
-            
-            pUString *uBuffer;
-            pBString *bBuffer;
-            bufTypeT bType;
-
-        public:
-
             // constructors
 
-            // default builds a unicode buffer, default size
-            pOutputBuffer() : uBuffer(new pUString(defBufSize,' ',0)), bType(bufTypeUnicode) { }
-
-            // specify type, default size
-            pOutputBuffer(bufTypeT t) : bType(t) {
+            // specify type
+            pOutputBuffer(bufTypeT t) : bBuffer(0), uBuffer(0), bType(t) {
                 switch (t) {
                     case bufTypeBinary:
-                        bBuffer = new pBString(defBufSize,' ');
+                        bBuffer = new pBString();
                         break;
                     case bufTypeUnicode:
-                        uBuffer = new pUString(defBufSize,' ',0);
-                        break;
-                }
-            }
-
-            // specify type, size
-            pOutputBuffer(bufTypeT t, std::size_t s) : bType(t) {
-                switch (t) {
-                    case bufTypeBinary:
-                        bBuffer = new pBString(s,' ');
-                        break;
-                    case bufTypeUnicode:
-                        uBuffer = new pUString(s,' ',0);
+                        uBuffer = new pUString();
                         break;
                 }
@@ -77 +52 @@
             }
 
+            const char* getRawBuffer() {
+                switch (bType) {
+                    case bufTypeBinary:
+                        return bBuffer->c_str();
+                    case bufTypeUnicode:
+                        return (const char*)uBuffer->getTerminatedBuffer();
+                }
+            }
+
+            void operator<< (const pBString& str) {
+                switch (bType) {
+                    case bufTypeBinary:
+                        bBuffer->append(str);
+                        break;
+                    case bufTypeUnicode:
+                        // TODO: this doesn't seem so efficient. but how often will it be used?
+                        uBuffer->append(pUString(str.c_str(),str.length(), US_INV));
+                        break;
+                }
+            }
+
+            void operator<< (const pUString& str) {
+                if (bType == bufTypeBinary) {
+                    // convert to unicode buffer
+                    uBuffer = new pUString(bBuffer->c_str(), bBuffer->length(), US_INV);
+                    delete bBuffer;
+                }
+                uBuffer->append(str);
+            }
+
+    private:
+
+            pUString *uBuffer;
+            pBString *bBuffer;
+            bufTypeT bType;
+
     };
 

trunk/rphp/runtime/include/pOutputManager.h

@@ -22 +22 @@
 #include <stack>
 #include "pOutputBuffer.h"
+#include "pTypes.h"
 
 namespace rphp {
+
+    class pRuntimeEngine;
 
     class pOutputManager {
 
         private:
-            std::stack<pOutputBuffer> bufferStack;
+            pRuntimeEngine* runtime;
+            std::stack<pOutputBuffer*> bufferStack;
 
         public:
 
             // constructors
-            pOutputManager() {
+            pOutputManager(pRuntimeEngine *r) : runtime(r) {
                 // default output buffer
-                bufferStack.push(pOutputBuffer());
+                // TODO: check the runtime config for which type of default buffer to use
+                bufferStack.push(new pOutputBuffer(pOutputBuffer::bufTypeBinary));
+            }
+
+            ~pOutputManager() {
+                flushAndFreeAll();
+            }
+
+            // flush one or more buffers
+            void flushAndFreeAll();
+
+            // printing to the current buffer
+            void print(pBString str) {
+                if (bufferStack.empty())
+                    return;
+                *bufferStack.top() << str;
+            }
+
+            void print(pUString str) {
+                if (bufferStack.empty())
+                    return;
+                *bufferStack.top() << str;
             }
 

trunk/rphp/runtime/include/pRuntime.h

@@ -31 +31 @@
 
         private:
-
-            // output buffering management
-            pOutputManager* outputManager;
-
             // extension manager
             // --> for loading and registering dynamic extensions (pcre, mysql, etc) and their associated functions, classes
@@ -69 +65 @@
             pFunctionManager* functionManager;
 
+            // output buffering management
+            pOutputManager* outputManager;
+
     };
 
@@ -82 +81 @@
     void rphp_deleteRuntimeEngine(rphp::pRuntimeEngine*);
 
+    // print to runtime output buffer
+    void rphp_print_cstr(rphp::pRuntimeEngine*, char* str);
+
 }
 

trunk/rphp/runtime/pOutputManager.cpp

@@ -17 +17 @@
  * ***** END LICENSE BLOCK ***** */
 
+#include <iostream>
 #include "pOutputManager.h"
 
 namespace rphp {
+
+void pOutputManager::flushAndFreeAll() {
+    while( !bufferStack.empty() ) {
+        std::cout << bufferStack.top()->getRawBuffer();
+        delete bufferStack.top();
+        bufferStack.pop();
+    }
+}
 
 

trunk/rphp/runtime/pRuntime.cpp

@@ -20 +20 @@
 #include "pRuntime.h"
 #include "pExtManager.h"
+#include "pOutputManager.h"
 #include "pFunctionManager.h"
 
@@ -25 +26 @@
 
 pRuntimeEngine::pRuntimeEngine() : extManager(new pExtManager(this)),
-                                   functionManager(new pFunctionManager(this))
+                                   functionManager(new pFunctionManager(this)),
+                                   outputManager(new pOutputManager(this))
 {
-    std::cout << "runtime is starting" << std::endl;
-
     // runtime initialization
     extManager->startUp();
@@ -37 +37 @@
 pRuntimeEngine::~pRuntimeEngine() {
 
-    std::cout << "runtime is shutting down" << std::endl;
-
     // runtime shutdown
+    delete outputManager; // will flush
     delete functionManager;
     delete extManager;
@@ -52 +51 @@
     // create a new runtime engine
     rphp::pRuntimeEngine* rphp_newRuntimeEngine() {
-        std::cout << "in C API runtime now" << std::endl;
         rphp::pRuntimeEngine* rt = new rphp::pRuntimeEngine();
         return rt;
@@ -59 +57 @@
     // destroy runtime engine
     void rphp_deleteRuntimeEngine(rphp::pRuntimeEngine* e) {
-        std::cout << "closing in C API runtime now" << std::endl;
         delete e;
     }
 
+    // print a c string to the current output buffer in the given runtime
+    void rphp_print_cstr(rphp::pRuntimeEngine* e, char* str) {
+        e->outputManager->print(rphp::pBString(str));
+    }
+
+
 }