From 64cfcefdeb05bd955659dfe07435c9ca6ae8efac Mon Sep 17 00:00:00 2001 From: Garrison Venn Date: Sun, 10 Apr 2011 14:06:52 +0000 Subject: Fixed more best practices, and explicit/implicit style guide issues. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@129245 91177308-0d34-0410-b5e6-96231b3b80d8 --- examples/ExceptionDemo/ExceptionDemo.cpp | 259 +++++++++++++++---------------- 1 file changed, 128 insertions(+), 131 deletions(-) (limited to 'examples/ExceptionDemo/ExceptionDemo.cpp') diff --git a/examples/ExceptionDemo/ExceptionDemo.cpp b/examples/ExceptionDemo/ExceptionDemo.cpp index f2203a72b6..5d7a63dce8 100644 --- a/examples/ExceptionDemo/ExceptionDemo.cpp +++ b/examples/ExceptionDemo/ExceptionDemo.cpp @@ -113,9 +113,9 @@ extern "C" { } __attribute__((__aligned__)); struct _Unwind_Context; - typedef struct _Unwind_Context* _Unwind_Context_t; + typedef struct _Unwind_Context *_Unwind_Context_t; - extern const uint8_t* _Unwind_GetLanguageSpecificData (_Unwind_Context_t c); + extern const uint8_t *_Unwind_GetLanguageSpecificData (_Unwind_Context_t c); extern uintptr_t _Unwind_GetGR (_Unwind_Context_t c, int i); extern void _Unwind_SetGR (_Unwind_Context_t c, int i, uintptr_t n); extern void _Unwind_SetIP (_Unwind_Context_t, uintptr_t new_value); @@ -171,13 +171,13 @@ static uint64_t ourBaseExceptionClass = 0; static std::vector ourTypeInfoNames; static std::map ourTypeInfoNamesIndex; -static llvm::StructType* ourTypeInfoType; -static llvm::StructType* ourExceptionType; -static llvm::StructType* ourUnwindExceptionType; +static llvm::StructType *ourTypeInfoType; +static llvm::StructType *ourExceptionType; +static llvm::StructType *ourUnwindExceptionType; -static llvm::ConstantInt* ourExceptionNotThrownState; -static llvm::ConstantInt* ourExceptionThrownState; -static llvm::ConstantInt* ourExceptionCaughtState; +static llvm::ConstantInt *ourExceptionNotThrownState; +static llvm::ConstantInt *ourExceptionThrownState; +static llvm::ConstantInt *ourExceptionCaughtState; typedef std::vector ArgNames; typedef std::vector ArgTypes; @@ -198,11 +198,11 @@ typedef std::vector ArgTypes; /// @param declarationOnly for function declarations /// @param isVarArg function uses vararg arguments /// @returns function instance -llvm::Function *createFunction(llvm::Module& module, - const llvm::Type* retType, - const ArgTypes& theArgTypes, - const ArgNames& theArgNames, - const std::string& functName, +llvm::Function *createFunction(llvm::Module &module, + const llvm::Type *retType, + const ArgTypes &theArgTypes, + const ArgNames &theArgNames, + const std::string &functName, llvm::GlobalValue::LinkageTypes linkage, bool declarationOnly, bool isVarArg) { @@ -234,13 +234,13 @@ llvm::Function *createFunction(llvm::Module& module, /// @param type stack variable type /// @param initWith optional constant initialization value /// @returns AllocaInst instance -static llvm::AllocaInst *createEntryBlockAlloca(llvm::Function& function, +static llvm::AllocaInst *createEntryBlockAlloca(llvm::Function &function, const std::string &varName, - const llvm::Type* type, - llvm::Constant* initWith = 0) { - llvm::BasicBlock& block = function.getEntryBlock(); + const llvm::Type *type, + llvm::Constant *initWith = 0) { + llvm::BasicBlock &block = function.getEntryBlock(); llvm::IRBuilder<> tmp(&block, block.begin()); - llvm::AllocaInst* ret = tmp.CreateAlloca(type, 0, varName.c_str()); + llvm::AllocaInst *ret = tmp.CreateAlloca(type, 0, varName.c_str()); if (initWith) tmp.CreateStore(initWith, ret); @@ -265,7 +265,7 @@ extern "C" { /// Prints a 32 bit number, according to the format, to stderr. /// @param intToPrint integer to print /// @param format printf like format to use when printing -void print32Int(int intToPrint, const char* format) { +void print32Int(int intToPrint, const char *format) { if (format) { // Note: No NULL check fprintf(stderr, format, intToPrint); @@ -282,7 +282,7 @@ void print32Int(int intToPrint, const char* format) { /// Prints a 64 bit number, according to the format, to stderr. /// @param intToPrint integer to print /// @param format printf like format to use when printing -void print64Int(long int intToPrint, const char* format) { +void print64Int(long int intToPrint, const char *format) { if (format) { // Note: No NULL check fprintf(stderr, format, intToPrint); @@ -296,7 +296,7 @@ void print64Int(long int intToPrint, const char* format) { /// Prints a C string to stderr /// @param toPrint string to print -void printStr(char* toPrint) { +void printStr(char *toPrint) { if (toPrint) { fprintf(stderr, "%s", toPrint); } @@ -310,7 +310,7 @@ void printStr(char* toPrint) { /// is calculated from the supplied OurBaseException_t::unwindException /// member address. Handles (ignores), NULL pointers. /// @param expToDelete exception to delete -void deleteOurException(OurUnwindException* expToDelete) { +void deleteOurException(OurUnwindException *expToDelete) { #ifdef DEBUG fprintf(stderr, "deleteOurException(...).\n"); @@ -331,7 +331,7 @@ void deleteOurException(OurUnwindException* expToDelete) { /// @unlink /// @param expToDelete exception instance to delete void deleteFromUnwindOurException(_Unwind_Reason_Code reason, - OurUnwindException* expToDelete) { + OurUnwindException *expToDelete) { #ifdef DEBUG fprintf(stderr, "deleteFromUnwindOurException(...).\n"); @@ -344,9 +344,9 @@ void deleteFromUnwindOurException(_Unwind_Reason_Code reason, /// Creates (allocates on the heap), an exception (OurException instance), /// of the supplied type info type. /// @param type type info type -OurUnwindException* createOurException(int type) { +OurUnwindException *createOurException(int type) { size_t size = sizeof(OurException); - OurException* ret = (OurException*) memset(malloc(size), 0, size); + OurException *ret = (OurException*) memset(malloc(size), 0, size); (ret->type).type = type; (ret->unwindException).exception_class = ourBaseExceptionClass; (ret->unwindException).exception_cleanup = deleteFromUnwindOurException; @@ -360,11 +360,11 @@ OurUnwindException* createOurException(int type) { /// @link http://dwarfstd.org/Dwarf3.pdf @unlink /// @param data reference variable holding memory pointer to decode from /// @returns decoded value -static uintptr_t readULEB128(const uint8_t** data) { +static uintptr_t readULEB128(const uint8_t **data) { uintptr_t result = 0; uintptr_t shift = 0; unsigned char byte; - const uint8_t* p = *data; + const uint8_t *p = *data; do { byte = *p++; @@ -384,11 +384,11 @@ static uintptr_t readULEB128(const uint8_t** data) { /// @link http://dwarfstd.org/Dwarf3.pdf @unlink /// @param data reference variable holding memory pointer to decode from /// @returns decoded value -static uintptr_t readSLEB128(const uint8_t** data) { +static uintptr_t readSLEB128(const uint8_t **data) { uintptr_t result = 0; uintptr_t shift = 0; unsigned char byte; - const uint8_t* p = *data; + const uint8_t *p = *data; do { byte = *p++; @@ -413,9 +413,9 @@ static uintptr_t readSLEB128(const uint8_t** data) { /// @param data reference variable holding memory pointer to decode from /// @param encoding dwarf encoding type /// @returns decoded value -static uintptr_t readEncodedPointer(const uint8_t** data, uint8_t encoding) { +static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encoding) { uintptr_t result = 0; - const uint8_t* p = *data; + const uint8_t *p = *data; if (encoding == llvm::dwarf::DW_EH_PE_omit) return(result); @@ -522,7 +522,7 @@ static bool handleActionValue(int64_t *resultAction, (exceptionClass != ourBaseExceptionClass)) return(ret); - struct OurBaseException_t* excp = (struct OurBaseException_t*) + struct OurBaseException_t *excp = (struct OurBaseException_t*) (((char*) exceptionObject) + ourBaseFromUnwindOffset); struct OurExceptionType_t *excpType = &(excp->type); int type = excpType->type; @@ -598,10 +598,10 @@ static bool handleActionValue(int64_t *resultAction, /// @param context unwind system context /// @returns minimally supported unwinding control indicator static _Unwind_Reason_Code handleLsda(int version, - const uint8_t* lsda, + const uint8_t *lsda, _Unwind_Action actions, uint64_t exceptionClass, - struct _Unwind_Exception* exceptionObject, + struct _Unwind_Exception *exceptionObject, _Unwind_Context_t context) { _Unwind_Reason_Code ret = _URC_CONTINUE_UNWIND; @@ -621,7 +621,7 @@ static _Unwind_Reason_Code handleLsda(int version, // emitted dwarf code) uintptr_t funcStart = _Unwind_GetRegionStart(context); uintptr_t pcOffset = pc - funcStart; - struct OurExceptionType_t** classInfo = NULL; + struct OurExceptionType_t **classInfo = NULL; // Note: See JITDwarfEmitter::EmitExceptionTable(...) for corresponding // dwarf emission @@ -649,11 +649,11 @@ static _Unwind_Reason_Code handleLsda(int version, uint8_t callSiteEncoding = *lsda++; uint32_t callSiteTableLength = readULEB128(&lsda); - const uint8_t* callSiteTableStart = lsda; - const uint8_t* callSiteTableEnd = callSiteTableStart + + const uint8_t *callSiteTableStart = lsda; + const uint8_t *callSiteTableEnd = callSiteTableStart + callSiteTableLength; - const uint8_t* actionTableStart = callSiteTableEnd; - const uint8_t* callSitePtr = callSiteTableStart; + const uint8_t *actionTableStart = callSiteTableEnd; + const uint8_t *callSitePtr = callSiteTableStart; bool foreignException = false; @@ -704,14 +704,11 @@ static _Unwind_Reason_Code handleLsda(int version, int64_t actionValue = 0; if (actionEntry) { - exceptionMatched = handleActionValue - ( - &actionValue, - classInfo, - actionEntry, - exceptionClass, - exceptionObject - ); + exceptionMatched = handleActionValue(&actionValue, + classInfo, + actionEntry, + exceptionClass, + exceptionObject); } if (!(actions & _UA_SEARCH_PHASE)) { @@ -789,7 +786,7 @@ static _Unwind_Reason_Code handleLsda(int version, _Unwind_Reason_Code ourPersonality(int version, _Unwind_Action actions, uint64_t exceptionClass, - struct _Unwind_Exception* exceptionObject, + struct _Unwind_Exception *exceptionObject, _Unwind_Context_t context) { #ifdef DEBUG fprintf(stderr, @@ -804,7 +801,7 @@ _Unwind_Reason_Code ourPersonality(int version, } #endif - const uint8_t* lsda = _Unwind_GetLanguageSpecificData(context); + const uint8_t *lsda = _Unwind_GetLanguageSpecificData(context); #ifdef DEBUG fprintf(stderr, @@ -860,15 +857,15 @@ uint64_t genClass(const unsigned char classChars[], size_t classCharsSize) /// generated, and is used to hold the constant string. A value of /// false indicates that the constant string will be stored on the /// stack. -void generateStringPrint(llvm::LLVMContext& context, - llvm::Module& module, - llvm::IRBuilder<>& builder, +void generateStringPrint(llvm::LLVMContext &context, + llvm::Module &module, + llvm::IRBuilder<> &builder, std::string toPrint, bool useGlobal = true) { llvm::Function *printFunct = module.getFunction("printStr"); llvm::Value *stringVar; - llvm::Constant* stringConstant = + llvm::Constant *stringConstant = llvm::ConstantArray::get(context, toPrint); if (useGlobal) { @@ -886,7 +883,7 @@ void generateStringPrint(llvm::LLVMContext& context, builder.CreateStore(stringConstant, stringVar); } - llvm::Value* cast = + llvm::Value *cast = builder.CreatePointerCast(stringVar, builder.getInt8Ty()->getPointerTo()); builder.CreateCall(printFunct, cast); @@ -905,11 +902,11 @@ void generateStringPrint(llvm::LLVMContext& context, /// generated, and is used to hold the constant string. A value of /// false indicates that the constant string will be stored on the /// stack. -void generateIntegerPrint(llvm::LLVMContext& context, - llvm::Module& module, - llvm::IRBuilder<>& builder, - llvm::Function& printFunct, - llvm::Value& toPrint, +void generateIntegerPrint(llvm::LLVMContext &context, + llvm::Module &module, + llvm::IRBuilder<> &builder, + llvm::Function &printFunct, + llvm::Value &toPrint, std::string format, bool useGlobal = true) { llvm::Constant *stringConstant = llvm::ConstantArray::get(context, format); @@ -930,7 +927,7 @@ void generateIntegerPrint(llvm::LLVMContext& context, builder.CreateStore(stringConstant, stringVar); } - llvm::Value* cast = + llvm::Value *cast = builder.CreateBitCast(stringVar, builder.getInt8Ty()->getPointerTo()); builder.CreateCall2(&printFunct, &toPrint, cast); @@ -956,16 +953,16 @@ void generateIntegerPrint(llvm::LLVMContext& context, /// @param exceptionCaughtFlag reference exception caught/thrown status storage /// @param exceptionStorage reference to exception pointer storage /// @returns newly created block -static llvm::BasicBlock* createFinallyBlock(llvm::LLVMContext& context, - llvm::Module& module, - llvm::IRBuilder<>& builder, - llvm::Function& toAddTo, - std::string& blockName, - std::string& functionId, - llvm::BasicBlock& terminatorBlock, - llvm::BasicBlock& unwindResumeBlock, - llvm::Value** exceptionCaughtFlag, - llvm::Value** exceptionStorage) { +static llvm::BasicBlock *createFinallyBlock(llvm::LLVMContext &context, + llvm::Module &module, + llvm::IRBuilder<> &builder, + llvm::Function &toAddTo, + std::string &blockName, + std::string &functionId, + llvm::BasicBlock &terminatorBlock, + llvm::BasicBlock &unwindResumeBlock, + llvm::Value **exceptionCaughtFlag, + llvm::Value **exceptionStorage) { assert(exceptionCaughtFlag && "ExceptionDemo::createFinallyBlock(...):exceptionCaughtFlag " "is NULL"); @@ -979,7 +976,7 @@ static llvm::BasicBlock* createFinallyBlock(llvm::LLVMContext& context, ourExceptionNotThrownState->getType(), ourExceptionNotThrownState); - const llvm::PointerType* exceptionStorageType = + const llvm::PointerType *exceptionStorageType = builder.getInt8Ty()->getPointerTo(); *exceptionStorage = createEntryBlockAlloca(toAddTo, @@ -1003,7 +1000,7 @@ static llvm::BasicBlock* createFinallyBlock(llvm::LLVMContext& context, bufferToPrint.str(), USE_GLOBAL_STR_CONSTS); - llvm::SwitchInst* theSwitch = + llvm::SwitchInst *theSwitch = builder.CreateSwitch(builder.CreateLoad(*exceptionCaughtFlag), &terminatorBlock, 2); @@ -1026,14 +1023,14 @@ static llvm::BasicBlock* createFinallyBlock(llvm::LLVMContext& context, /// @param terminatorBlock terminator "end" block /// @param exceptionCaughtFlag exception caught/thrown status /// @returns newly created block -static llvm::BasicBlock* createCatchBlock(llvm::LLVMContext& context, - llvm::Module& module, - llvm::IRBuilder<>& builder, - llvm::Function& toAddTo, - std::string& blockName, - std::string& functionId, - llvm::BasicBlock& terminatorBlock, - llvm::Value& exceptionCaughtFlag) { +static llvm::BasicBlock *createCatchBlock(llvm::LLVMContext &context, + llvm::Module &module, + llvm::IRBuilder<> &builder, + llvm::Function &toAddTo, + std::string &blockName, + std::string &functionId, + llvm::BasicBlock &terminatorBlock, + llvm::Value &exceptionCaughtFlag) { llvm::BasicBlock *ret = llvm::BasicBlock::Create(context, blockName, @@ -1079,15 +1076,15 @@ static llvm::BasicBlock* createCatchBlock(llvm::LLVMContext& context, /// @param exceptionTypesToCatch array of type info types to "catch" /// @returns generated function static -llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, - llvm::IRBuilder<>& builder, - llvm::FunctionPassManager& fpm, - llvm::Function& toInvoke, - std::string ourId, - unsigned numExceptionsToCatch, - unsigned exceptionTypesToCatch[]) { - - llvm::LLVMContext& context = module.getContext(); +llvm::Function *createCatchWrappedInvokeFunction(llvm::Module &module, + llvm::IRBuilder<> &builder, + llvm::FunctionPassManager &fpm, + llvm::Function &toInvoke, + std::string ourId, + unsigned numExceptionsToCatch, + unsigned exceptionTypesToCatch[]) { + + llvm::LLVMContext &context = module.getContext(); llvm::Function *toPrint32Int = module.getFunction("print32Int"); ArgTypes argTypes; @@ -1096,7 +1093,7 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, ArgNames argNames; argNames.push_back("exceptTypeToThrow"); - llvm::Function* ret = createFunction(module, + llvm::Function *ret = createFunction(module, builder.getVoidTy(), argTypes, argNames, @@ -1135,12 +1132,12 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, std::string nextName; std::vector catchBlocks(numExceptionsToCatch); - llvm::Value* exceptionCaughtFlag = NULL; - llvm::Value* exceptionStorage = NULL; + llvm::Value *exceptionCaughtFlag = NULL; + llvm::Value *exceptionStorage = NULL; // Finally block which will branch to unwindResumeBlock if // exception is not caught. Initializes/allocates stack locations. - llvm::BasicBlock* finallyBlock = createFinallyBlock(context, + llvm::BasicBlock *finallyBlock = createFinallyBlock(context, module, builder, *ret, @@ -1224,13 +1221,13 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, llvm::Function *ehException = module.getFunction("llvm.eh.exception"); // Retrieve thrown exception - llvm::Value* unwindException = builder.CreateCall(ehException); + llvm::Value *unwindException = builder.CreateCall(ehException); // Store exception and flag builder.CreateStore(unwindException, exceptionStorage); builder.CreateStore(ourExceptionThrownState, exceptionCaughtFlag); llvm::Function *personality = module.getFunction("ourPersonality"); - llvm::Value* functPtr = + llvm::Value *functPtr = builder.CreatePointerCast(personality, builder.getInt8Ty()->getPointerTo()); @@ -1256,14 +1253,14 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, // handles this call. This landing pad (this exception block), will be // called either because it nees to cleanup (call finally) or a type // info was found which matched the thrown exception. - llvm::Value* retTypeInfoIndex = builder.CreateCall(ehSelector, + llvm::Value *retTypeInfoIndex = builder.CreateCall(ehSelector, args.begin(), args.end()); // Retrieve exception_class member from thrown exception // (_Unwind_Exception instance). This member tells us whether or not // the exception is foreign. - llvm::Value* unwindExceptionClass = + llvm::Value *unwindExceptionClass = builder.CreateLoad(builder.CreateStructGEP( builder.CreatePointerCast(unwindException, ourUnwindExceptionType->getPointerTo()), @@ -1298,7 +1295,7 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, // (OurException instance). // // Note: ourBaseFromUnwindOffset is usually negative - llvm::Value* typeInfoThrown = + llvm::Value *typeInfoThrown = builder.CreatePointerCast(builder.CreateConstGEP1_64(unwindException, ourBaseFromUnwindOffset), ourExceptionType->getPointerTo()); @@ -1309,7 +1306,7 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, // unlike a true getelementptr (GEP) instruction typeInfoThrown = builder.CreateStructGEP(typeInfoThrown, 0); - llvm::Value* typeInfoThrownType = + llvm::Value *typeInfoThrownType = builder.CreateStructGEP(typeInfoThrown, 0); generateIntegerPrint(context, @@ -1324,7 +1321,7 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, USE_GLOBAL_STR_CONSTS); // Route to matched type info catch block or run cleanup finally block - llvm::SwitchInst* switchToCatchBlock = + llvm::SwitchInst *switchToCatchBlock = builder.CreateSwitch(retTypeInfoIndex, finallyBlock, numExceptionsToCatch); @@ -1360,13 +1357,13 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module, /// if the above nativeThrowType matches generated function's arg. /// @returns generated function static -llvm::Function* createThrowExceptionFunction(llvm::Module& module, - llvm::IRBuilder<>& builder, - llvm::FunctionPassManager& fpm, +llvm::Function *createThrowExceptionFunction(llvm::Module &module, + llvm::IRBuilder<> &builder, + llvm::FunctionPassManager &fpm, std::string ourId, int32_t nativeThrowType, - llvm::Function& nativeThrowFunct) { - llvm::LLVMContext& context = module.getContext(); + llvm::Function &nativeThrowFunct) { + llvm::LLVMContext &context = module.getContext(); namedValues.clear(); ArgTypes unwindArgTypes; unwindArgTypes.push_back(builder.getInt32Ty()); @@ -1398,7 +1395,7 @@ llvm::Function* createThrowExceptionFunction(llvm::Module& module, "generatedThrow", ret); // Retrieved runtime type info type to throw - llvm::Value* exceptionType = namedValues["exceptTypeToThrow"]; + llvm::Value *exceptionType = namedValues["exceptTypeToThrow"]; // nativeThrowBlock block @@ -1426,7 +1423,7 @@ llvm::Function* createThrowExceptionFunction(llvm::Module& module, // Switches on runtime type info type value to determine whether or not // a foreign exception is thrown. Defaults to throwing one of our // generated exceptions. - llvm::SwitchInst* theSwitch = builder.CreateSwitch(exceptionType, + llvm::SwitchInst *theSwitch = builder.CreateSwitch(exceptionType, generatedThrowBlock, 1); @@ -1444,7 +1441,7 @@ llvm::Function* createThrowExceptionFunction(llvm::Module& module, module.getFunction("_Unwind_RaiseException"); // Creates exception to throw with runtime type info type. - llvm::Value* exception = + llvm::Value *exception = builder.CreateCall(createOurException, namedValues["exceptTypeToThrow"]); @@ -1459,8 +1456,8 @@ llvm::Function* createThrowExceptionFunction(llvm::Module& module, } static void createStandardUtilityFunctions(unsigned numTypeInfos, - llvm::Module& module, - llvm::IRBuilder<>& builder); + llvm::Module &module, + llvm::IRBuilder<> &builder); /// Creates test code by generating and organizing these functions into the /// test case. The test case consists of an outer function setup to invoke @@ -1482,9 +1479,9 @@ static void createStandardUtilityFunctions(unsigned numTypeInfos, /// @param nativeThrowFunctName name of external function which will throw /// a foreign exception /// @returns outermost generated test function. -llvm::Function* createUnwindExceptionTest(llvm::Module& module, - llvm::IRBuilder<>& builder, - llvm::FunctionPassManager& fpm, +llvm::Function *createUnwindExceptionTest(llvm::Module &module, + llvm::IRBuilder<> &builder, + llvm::FunctionPassManager &fpm, std::string nativeThrowFunctName) { // Number of type infos to generate unsigned numTypeInfos = 6; @@ -1499,7 +1496,7 @@ llvm::Function* createUnwindExceptionTest(llvm::Module& module, // Create exception throw function using the value ~0 to cause // foreign exceptions to be thrown. - llvm::Function* throwFunct = + llvm::Function *throwFunct = createThrowExceptionFunction(module, builder, fpm, @@ -1512,7 +1509,7 @@ llvm::Function* createUnwindExceptionTest(llvm::Module& module, sizeof(unsigned); // Generate inner function. - llvm::Function* innerCatchFunct = + llvm::Function *innerCatchFunct = createCatchWrappedInvokeFunction(module, builder, fpm, @@ -1527,7 +1524,7 @@ llvm::Function* createUnwindExceptionTest(llvm::Module& module, sizeof(unsigned); // Generate outer function - llvm::Function* outerCatchFunct = + llvm::Function *outerCatchFunct = createCatchWrappedInvokeFunction(module, builder, fpm, @@ -1547,10 +1544,10 @@ public: OurCppRunException(const std::string reason) : std::runtime_error(reason) {} - OurCppRunException (const OurCppRunException& toCopy) : + OurCppRunException (const OurCppRunException &toCopy) : std::runtime_error(toCopy) {} - OurCppRunException& operator = (const OurCppRunException& toCopy) { + OurCppRunException &operator = (const OurCppRunException &toCopy) { return(reinterpret_cast( std::runtime_error::operator=(toCopy))); } @@ -1579,8 +1576,8 @@ typedef void (*OurExceptionThrowFunctType) (int32_t typeToThrow); /// @param typeToThrow type info type of generated exception to throw, or /// indicator to cause foreign exception to be thrown. static -void runExceptionThrow(llvm::ExecutionEngine* engine, - llvm::Function* function, +void runExceptionThrow(llvm::ExecutionEngine *engine, + llvm::Function *function, int32_t typeToThrow) { // Find test's function pointer @@ -1624,10 +1621,10 @@ typedef llvm::ArrayRef TypeArray; /// @param module code for module instance /// @param builder builder instance static void createStandardUtilityFunctions(unsigned numTypeInfos, - llvm::Module& module, - llvm::IRBuilder<>& builder) { + llvm::Module &module, + llvm::IRBuilder<> &builder) { - llvm::LLVMContext& context = module.getContext(); + llvm::LLVMContext &context = module.getContext(); // Exception initializations @@ -1683,7 +1680,7 @@ static void createStandardUtilityFunctions(unsigned numTypeInfos, std::vector structVals; llvm::Constant *nextStruct; - llvm::GlobalVariable* nextGlobal = NULL; + llvm::GlobalVariable *nextGlobal = NULL; // Generate each type info // @@ -1712,11 +1709,11 @@ static void createStandardUtilityFunctions(unsigned numTypeInfos, ArgNames argNames; ArgTypes argTypes; - llvm::Function* funct = NULL; + llvm::Function *funct = NULL; // print32Int - const llvm::Type* retType = builder.getVoidTy(); + const llvm::Type *retType = builder.getVoidTy(); argTypes.clear(); argTypes.push_back(builder.getInt32Ty()); @@ -1910,7 +1907,7 @@ static void createStandardUtilityFunctions(unsigned numTypeInfos, /// <= 6 and >= 1 will be caught by test functions; and type info types > 6 /// will result in exceptions which pass through to the test harness. All other /// type info types are not supported and could cause a crash. -int main(int argc, char* argv[]) { +int main(int argc, char *argv[]) { if (argc == 1) { fprintf(stderr, "\nUsage: ExceptionDemo " @@ -1929,17 +1926,17 @@ int main(int argc, char* argv[]) { llvm::JITExceptionHandling = true; llvm::InitializeNativeTarget(); - llvm::LLVMContext& context = llvm::getGlobalContext(); + llvm::LLVMContext &context = llvm::getGlobalContext(); llvm::IRBuilder<> theBuilder(context); // Make the module, which holds all the code. - llvm::Module* module = new llvm::Module("my cool jit", context); + llvm::Module *module = new llvm::Module("my cool jit", context); // Build engine with JIT llvm::EngineBuilder factory(module); factory.setEngineKind(llvm::EngineKind::JIT); factory.setAllocateGVsWithCode(false); - llvm::ExecutionEngine* executionEngine = factory.create(); + llvm::ExecutionEngine *executionEngine = factory.create(); { llvm::FunctionPassManager fpm(module); @@ -1976,7 +1973,7 @@ int main(int argc, char* argv[]) { // Generate test code using function throwCppException(...) as // the function which throws foreign exceptions. - llvm::Function* toRun = + llvm::Function *toRun = createUnwindExceptionTest(*module, theBuilder, fpm, -- cgit v1.2.3