nlopess		Thu Oct 23 14:12:09 2008 UTC

  Modified files:              
    /pecl/llvm	phpllvm.cpp phpllvm_compile.cpp phpllvm_execute.cpp 
              	phpllvm_execute.h 
  Log:
  fix execute data padding
  fix some typos in the execute data struct dumping, it isnt fully working, though
  use the new raw_ostream API instead of std::ostream
  remove some useless TSRMLS_D/C
  
http://cvs.php.net/viewvc.cgi/pecl/llvm/phpllvm.cpp?r1=1.7&r2=1.8&diff_format=u
Index: pecl/llvm/phpllvm.cpp
diff -u pecl/llvm/phpllvm.cpp:1.7 pecl/llvm/phpllvm.cpp:1.8
--- pecl/llvm/phpllvm.cpp:1.7	Tue Jul 29 00:54:51 2008
+++ pecl/llvm/phpllvm.cpp	Thu Oct 23 14:12:09 2008
@@ -62,10 +62,10 @@
 
 	REGISTER_INI_ENTRIES();
 
-	init_jit_engine(NULL TSRMLS_CC);
+	init_jit_engine(NULL);
 
 	if (INI_BOOL("phpllvm.active"))
-		override_executor(TSRMLS_C);
+		override_executor();
 
 	return SUCCESS;
 }
@@ -74,12 +74,12 @@
 static PHP_MSHUTDOWN_FUNCTION(phpllvm)
 {
 	if (INI_BOOL("phpllvm.active"))
-		restore_executor(TSRMLS_C);
+		restore_executor();
 
 	UNREGISTER_INI_ENTRIES();
 
 	save_module(TEMP_FILE);
-	destroy_jit_engine(TSRMLS_C);
+	destroy_jit_engine();
 
 	return SUCCESS;
 }
@@ -96,7 +96,7 @@
 static PHP_MINFO_FUNCTION(phpllvm)
 {
 	php_info_print_table_start();
-	php_info_print_table_row(2, "Revision", "$Revision: 1.7 $");
+	php_info_print_table_row(2, "Revision", "$Revision: 1.8 $");
 	php_info_print_table_row(2, "LLVM version", getLLVMString());
 	php_info_print_table_end();
 
http://cvs.php.net/viewvc.cgi/pecl/llvm/phpllvm_compile.cpp?r1=1.18&r2=1.19&diff_format=u
Index: pecl/llvm/phpllvm_compile.cpp
diff -u pecl/llvm/phpllvm_compile.cpp:1.18 pecl/llvm/phpllvm_compile.cpp:1.19
--- pecl/llvm/phpllvm_compile.cpp:1.18	Sat Aug  9 15:17:00 2008
+++ pecl/llvm/phpllvm_compile.cpp	Thu Oct 23 14:12:09 2008
@@ -305,6 +305,14 @@
 	return process_oparray;
 }
 
+
+static void add_padding(std::vector<Constant*> &v, unsigned bytes)
+{
+	for (unsigned i = 0; i < bytes; ++i) {
+		v.push_back(ConstantInt::get(Type::Int8Ty, 0));
+	}
+}
+
 static GlobalVariable* dump_class_entry(zend_class_entry* class_entry, Module* mod) {
 	const Type* class_entry_type = mod->getTypeByName(STRUCT("zend_class_entry"));
 
@@ -498,10 +506,7 @@
 		op_members.push_back(ConstantInt::get(Type::Int8Ty, opcodes[i].opcode));
 
 #ifdef COMPILED_WITH_CLANG
-		// clang adds some padding
-		for (uint i = 0; i < 3; ++i) {
-			op_members.push_back(ConstantInt::get(Type::Int8Ty, 0));
-		}
+		add_padding(op_members, 3);
 #endif
 
 		ops.push_back(ConstantStruct::get(op_type, op_members));
@@ -581,11 +586,12 @@
 }
 
 static GlobalVariable* dump_try_catch_array(zend_try_catch_element* elements, int count, Module* mod) {
-	const StructType* try_catch_element_type = cast<const StructType>(mod->getTypeByName(STRUCT("zend_try_catch_element")));
+	const StructType* try_catch_element_type = cast<const StructType>(mod->getTypeByName(STRUCT("zend_label")));
+	const Type* uint_type = Type::Int32Ty; // TODO: adjust this automatically
 
 	std::vector<Constant*> members;
 
-	for(int i = 0; i < count; i++) {
+	for (int i = 0; i < count; ++i) {
 		// typedef struct _zend_try_catch_element {
 		// 	zend_uint try_op;
 		// 	zend_uint catch_op;  /* ketchup! */
@@ -594,8 +600,8 @@
 
 		std::vector<Constant*> element_members;
 
-		element_members.push_back(ConstantInt::get(Type::Int32Ty, elements[i].try_op));
-		element_members.push_back(ConstantInt::get(Type::Int32Ty, elements[i].catch_op));
+		element_members.push_back(ConstantInt::get(uint_type, elements[i].try_op));
+		element_members.push_back(ConstantInt::get(uint_type, elements[i].catch_op));
 
 		members.push_back(ConstantStruct::get(try_catch_element_type, element_members));
 	}
@@ -618,14 +624,15 @@
 
 static GlobalVariable* dump_op_array(zend_op_array* op_array, Module* mod, ExecutionEngine* engine) {
 	const StructType* op_array_type = cast<const StructType>(mod->getTypeByName(STRUCT("zend_op_array")));
-	const Type* class_entry_type = mod->getTypeByName(STRUCT("zend_class_entry"));
-	const Type* function_type = mod->getTypeByName(UNION("zend_function"));
 	const Type* arg_info_type = mod->getTypeByName(STRUCT("zend_arg_info"));
-	const Type* compiled_variable_type = mod->getTypeByName(STRUCT("zend_compiled_variable"));
 	const Type* brk_cont_element_type = mod->getTypeByName(STRUCT("zend_brk_cont_element"));
-	const Type* try_catch_element_type = mod->getTypeByName(STRUCT("zend_try_catch_element"));
-	const Type* hashtable_type = mod->getTypeByName(STRUCT("HashTable"));
+	const Type* class_entry_type = mod->getTypeByName(STRUCT("zend_class_entry"));
+	const Type* compiled_variable_type = mod->getTypeByName(STRUCT("zend_compiled_variable"));
+	const Type* function_type = mod->getTypeByName(UNION("zend_function"));
+	const Type* hashtable_type = mod->getTypeByName(STRUCT("hashtable"));
+	const Type* label_type = mod->getTypeByName(STRUCT("zend_label"));
 	const Type* op_type = mod->getTypeByName(STRUCT("zend_op"));
+	const Type* uint_type = Type::Int32Ty; // TODO: adjust this automatically
 
 	std::vector<Constant*> members;
 
@@ -633,42 +640,47 @@
 
 	// zend_uchar type;
 	members.push_back(ConstantInt::get(Type::Int8Ty, op_array->type));
+	add_padding(members, 3);
 
 	// char *function_name;
 	if (op_array->function_name) {
 		Constant* string = ConstantArray::get(op_array->function_name);
 		GlobalVariable* var = new GlobalVariable(string->getType(), true, GlobalValue::InternalLinkage, string, "function_name", mod);
 		members.push_back(ConstantExpr::getGetElementPtr(var, &zero_indices[0], 2));
-	} else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(Type::Int8Ty)));
+	}
 
 	// zend_class_entry *scope;
-	if (op_array->scope)
+	if (op_array->scope) {
 		members.push_back(dump_class_entry(op_array->scope, mod));
-	else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(class_entry_type)));
+	}
 
 	// zend_uint fn_flags;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->fn_flags));
+	members.push_back(ConstantInt::get(uint_type, op_array->fn_flags));
 
 	// union _zend_function *prototype;
-	if (op_array->prototype)
+	if (op_array->prototype) {
 		members.push_back(dump_function(op_array->prototype, mod));
-	else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(function_type)));
+	}
 
 	// zend_uint num_args;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->num_args));
+	members.push_back(ConstantInt::get(uint_type, op_array->num_args));
 
 	// zend_uint required_num_args;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->num_args));
+	members.push_back(ConstantInt::get(uint_type, op_array->num_args));
 
 	// zend_arg_info *arg_info;
-	if (op_array->prototype) {
+	if (op_array->arg_info) {
 		GlobalVariable* var = dump_arg_info_array(op_array->arg_info, op_array->num_args, mod);
 		members.push_back(ConstantExpr::getGetElementPtr(var, &zero_indices[0], 2));
-	} else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(arg_info_type)));
+	}
 
 	// zend_bool pass_rest_by_reference;
 	members.push_back(ConstantInt::get(Type::Int8Ty, op_array->pass_rest_by_reference));
@@ -679,41 +691,46 @@
 	// zend_bool done_pass_two;
 	members.push_back(ConstantInt::get(Type::Int8Ty, op_array->done_pass_two));
 
+	add_padding(members, 1);
+
 	// zend_uint *refcount;
-	if (op_array->function_name) {
-		GlobalVariable* var = new GlobalVariable(Type::Int32Ty, true, GlobalValue::InternalLinkage, ConstantInt::get(Type::Int32Ty, *op_array->refcount), "refcount", mod);
+	if (op_array->refcount) {
+		GlobalVariable* var = new GlobalVariable(uint_type, true, GlobalValue::InternalLinkage, ConstantInt::get(uint_type, *op_array->refcount), "refcount", mod);
 		members.push_back(var);
-	} else
-		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(Type::Int32Ty)));
+	} else {
+		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(uint_type)));
+	}
 
 	// zend_op *opcodes;
 	GlobalVariable* opcodes = dump_opcodes(op_array->opcodes, op_array->last, mod, engine);
 	members.push_back(opcodes);
 
 	// zend_uint last, size;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->last));
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->last)); // not "size" intentionally
+	members.push_back(ConstantInt::get(uint_type, op_array->last));
+	members.push_back(ConstantInt::get(uint_type, op_array->last)); // not "size" intentionally
 
 	// zend_compiled_variable *vars;
 	if (op_array->vars) {
 		GlobalVariable* var = dump_compiled_vars(op_array->vars, op_array->last_var, mod);
 		members.push_back(ConstantExpr::getGetElementPtr(var, &zero_indices[0], 2));
-	} else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(compiled_variable_type)));
+	}
 
 	// int last_var, size_var;
 	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->last_var));
 	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->size_var));
 
 	// zend_uint T;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->T));
+	members.push_back(ConstantInt::get(uint_type, op_array->T));
 
 	// zend_brk_cont_element *brk_cont_array;
 	if (op_array->brk_cont_array) {
 		GlobalVariable* var = dump_brk_cont_array(op_array->brk_cont_array, op_array->last_brk_cont, mod);
 		members.push_back(ConstantExpr::getGetElementPtr(var, &zero_indices[0], 2));
-	} else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(brk_cont_element_type)));
+	}
 
 	// int last_brk_cont;
 	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->last_brk_cont));
@@ -721,11 +738,13 @@
 	// int current_brk_cont;
 	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->current_brk_cont));
 
+	// zend_try_catch_element *try_catch_array;
 	if (op_array->try_catch_array) {
 		GlobalVariable* var = dump_try_catch_array(op_array->try_catch_array, op_array->last_try_catch, mod);
 		members.push_back(ConstantExpr::getGetElementPtr(var, &zero_indices[0], 2));
-	} else
-		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(try_catch_element_type)));
+	} else {
+		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(label_type)));
+	}
 
 	// int last_try_catch;
 	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->last_try_catch));
@@ -741,47 +760,50 @@
 		indices.push_back(ConstantInt::get(Type::Int32Ty, 0));
 		indices.push_back(ConstantInt::get(Type::Int32Ty, start));
 		members.push_back(ConstantExpr::getGetElementPtr(opcodes, &indices[0], 2));
-	} else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(op_type)));
+	}
 
 	// int backpatch_count;
 	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->backpatch_count));
 
 	// zend_uint this_var;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->this_var));
+	members.push_back(ConstantInt::get(uint_type, op_array->this_var));
 
 	// char *filename;
 	if (op_array->filename) {
 		Constant* string = ConstantArray::get(op_array->filename);
 		GlobalVariable* var = new GlobalVariable(string->getType(), true, GlobalValue::InternalLinkage, string, "filename", mod);
 		members.push_back(ConstantExpr::getGetElementPtr(var, &zero_indices[0], 2));
-	} else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(Type::Int8Ty)));
+	}
 
 	// zend_uint line_start;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->line_start));
+	members.push_back(ConstantInt::get(uint_type, op_array->line_start));
 
 	// zend_uint line_end;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->line_end));
+	members.push_back(ConstantInt::get(uint_type, op_array->line_end));
 
 	// char *doc_comment;
 	if (op_array->doc_comment) {
 		Constant* string = ConstantArray::get(op_array->doc_comment);
 		GlobalVariable* var = new GlobalVariable(string->getType(), true, GlobalValue::InternalLinkage, string, "doc_comment", mod);
 		members.push_back(ConstantExpr::getGetElementPtr(var, &zero_indices[0], 2));
-	} else
+	} else {
 		members.push_back(ConstantPointerNull::get(PointerType::getUnqual(Type::Int8Ty)));
+	}
 
 	// zend_uint doc_comment_len;
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->doc_comment_len));
+	members.push_back(ConstantInt::get(uint_type, op_array->doc_comment_len));
 
 	// zend_uint early_binding; /* the linked list of delayed declarations */
-	members.push_back(ConstantInt::get(Type::Int32Ty, op_array->early_binding));
+	members.push_back(ConstantInt::get(uint_type, op_array->early_binding));
 
 	// void *reserved[ZEND_MAX_RESERVED_RESOURCES];
 	const ArrayType *ptr_array_type = ArrayType::get(PointerType::getUnqual(Type::Int8Ty), ZEND_MAX_RESERVED_RESOURCES);
 	std::vector<Constant*> vals;
-	for(int i = 0; op_array->reserved[i] && i < ZEND_MAX_RESERVED_RESOURCES; i++) {
+	for(unsigned i = 0; op_array->reserved[i] && i < ZEND_MAX_RESERVED_RESOURCES; i++) {
 		// TODO: Do these need to be deep copied?
 		GlobalVariable* var = new GlobalVariable(Type::Int8Ty, true, GlobalValue::InternalLinkage, ConstantInt::get(Type::Int8Ty, (uint64_t) op_array->reserved[i]), "reserved_ptr", mod);
 		vals.push_back(var);
http://cvs.php.net/viewvc.cgi/pecl/llvm/phpllvm_execute.cpp?r1=1.12&r2=1.13&diff_format=u
Index: pecl/llvm/phpllvm_execute.cpp
diff -u pecl/llvm/phpllvm_execute.cpp:1.12 pecl/llvm/phpllvm_execute.cpp:1.13
--- pecl/llvm/phpllvm_execute.cpp:1.12	Tue Aug 12 15:14:11 2008
+++ pecl/llvm/phpllvm_execute.cpp	Thu Oct 23 14:12:09 2008
@@ -21,29 +21,24 @@
 #include "phpllvm_compile.h"
 
 #include <llvm/PassManager.h>
-#include <llvm/CallingConv.h>
-#include <llvm/Support/IRBuilder.h>
-
-#include "llvm/ModuleProvider.h"
+#include <llvm/ModuleProvider.h>
 #include <llvm/ExecutionEngine/ExecutionEngine.h>
 #include <llvm/ExecutionEngine/GenericValue.h>
 #include <llvm/Support/MemoryBuffer.h>
 #include <llvm/Bitcode/ReaderWriter.h>
 #include <llvm/Analysis/Verifier.h>
 #include <llvm/Assembly/PrintModulePass.h>
-
-#include "llvm/Target/TargetData.h"
-#include "llvm/Transforms/Scalar.h"
-#include "llvm/Transforms/IPO.h"
-
-#include <fstream>
+#include <llvm/Target/TargetData.h>
+#include <llvm/Transforms/Scalar.h>
+#include <llvm/Transforms/IPO.h>
+#include <llvm/Support/raw_ostream.h>
 
 using namespace llvm;
 using namespace phpllvm;
 
-/* pointer to the original Zend engine execute function */
+// pointer to the original Zend engine execute function
 typedef void (zend_execute_t)(zend_op_array *op_array TSRMLS_DC);
-static zend_execute_t *old_execute;
+static zend_execute_t *old_execute = NULL;
 
 static ExecutionEngine* engine;
 static Module* module;
@@ -65,31 +60,36 @@
 	verifyModule(*module, AbortProcessAction);
 #endif
 
-	std::ofstream bc_os(filename, std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
-	if (!bc_os.fail()) {
-		WriteBitcodeToFile(module, bc_os);
+	std::string ErrorInfo;
+	raw_fd_ostream os(filename, ErrorInfo);
+
+	if (ErrorInfo.empty()) {
+		WriteBitcodeToFile(module, os);
 	}
 }
 
-void phpllvm::init_jit_engine(const char* filename TSRMLS_DC) {
+void phpllvm::init_jit_engine(const char* filename) {
 
-	if (!filename)
+	if (!filename) {
 		filename = "module_template.bc";
+	}
 
-	/* read in the template that includes the handlers */
+	// read in the template that includes the handlers
 	MemoryBuffer* buf;
 	std::string err;
 
-	if (!(buf = MemoryBuffer::getFile(filename, &err)))
+	if (!(buf = MemoryBuffer::getFile(filename, &err))) {
 		fprintf(stderr, "Couldn't read handlers file: %s", err.c_str());
+	}
 
-	if (!(module = ParseBitcodeFile(buf, &err)))
+	if (!(module = ParseBitcodeFile(buf, &err))) {
 		fprintf(stderr, "Couldn't parse handlers file: %s", err.c_str());
+	}
 
 	provider = new ExistingModuleProvider(module);
 	engine = ExecutionEngine::create(provider);
 
-	/* Force codegen of handlers. */
+	// Force codegen of handlers. this is a workaround for an LLVM bug in the JIT engine
 	for (Module::iterator I = module->begin(), E = module->end(); I != E; ++I) {
 		Function *Fn = &*I;
 		if (!Fn->isDeclaration() && Fn->getName().compare(0, 5, "ZEND_") == 0) {
@@ -98,44 +98,36 @@
 		}
 	}
 
-	/* Set up the optimization passes */
+	// Set up the optimization passes
 	opt_fpass_manager = new FunctionPassManager(provider);
 
 	opt_fpass_manager->add(new TargetData(*engine->getTargetData()));
 	pass_manager.add(new TargetData(*engine->getTargetData()));
 
 	// IPO optimizations
-	// Inline function calls.
 	pass_manager.add(createFunctionInliningPass());
 
 	// local optimizations
-	// Do simple "peephole" optimizations and bit-twiddling optzns.
 	opt_fpass_manager->add(createInstructionCombiningPass());
-	// Reassociate expressions.
 	opt_fpass_manager->add(createReassociatePass());
-	// Eliminate Common SubExpressions.
 	opt_fpass_manager->add(createGVNPass());
-	// Simplify the control flow graph (deleting unreachable blocks, etc).
 	opt_fpass_manager->add(createCFGSimplificationPass());
 }
 
-void phpllvm::destroy_jit_engine(TSRMLS_D) {
+void phpllvm::destroy_jit_engine() {
 	delete engine;
-	engine = NULL;
-	provider = NULL;
-
 	delete opt_fpass_manager;
-	opt_fpass_manager = NULL;
 }
 
-void phpllvm::override_executor(TSRMLS_D) {
+void phpllvm::override_executor() {
 	old_execute = zend_execute;
 	zend_execute = phpllvm::execute;
 }
 
-void phpllvm::restore_executor(TSRMLS_D) {
-	if (old_execute)
+void phpllvm::restore_executor() {
+	if (old_execute) {
 		zend_execute = old_execute;
+	}
 }
 
 void phpllvm::execute(zend_op_array *op_array TSRMLS_DC) {
http://cvs.php.net/viewvc.cgi/pecl/llvm/phpllvm_execute.h?r1=1.5&r2=1.6&diff_format=u
Index: pecl/llvm/phpllvm_execute.h
diff -u pecl/llvm/phpllvm_execute.h:1.5 pecl/llvm/phpllvm_execute.h:1.6
--- pecl/llvm/phpllvm_execute.h:1.5	Tue Jul 29 00:54:51 2008
+++ pecl/llvm/phpllvm_execute.h	Thu Oct 23 14:12:09 2008
@@ -26,13 +26,13 @@
 
 namespace phpllvm {
 
-	void init_jit_engine(const char* filename TSRMLS_DC);
+	void init_jit_engine(const char* filename);
 
-	void destroy_jit_engine(TSRMLS_D);
+	void destroy_jit_engine();
 
-	void override_executor(TSRMLS_D);
+	void override_executor();
 
-	void restore_executor(TSRMLS_D);
+	void restore_executor();
 
 	void execute(zend_op_array *op_array TSRMLS_DC);