reindent this whole file and do a variety of stylistic cleanups.

This code is still a long way from following best practices.

llvm-svn: 129140

examples/ExceptionDemo/ExceptionDemo.cpp

@@ -1,12 +1,11 @@
-//===-- examples/ExceptionDemo/ExceptionDemo.cpp - 
+//===-- ExceptionDemo.cpp - An example using llvm Exceptions --------------===//
-//                      An example use of the llvm Exception mechanism --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
-//===--------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 //
 // Demo program which implements an example LLVM exception implementation, and
 // shows several test cases including the handling of foreign exceptions.
@@ -46,8 +45,7 @@
 // This code uses code from the llvm compiler-rt project and the llvm 
 // Kaleidoscope project.
 //
-//===--------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
-
 
 #include "llvm/LLVMContext.h"
 #include "llvm/DerivedTypes.h"
@@ -64,11 +62,7 @@
 #include "llvm/Support/IRBuilder.h"
 #include "llvm/Support/Dwarf.h"
 
-#include <cstdio>
-#include <string>
 #include <sstream>
-#include <map>
-#include <vector>
 #include <stdexcept>
 
 
@@ -212,13 +206,10 @@ llvm::Function *createFunction(llvm::Module& module,
                                llvm::GlobalValue::LinkageTypes linkage,
                                bool declarationOnly,
                                bool isVarArg) {
-    llvm::FunctionType* functType = llvm::FunctionType::get(retType, 
+  llvm::FunctionType *functType =
-                                                            theArgTypes, 
+    llvm::FunctionType::get(retType, theArgTypes, isVarArg);
-                                                            isVarArg);
+  llvm::Function *ret =
-    llvm::Function* ret = llvm::Function::Create(functType, 
+    llvm::Function::Create(functType, linkage, functName, &module);
-                                                 linkage, 
-                                                 functName, 
-                                                 &module);
   if (!ret || declarationOnly)
     return(ret);
   
@@ -246,7 +237,7 @@ llvm::Function *createFunction(llvm::Module& module,
 static llvm::AllocaInst *createEntryBlockAlloca(llvm::Function& function,
                                                 const std::string &varName,
                                                 const llvm::Type* type,
-                                            llvm::Constant* initWith = NULL) {
+                                                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());
@@ -1005,10 +996,7 @@ static llvm::BasicBlock* createFinallyBlock(llvm::LLVMContext& context,
   
   std::ostringstream bufferToPrint;
   bufferToPrint << "Gen: Executing finally block "
-                  << blockName
+    << blockName << " in " << functionId << "\n";
-                  << " in "
-                  << functionId
-                  << std::endl;
   generateStringPrint(context, 
                       module, 
                       builder, 
@@ -1253,8 +1241,7 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module,
   // Note: Skipping index 0
   for (unsigned i = 0; i < numExceptionsToCatch; ++i) {
     // Set up type infos to be caught
-        args.push_back(
+    args.push_back(module.getGlobalVariable(
-            module.getGlobalVariable(
                                   ourTypeInfoNames[exceptionTypesToCatch[i]]));
   }
   
@@ -1277,17 +1264,14 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module,
   // (_Unwind_Exception instance). This member tells us whether or not
   // the exception is foreign.
   llvm::Value* unwindExceptionClass = 
-        builder.CreateLoad(
+    builder.CreateLoad(builder.CreateStructGEP(
-            builder.CreateStructGEP(
+             builder.CreatePointerCast(unwindException, 
-                builder.CreatePointerCast(
-                    unwindException, 
                                        ourUnwindExceptionType->getPointerTo()), 
                                                0));
   
   // Branch to the externalExceptionBlock if the exception is foreign or
   // to a catch router if not. Either way the finally block will be run.
-    builder.CreateCondBr(
+  builder.CreateCondBr(builder.CreateICmpEQ(unwindExceptionClass,
-        builder.CreateICmpEQ(unwindExceptionClass,
                             llvm::ConstantInt::get(builder.getInt64Ty(), 
                                                    ourBaseExceptionClass)),
                        exceptionRouteBlock,
@@ -1315,8 +1299,7 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module,
   //
   // Note: ourBaseFromUnwindOffset is usually negative
   llvm::Value* typeInfoThrown = 
-        builder.CreatePointerCast(
+  builder.CreatePointerCast(builder.CreateConstGEP1_64(unwindException,
-            builder.CreateConstGEP1_64(unwindException,
                                                        ourBaseFromUnwindOffset),
                             ourExceptionType->getPointerTo());
   
@@ -1351,8 +1334,7 @@ llvm::Function* createCatchWrappedInvokeFunction(llvm::Module& module,
   for (unsigned i = 1; i <= numExceptionsToCatch; ++i) {
     nextTypeToCatch = i - 1;
     switchToCatchBlock->addCase(llvm::ConstantInt::get(
-                                        llvm::Type::getInt32Ty(context), 
+                                   llvm::Type::getInt32Ty(context), i),
-                                        i),
                                 catchBlocks[nextTypeToCatch]);
   }
   
@@ -1570,8 +1552,7 @@ public:
   
   OurCppRunException& operator = (const OurCppRunException& toCopy) {
     return(reinterpret_cast<OurCppRunException&>(
-                   std::runtime_error::operator = (toCopy)
+                                 std::runtime_error::operator=(toCopy)));
-               ));
   }
   
   ~OurCppRunException (void) throw () {}
@@ -1605,10 +1586,7 @@ void runExceptionThrow(llvm::ExecutionEngine* engine,
   // Find test's function pointer
   OurExceptionThrowFunctType functPtr = 
     reinterpret_cast<OurExceptionThrowFunctType>(
-              reinterpret_cast<intptr_t>(
+       reinterpret_cast<intptr_t>(engine->getPointerToFunction(function)));
-                  engine->getPointerToFunction(function)
-              )
-          );
   
   try {
     // Run test
@@ -1675,8 +1653,8 @@ static void createStandardUtilityFunctions(unsigned numTypeInfos,
   //
   // Note: Declaring only a portion of the _Unwind_Exception struct.
   //       Does this cause problems?
-    ourUnwindExceptionType = llvm::StructType::get(context, 
+  ourUnwindExceptionType =
-                                               TypeArray(builder.getInt64Ty()));
+    llvm::StructType::get(context, TypeArray(builder.getInt64Ty()));
   struct OurBaseException_t dummyException;
   
   // Calculate offset of OurException::unwindException member.
@@ -1922,9 +1900,9 @@ static void createStandardUtilityFunctions(unsigned numTypeInfos,
 }
 
 
-//===---------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 // Main test driver code.
-//===---------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 
 /// Demo main routine which takes the type info types to throw. A test will
 /// be run for each given type info type. While type info types with the value