hlvm/hlvm/CodeGen/LLVMEmitter.h - llvm-archive - Git at Google

 //===-- LLVM Code Emitter Interface -----------------------------*- C++ -*-===//
 //
 //                      High Level Virtual Machine (HLVM)
 //
 // Copyright (C) 2006 Reid Spencer. All Rights Reserved.
 //
 // This software is free software; you can redistribute it and/or modify it
 // under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation; either version 2.1 of the License, or (at
 // your option) any later version.
 //
 // This software is distributed in the hope that it will be useful, but WITHOUT
 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
 // more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with this library in the file named LICENSE.txt; if not, write to the
 // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 // MA 02110-1301 USA
 //
 //===----------------------------------------------------------------------===//
 /// @file hlvm/CodeGen/LLVMEmitter.h
 /// @author Reid Spencer <rspencer@reidspencer.com> (original author)
 /// @date 2006/07/09
 /// @since 0.2.0
 /// @brief Declares the interface for emitting LLVM code
 //===----------------------------------------------------------------------===//

 #ifndef HLVM_CODEGEN_LLVMEMITTER_H
 #define HLVM_CODEGEN_LLVMEMITTER_H

 // Include the LLVM classes that we use
 #include <llvm/Module.h>
 #include <llvm/PassManager.h>
 #include <llvm/BasicBlock.h>
 #include <llvm/Function.h>
 #include <llvm/GlobalVariable.h>
 #include <llvm/Instructions.h>
 #include <llvm/DerivedTypes.h>
 #include <llvm/TypeSymbolTable.h>
 #include <llvm/Constants.h>
 #include <llvm/CallingConv.h>
 #include "llvm/Support/DataTypes.h"
 #include <vector>

 namespace hlvm {

 /// A simple list of LLVM Modules
 typedef std::vector<llvm::Module*> ModuleList;

 /// A List of LLVM Branch Instructions. These are used to record unconditional
 /// branches that need to be fixed up later with LLVMEmitter::ResolveBranches.
 typedef std::vector<llvm::BranchInst*> BranchList;

 /// A list of LLVM Blocks, presumably used in a push/pop stack fashion.
 typedef std::vector<llvm::BasicBlock*> BlockStack;

 /// A list of LLVM Values, used for argument lists
 typedef std::vector<llvm::Value*> ArgList;

 /// A list of LLVM types, used for function types
 typedef std::vector<const llvm::Type*> TypeList;

 /// This class provides utility functions for emitting LLVM code. It has no
 /// concept of how to translate HLVM into LLVM, that logic is in LLVMGenerator
 /// class. This class just keeps track of things in the LLVM world and provides
 /// a group of methods to take care of the details of emitting LLVM code. The
 /// main purpose for this class is simply to unclutter LLVMGenerator.
 class LLVMEmitter
 {
   /// @name Constructors
   /// @{
   protected:
     LLVMEmitter();

   /// @}
   /// @name Function Emission
   /// @{
   public:

     // Start a new modules
     llvm::Module* StartModule(const std::string& ID);

     // Finish the started module
     llvm::Module* FinishModule();

     /// Start a new function. This sets up the context of the emitter to start
     /// generating code for function \p F.
     void StartFunction(llvm::Function* F);

     /// Finish the function previously started. This must be called after a call
     /// to StartFunction. Mostly this just checks that the generated function is
     /// sane.
     void FinishFunction();

     /// Add a type to the module
     void AddType(const llvm::Type* Ty, const std::string& name)
     {
       TheModule->addTypeName(name, Ty);
     }

     /// Add a Function to the module
     llvm::Function* NewFunction(
       const llvm::FunctionType* Ty,
       llvm::GlobalValue::LinkageTypes LT,
       const std::string& name)
     {
       return new llvm::Function(Ty, LT, name, TheModule);
     }

     /// Add a global variable to the module
     llvm::GlobalVariable* NewGVar(
       const llvm::Type* Ty,
       llvm::GlobalValue::LinkageTypes LT,
       llvm::Constant* init,
       const std::string& name)
     {
       return new llvm::GlobalVariable(Ty, false, LT, init, name, TheModule);
     }
     /// Add a global constant to the module
     llvm::GlobalVariable* NewGConst(
       const llvm::Type* Ty,
       llvm::Constant* init,
       const std::string& name)
     {
       return new llvm::GlobalVariable(Ty, true,
          llvm::GlobalValue::InternalLinkage, init, name, TheModule);
     }

     /// Create a new AllocaInst in the entry block with the given name and type.
     /// The Type must have a fixed/constant size.
     llvm::AllocaInst* NewAutoVar(const llvm::Type* Ty, const std::string& name)
     {
       return new llvm::AllocaInst(Ty, 0, name, EntryInsertionPoint);
     }

     /// Add the specified basic block to the end of the function.  If
     /// the previous block falls through into it, add an explicit branch.  Also,
     /// manage fixups for EH info.
     void EmitBlock(llvm::BasicBlock *BB);

     /// Create a new LLVM block with the given \p name and push it onto the
     /// block stack.
     llvm::BasicBlock* pushBlock(const std::string& name);

     /// Pop a block off the block stack and return it.
     llvm::BasicBlock* popBlock();

     /// Replace the top of the block stack with a new block with the given
     /// \p name
     llvm::BasicBlock* newBlock(const std::string& name);

   /// @}
   /// @name Simple Helper Functions
   /// @{
   public:
     /// Get the current module we're building
     llvm::Module* getModule() const { return TheModule; }

     /// Get the current function we're building
     llvm::Function* getFunction() const { return TheFunction; }

     /// Get the current block we are filling
     llvm::BasicBlock* getBlock() const { return TheBlock; }

     /// Get the name of the current block we're inserting into
     std::string getBlockName() const {
       return TheBlock->getName();
     }
     // Get the terminating instruction of the current block
     llvm::Instruction* getBlockTerminator() const {
       return TheBlock->getTerminator();
     }
     // Get the return type of the current function
     const llvm::Type* getReturnType() const {
       return TheFunction->getReturnType();
     }

     /// Return the total number of elements in the Type, examining recursively,
     /// any nested aggregate types.
     unsigned getNumElements(const llvm::Type *Ty);

     /// Return a constant expression for indexing into the first element of
     /// a constant global variable.
     llvm::Constant* getFirstElement(llvm::GlobalVariable* GV);

     /// If V is a PointerType then load its value unless the referent type is
     /// not first class type
     llvm::Value* Pointer2Value(llvm::Value* V) const;

     /// Convert the value V into a Boolean value.
     llvm::Value* ConvertToBoolean(llvm::Value* V) const;

     /// Run through the \p list and set the first operand of each branch
     /// instruction found there to the \p exit block. This presumes that the
     /// branch instruction is unconditional.
     void ResolveBreaks(llvm::BasicBlock* exit);
     void ResolveContinues(llvm::BasicBlock* entry);

     /// Return true if a cast from V to Ty does not change any bits.
     static bool IsNoopCast(llvm::Value *V, const llvm::Type *Ty);

     /// Cast the \p V  to \p Ty if it is not already that type.
     llvm::Value *CastToType(llvm::Value *V, bool isSigned,
                             const llvm::Type *Ty, bool isSigned,
                             const std::string& newName);

     static void TwoZeroIndices(ArgList& indices) {
       indices.clear();
       indices.push_back(llvm::ConstantInt::getNullValue(llvm::Type::Int32Ty));
       indices.push_back(llvm::ConstantInt::getNullValue(llvm::Type::Int32Ty));
     }

     /// Convert a non-first-class type into a first-class type by constructing
     /// a pointer to the original type.
     const llvm::Type* getFirstClassType(const llvm::Type* Ty) {
       if (!Ty->isFirstClassType())
         return llvm::PointerType::get(Ty);
       return Ty;
     }

     /// Get an LLVM FunctionType for the corresponding arguments. This handles
     /// the details of converting non-first-class arguments and results into
     /// the appropriate pointers to those types and making the first function
     /// argument a pointer to the result storage, if necessary.
     llvm::FunctionType* getFunctionType(
       const std::string& name,       ///< The name to give the function type
       const llvm::Type* resultTy,    ///< The type of the function's result
       const TypeList& args,          ///< The list of the function's arguments
       bool varargs                   ///< Whether its a varargs function or not
     );

     llvm::Type* getTextType();
     llvm::Type* getStreamType();
     llvm::Type* getBufferType();
     llvm::FunctionType* getProgramType();

   /// @}
   /// @name Simple Value getters
   /// @{
   public:
     llvm::Constant* getTrue() const  { return llvm::ConstantInt::getTrue(); }
     llvm::Constant* getFalse() const { return llvm::ConstantInt::getFalse(); }
     llvm::Constant* getZero() const {
       return llvm::ConstantInt::getNullValue(llvm::Type::Int32Ty);
     }
     llvm::Constant* getFOne() const {
       return llvm::ConstantFP::get(llvm::Type::FloatTy,1.0);
     }
     llvm::Constant* getDOne() const {
       return llvm::ConstantFP::get(llvm::Type::DoubleTy,1.0);
     }
     llvm::Constant* getFPOne(const llvm::Type* Ty) const {
       return llvm::ConstantFP::get(Ty,1.0);
     }
     llvm::Constant* getOne(const llvm::Type* Ty) const {
       return llvm::ConstantInt::get(Ty,1);
     }
     llvm::Constant* getSVal(const llvm::Type* Ty, int64_t val) const {
       return llvm::ConstantInt::get(Ty,val);
     }
     llvm::Constant* getUVal(const llvm::Type* Ty, uint64_t val) const {
       return llvm::ConstantInt::get(Ty,val);
     }
     llvm::Constant* getNullValue(const llvm::Type* Ty) const {
       return llvm::Constant::getNullValue(Ty);
     }
     llvm::Constant* getAllOnes(const llvm::Type* Ty) const {
       return llvm::ConstantInt::getAllOnesValue(Ty);
     }
   /// @}
   /// @name Simple emitters
   /// @{
   public:
     llvm::CmpInst* emitNE(llvm::Value* V1, llvm::Value* V2);
     llvm::CmpInst* emitEQ(llvm::Value* V1, llvm::Value* V2);
     llvm::CmpInst* emitLT(llvm::Value* V1, llvm::Value* V2, bool sign = false);
     llvm::CmpInst* emitGT(llvm::Value* V1, llvm::Value* V2, bool sign = false);
     llvm::CmpInst* emitLE(llvm::Value* V1, llvm::Value* V2, bool sign = false);
     llvm::CmpInst* emitGE(llvm::Value* V1, llvm::Value* V2, bool sign = false);

     llvm::LoadInst* emitLoad(llvm::Value* V, const std::string& name) const {
       return new llvm::LoadInst(V, name, TheBlock);
     }
     llvm::StoreInst* emitStore(llvm::Value* from, llvm::Value* to) const {
       return new llvm::StoreInst(from, to, TheBlock);
     }
     llvm::BinaryOperator* emitNeg(llvm::Value* V) const {
       return llvm::BinaryOperator::createNeg(V,"neg",TheBlock);
     }
     llvm::BinaryOperator* emitCmpl(llvm::Value* V) const {
       return llvm::BinaryOperator::create(llvm::Instruction::Xor,
         V, getAllOnes(V->getType()), "cmpl", TheBlock);
     }
     llvm::Constant* emitSizeOf(llvm::Value* V1) {
       return llvm::ConstantExpr::getSizeOf(V1->getType());
     }
     llvm::Constant* emitSizeof(llvm::Type* Ty) {
       return llvm::ConstantExpr::getSizeOf(Ty);
     }
     llvm::BinaryOperator* emitAdd(llvm::Value* V1, llvm::Value* V2) {
       return llvm::BinaryOperator::createAdd(V1, V2, "add", TheBlock);
     }
     llvm::BinaryOperator* emitSub(llvm::Value* V1, llvm::Value* V2) {
       return llvm::BinaryOperator::createSub(V1, V2, "sub", TheBlock);
     }
     llvm::BinaryOperator* emitMul(llvm::Value* V1, llvm::Value* V2) {
       return llvm::BinaryOperator::createMul(V1, V2, "mul", TheBlock);
     }
     llvm::BinaryOperator* emitSDiv(llvm::Value* V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::createSDiv(V1, V2, "div", TheBlock);
     }
     llvm::BinaryOperator* emitUDiv(llvm::Value* V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::createUDiv(V1, V2, "div", TheBlock);
     }
     llvm::BinaryOperator* emitSRem(llvm::Value* V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::createSRem(V1, V2, "mod", TheBlock);
     }
     llvm::BinaryOperator* emitURem(llvm::Value* V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::createURem(V1, V2, "mod", TheBlock);
     }
     llvm::BinaryOperator* emitBAnd(llvm::Value*V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::createAnd(V1, V2, "band", TheBlock);
     }
     llvm::BinaryOperator* emitBOr(llvm::Value*V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::createOr(V1, V2, "bor", TheBlock);
     }
     llvm::BinaryOperator* emitBXor(llvm::Value*V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::createXor(V1, V2, "bxor", TheBlock);
     }
     llvm::BinaryOperator* emitBNor(llvm::Value* V1, llvm::Value* V2) const {
       llvm::BinaryOperator* bor =
         llvm::BinaryOperator::createOr(V1, V2, "bnor", TheBlock);
       return llvm::BinaryOperator::createNot(bor,"bnor",TheBlock);
     }
     llvm::BinaryOperator* emitNot(llvm::Value* V1) const {
       return llvm::BinaryOperator::createNot(
         ConvertToBoolean(V1),"not",TheBlock);
     }
     llvm::BinaryOperator* emitAnd(llvm::Value* V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::create(llvm::Instruction::And,
         ConvertToBoolean(V1), ConvertToBoolean(V2), "and", TheBlock);
     }
     llvm::BinaryOperator* emitOr(llvm::Value* V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::create(llvm::Instruction::Or,
         ConvertToBoolean(V1), ConvertToBoolean(V2), "or", TheBlock);
     }
     llvm::BinaryOperator* emitXor(llvm::Value*V1, llvm::Value* V2) const {
       return llvm::BinaryOperator::create(llvm::Instruction::Xor,
         ConvertToBoolean(V1), ConvertToBoolean(V2), "xor", TheBlock);
     }
     llvm::BinaryOperator* emitNor(llvm::Value* V1, llvm::Value* V2) const {
       llvm::BinaryOperator* op = llvm::BinaryOperator::create(
         llvm::Instruction::Or, ConvertToBoolean(V1), ConvertToBoolean(V2),
         "nor", TheBlock);
       return llvm::BinaryOperator::createNot(op,"nor",TheBlock);
     }
     llvm::SelectInst* emitSelect(llvm::Value* V1, llvm::Value* V2,
       llvm::Value* V3, const std::string& name) {
       return new llvm::SelectInst(V1,V2,V3,name,TheBlock);
     }
     llvm::BranchInst* emitBranch(llvm::BasicBlock* blk) {
       return new llvm::BranchInst(blk,TheBlock);
     }
     llvm::BranchInst* emitBreak() {
       llvm::BranchInst* brnch = new llvm::BranchInst(TheBlock,TheBlock);
       breaks.push_back(brnch);
       return brnch;
     }
     llvm::BranchInst* emitContinue() {
       llvm::BranchInst* brnch = new llvm::BranchInst(TheBlock,TheBlock);
       continues.push_back(brnch);
       return brnch;
     }

     llvm::ReturnInst* emitReturn(llvm::Value* V);

     llvm::CallInst* emitCall(llvm::Function* F, const ArgList& args);

     llvm::GetElementPtrInst* emitGEP(llvm::Value* V, const ArgList& indices) {
       return new llvm::GetElementPtrInst(V, &indices[0], indices.size(), "",
                                          TheBlock);
     }

     llvm::GetElementPtrInst* emitGEP(llvm::Value* V, llvm::Value* index) {
       llvm::Value* indices[2];
       indices[0] = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
       indices[1] = index;
       return new llvm::GetElementPtrInst(V, indices, 2, "",TheBlock);
     }

     /// This method implements an assignment of a src value to a pointer to a
     /// destination value. It handles all cases from a simple store instruction
     /// for first class types, to construction of temporary global variables
     /// for assignment of constant aggregates to variables.
     void emitAssign(llvm::Value* dest, llvm::Value* src);

     /// Copy one aggregate to another. This method will use individual load and
     /// store instructions for small aggregates or the llvm.memcpy intrinsic for
     /// larger ones.
     void emitAggregateCopy(
       llvm::Value *DestPtr,  ///< Pointer to destination aggregate
       llvm::Value *SrcPtr    ///< Pointer to source aggregate
     );

     /// Emit an llvm.memcpy.i64 intrinsic
     void emitMemCpy(
       llvm::Value *dest,  ///< A Pointer type value to receive the data
       llvm::Value *src,   ///< A Pointer type value that is the data source
       llvm::Value *size   ///< A ULong Type value to specify # of bytes to copy
     );

     /// Emit an llvm.memmove.i64 intrinsic
     void emitMemMove(
       llvm::Value *dest,  ///< A Pointer type value to receive the data
       llvm::Value *src,   ///< A Pointer type value that is the data source
       llvm::Value *size   ///< A ULong Type value to specify # of bytes to move
     );

     /// Emit an llvm.memset.i64 intrinsic
     void emitMemSet(
       llvm::Value *dest,  ///< A Pointer type value to receive the data
       llvm::Value *val,   ///< An integer type that specifies the byte to set
       llvm::Value *size   ///< A ULong Type value to specif # of bytes to set
     );

   /// @}
   /// @name Emitters for Stream Operations
   /// @{
   public:
     llvm::CallInst* emitOpen(llvm::Value* strm);
     llvm::CallInst* emitClose(llvm::Value* strm);
     llvm::CallInst* emitRead(llvm::Value* strm,llvm::Value* V2,llvm::Value* V3);
     llvm::CallInst* emitWrite(llvm::Value* strm,llvm::Value*V2);

   /// @}
   /// @name Emitters for Math functions
   /// @{
   public:
     llvm::CallInst* emitIsPInf(llvm::Value* V);
     llvm::CallInst* emitIsNInf(llvm::Value* V);
     llvm::CallInst* emitIsNan(llvm::Value* V);
     llvm::CallInst* emitTrunc(llvm::Value* V);
     llvm::CallInst* emitRound(llvm::Value* V);
     llvm::CallInst* emitFloor(llvm::Value* V);
     llvm::CallInst* emitCeiling(llvm::Value* V);
     llvm::CallInst* emitLogE(llvm::Value* V);
     llvm::CallInst* emitLog2(llvm::Value* V);
     llvm::CallInst* emitLog10(llvm::Value* V);
     llvm::CallInst* emitSquareRoot(llvm::Value* V);
     llvm::CallInst* emitCubeRoot(llvm::Value* V);
     llvm::CallInst* emitFactorial(llvm::Value* V);
     llvm::CallInst* emitPower(llvm::Value* V1,llvm::Value*V2);
     llvm::CallInst* emitRoot(llvm::Value* V1,llvm::Value*V2);
     llvm::CallInst* emitGCD(llvm::Value* V1,llvm::Value*V2);
     llvm::CallInst* emitLCM(llvm::Value* V1,llvm::Value*V2);

   /// @}
   /// @name Other miscellaneous functions
   /// @{
   public:

     /// Return the unique ID of the specified basic
     /// block for uses that take the address of it.
     llvm::Constant *getIndirectGotoBlockNumber(llvm::BasicBlock *BB);

     /// Get (and potentially lazily create) the indirect
     /// goto block.
     llvm::BasicBlock *getIndirectGotoBlock();

     /// Zero the elements of DestPtr.
     void EmitAggregateZero(llvm::Value *DestPtr);

     /// Emit an unconditional branch to the specified basic block, running
     /// cleanups if the branch exits scopes.  The argument specify
     /// how to handle these cleanups.
     void EmitBranchInternal(llvm::BasicBlock *Dest, bool IsExceptionEdge);

     /// Add the specified unconditional branch to the fixup list for the
     /// outermost exception scope, merging it if there is already a fixup that
     /// works.
     void AddBranchFixup(llvm::BranchInst *BI, bool isExceptionEdge);

   /// @}
   /// @name Data Members
   /// @{
   protected:
     BlockStack blocks;              ///< The stack of nested blocks
     BranchList breaks;              ///< The list of breaks to fix up later
     BranchList continues;           ///< The list of continues to fix up later
     llvm::Module *TheModule;        ///< The module that we are compiling into.
     llvm::Function * TheFunction;   ///< The function we're constructing
     llvm::BasicBlock* TheEntryBlock;///< The function's entry block
     llvm::BasicBlock* TheExitBlock; ///< The function's exit (return) block
     llvm::Instruction* EntryInsertionPoint; ///< Insertion point for entry stuff
     llvm::BasicBlock* TheBlock;     ///< The current block we're building
   /// @}
 };

 extern LLVMEmitter* new_LLVMEmitter();

 } // end hlvm namespace

 #endif
	//===-- LLVM Code Emitter Interface ------------------------------ C++ --===//
	//
	// High Level Virtual Machine (HLVM)
	//
	// Copyright (C) 2006 Reid Spencer. All Rights Reserved.
	//
	// This software is free software; you can redistribute it and/or modify it
	// under the terms of the GNU Lesser General Public License as published by
	// the Free Software Foundation; either version 2.1 of the License, or (at
	// your option) any later version.
	//
	// This software is distributed in the hope that it will be useful, but WITHOUT
	// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
	// more details.
	//
	// You should have received a copy of the GNU Lesser General Public License
	// along with this library in the file named LICENSE.txt; if not, write to the
	// Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
	// MA 02110-1301 USA
	//
	//===----------------------------------------------------------------------===//
	/// @file hlvm/CodeGen/LLVMEmitter.h
	/// @author Reid Spencer <rspencer@reidspencer.com> (original author)
	/// @date 2006/07/09
	/// @since 0.2.0
	/// @brief Declares the interface for emitting LLVM code
	//===----------------------------------------------------------------------===//

	#ifndef HLVM_CODEGEN_LLVMEMITTER_H
	#define HLVM_CODEGEN_LLVMEMITTER_H

	// Include the LLVM classes that we use
	#include <llvm/Module.h>
	#include <llvm/PassManager.h>
	#include <llvm/BasicBlock.h>
	#include <llvm/Function.h>
	#include <llvm/GlobalVariable.h>
	#include <llvm/Instructions.h>
	#include <llvm/DerivedTypes.h>
	#include <llvm/TypeSymbolTable.h>
	#include <llvm/Constants.h>
	#include <llvm/CallingConv.h>
	#include "llvm/Support/DataTypes.h"
	#include <vector>

	namespace hlvm {

	/// A simple list of LLVM Modules
	typedef std::vector<llvm::Module*> ModuleList;

	/// A List of LLVM Branch Instructions. These are used to record unconditional
	/// branches that need to be fixed up later with LLVMEmitter::ResolveBranches.
	typedef std::vector<llvm::BranchInst*> BranchList;

	/// A list of LLVM Blocks, presumably used in a push/pop stack fashion.
	typedef std::vector<llvm::BasicBlock*> BlockStack;

	/// A list of LLVM Values, used for argument lists
	typedef std::vector<llvm::Value*> ArgList;

	/// A list of LLVM types, used for function types
	typedef std::vector<const llvm::Type*> TypeList;

	/// This class provides utility functions for emitting LLVM code. It has no
	/// concept of how to translate HLVM into LLVM, that logic is in LLVMGenerator
	/// class. This class just keeps track of things in the LLVM world and provides
	/// a group of methods to take care of the details of emitting LLVM code. The
	/// main purpose for this class is simply to unclutter LLVMGenerator.
	class LLVMEmitter
	{
	/// @name Constructors
	/// @{
	protected:
	LLVMEmitter();

	/// @}
	/// @name Function Emission
	/// @{
	public:

	// Start a new modules
	llvm::Module* StartModule(const std::string& ID);

	// Finish the started module
	llvm::Module* FinishModule();

	/// Start a new function. This sets up the context of the emitter to start
	/// generating code for function \p F.
	void StartFunction(llvm::Function* F);

	/// Finish the function previously started. This must be called after a call
	/// to StartFunction. Mostly this just checks that the generated function is
	/// sane.
	void FinishFunction();

	/// Add a type to the module
	void AddType(const llvm::Type* Ty, const std::string& name)
	{
	TheModule->addTypeName(name, Ty);
	}

	/// Add a Function to the module
	llvm::Function* NewFunction(
	const llvm::FunctionType* Ty,
	llvm::GlobalValue::LinkageTypes LT,
	const std::string& name)
	{
	return new llvm::Function(Ty, LT, name, TheModule);
	}

	/// Add a global variable to the module
	llvm::GlobalVariable* NewGVar(
	const llvm::Type* Ty,
	llvm::GlobalValue::LinkageTypes LT,
	llvm::Constant* init,
	const std::string& name)
	{
	return new llvm::GlobalVariable(Ty, false, LT, init, name, TheModule);
	}
	/// Add a global constant to the module
	llvm::GlobalVariable* NewGConst(
	const llvm::Type* Ty,
	llvm::Constant* init,
	const std::string& name)
	{
	return new llvm::GlobalVariable(Ty, true,
	llvm::GlobalValue::InternalLinkage, init, name, TheModule);
	}

	/// Create a new AllocaInst in the entry block with the given name and type.
	/// The Type must have a fixed/constant size.
	llvm::AllocaInst* NewAutoVar(const llvm::Type* Ty, const std::string& name)
	{
	return new llvm::AllocaInst(Ty, 0, name, EntryInsertionPoint);
	}

	/// Add the specified basic block to the end of the function. If
	/// the previous block falls through into it, add an explicit branch. Also,
	/// manage fixups for EH info.
	void EmitBlock(llvm::BasicBlock *BB);

	/// Create a new LLVM block with the given \p name and push it onto the
	/// block stack.
	llvm::BasicBlock* pushBlock(const std::string& name);

	/// Pop a block off the block stack and return it.
	llvm::BasicBlock* popBlock();

	/// Replace the top of the block stack with a new block with the given
	/// \p name
	llvm::BasicBlock* newBlock(const std::string& name);

	/// @}
	/// @name Simple Helper Functions
	/// @{
	public:
	/// Get the current module we're building
	llvm::Module* getModule() const { return TheModule; }

	/// Get the current function we're building
	llvm::Function* getFunction() const { return TheFunction; }

	/// Get the current block we are filling
	llvm::BasicBlock* getBlock() const { return TheBlock; }

	/// Get the name of the current block we're inserting into
	std::string getBlockName() const {
	return TheBlock->getName();
	}
	// Get the terminating instruction of the current block
	llvm::Instruction* getBlockTerminator() const {
	return TheBlock->getTerminator();
	}
	// Get the return type of the current function
	const llvm::Type* getReturnType() const {
	return TheFunction->getReturnType();
	}

	/// Return the total number of elements in the Type, examining recursively,
	/// any nested aggregate types.
	unsigned getNumElements(const llvm::Type *Ty);

	/// Return a constant expression for indexing into the first element of
	/// a constant global variable.
	llvm::Constant* getFirstElement(llvm::GlobalVariable* GV);

	/// If V is a PointerType then load its value unless the referent type is
	/// not first class type
	llvm::Value* Pointer2Value(llvm::Value* V) const;

	/// Convert the value V into a Boolean value.
	llvm::Value* ConvertToBoolean(llvm::Value* V) const;

	/// Run through the \p list and set the first operand of each branch
	/// instruction found there to the \p exit block. This presumes that the
	/// branch instruction is unconditional.
	void ResolveBreaks(llvm::BasicBlock* exit);
	void ResolveContinues(llvm::BasicBlock* entry);

	/// Return true if a cast from V to Ty does not change any bits.
	static bool IsNoopCast(llvm::Value V, const llvm::Type Ty);

	/// Cast the \p V to \p Ty if it is not already that type.
	llvm::Value CastToType(llvm::Value V, bool isSigned,
	const llvm::Type *Ty, bool isSigned,
	const std::string& newName);

	static void TwoZeroIndices(ArgList& indices) {
	indices.clear();
	indices.push_back(llvm::ConstantInt::getNullValue(llvm::Type::Int32Ty));
	indices.push_back(llvm::ConstantInt::getNullValue(llvm::Type::Int32Ty));
	}

	/// Convert a non-first-class type into a first-class type by constructing
	/// a pointer to the original type.
	const llvm::Type* getFirstClassType(const llvm::Type* Ty) {
	if (!Ty->isFirstClassType())
	return llvm::PointerType::get(Ty);
	return Ty;
	}

	/// Get an LLVM FunctionType for the corresponding arguments. This handles
	/// the details of converting non-first-class arguments and results into
	/// the appropriate pointers to those types and making the first function
	/// argument a pointer to the result storage, if necessary.
	llvm::FunctionType* getFunctionType(
	const std::string& name, ///< The name to give the function type
	const llvm::Type* resultTy, ///< The type of the function's result
	const TypeList& args, ///< The list of the function's arguments
	bool varargs ///< Whether its a varargs function or not
	);

	llvm::Type* getTextType();
	llvm::Type* getStreamType();
	llvm::Type* getBufferType();
	llvm::FunctionType* getProgramType();

	/// @}
	/// @name Simple Value getters
	/// @{
	public:
	llvm::Constant* getTrue() const { return llvm::ConstantInt::getTrue(); }
	llvm::Constant* getFalse() const { return llvm::ConstantInt::getFalse(); }
	llvm::Constant* getZero() const {
	return llvm::ConstantInt::getNullValue(llvm::Type::Int32Ty);
	}
	llvm::Constant* getFOne() const {
	return llvm::ConstantFP::get(llvm::Type::FloatTy,1.0);
	}
	llvm::Constant* getDOne() const {
	return llvm::ConstantFP::get(llvm::Type::DoubleTy,1.0);
	}
	llvm::Constant* getFPOne(const llvm::Type* Ty) const {
	return llvm::ConstantFP::get(Ty,1.0);
	}
	llvm::Constant* getOne(const llvm::Type* Ty) const {
	return llvm::ConstantInt::get(Ty,1);
	}
	llvm::Constant* getSVal(const llvm::Type* Ty, int64_t val) const {
	return llvm::ConstantInt::get(Ty,val);
	}
	llvm::Constant* getUVal(const llvm::Type* Ty, uint64_t val) const {
	return llvm::ConstantInt::get(Ty,val);
	}
	llvm::Constant* getNullValue(const llvm::Type* Ty) const {
	return llvm::Constant::getNullValue(Ty);
	}
	llvm::Constant* getAllOnes(const llvm::Type* Ty) const {
	return llvm::ConstantInt::getAllOnesValue(Ty);
	}
	/// @}
	/// @name Simple emitters
	/// @{
	public:
	llvm::CmpInst* emitNE(llvm::Value* V1, llvm::Value* V2);
	llvm::CmpInst* emitEQ(llvm::Value* V1, llvm::Value* V2);
	llvm::CmpInst* emitLT(llvm::Value* V1, llvm::Value* V2, bool sign = false);
	llvm::CmpInst* emitGT(llvm::Value* V1, llvm::Value* V2, bool sign = false);
	llvm::CmpInst* emitLE(llvm::Value* V1, llvm::Value* V2, bool sign = false);
	llvm::CmpInst* emitGE(llvm::Value* V1, llvm::Value* V2, bool sign = false);

	llvm::LoadInst* emitLoad(llvm::Value* V, const std::string& name) const {
	return new llvm::LoadInst(V, name, TheBlock);
	}
	llvm::StoreInst* emitStore(llvm::Value* from, llvm::Value* to) const {
	return new llvm::StoreInst(from, to, TheBlock);
	}
	llvm::BinaryOperator* emitNeg(llvm::Value* V) const {
	return llvm::BinaryOperator::createNeg(V,"neg",TheBlock);
	}
	llvm::BinaryOperator* emitCmpl(llvm::Value* V) const {
	return llvm::BinaryOperator::create(llvm::Instruction::Xor,
	V, getAllOnes(V->getType()), "cmpl", TheBlock);
	}
	llvm::Constant* emitSizeOf(llvm::Value* V1) {
	return llvm::ConstantExpr::getSizeOf(V1->getType());
	}
	llvm::Constant* emitSizeof(llvm::Type* Ty) {
	return llvm::ConstantExpr::getSizeOf(Ty);
	}
	llvm::BinaryOperator* emitAdd(llvm::Value* V1, llvm::Value* V2) {
	return llvm::BinaryOperator::createAdd(V1, V2, "add", TheBlock);
	}
	llvm::BinaryOperator* emitSub(llvm::Value* V1, llvm::Value* V2) {
	return llvm::BinaryOperator::createSub(V1, V2, "sub", TheBlock);
	}
	llvm::BinaryOperator* emitMul(llvm::Value* V1, llvm::Value* V2) {
	return llvm::BinaryOperator::createMul(V1, V2, "mul", TheBlock);
	}
	llvm::BinaryOperator* emitSDiv(llvm::Value* V1, llvm::Value* V2) const {
	return llvm::BinaryOperator::createSDiv(V1, V2, "div", TheBlock);
	}
	llvm::BinaryOperator* emitUDiv(llvm::Value* V1, llvm::Value* V2) const {
	return llvm::BinaryOperator::createUDiv(V1, V2, "div", TheBlock);
	}
	llvm::BinaryOperator* emitSRem(llvm::Value* V1, llvm::Value* V2) const {
	return llvm::BinaryOperator::createSRem(V1, V2, "mod", TheBlock);
	}
	llvm::BinaryOperator* emitURem(llvm::Value* V1, llvm::Value* V2) const {
	return llvm::BinaryOperator::createURem(V1, V2, "mod", TheBlock);
	}
	llvm::BinaryOperator* emitBAnd(llvm::ValueV1, llvm::Value V2) const {
	return llvm::BinaryOperator::createAnd(V1, V2, "band", TheBlock);
	}
	llvm::BinaryOperator* emitBOr(llvm::ValueV1, llvm::Value V2) const {
	return llvm::BinaryOperator::createOr(V1, V2, "bor", TheBlock);
	}
	llvm::BinaryOperator* emitBXor(llvm::ValueV1, llvm::Value V2) const {
	return llvm::BinaryOperator::createXor(V1, V2, "bxor", TheBlock);
	}
	llvm::BinaryOperator* emitBNor(llvm::Value* V1, llvm::Value* V2) const {
	llvm::BinaryOperator* bor =
	llvm::BinaryOperator::createOr(V1, V2, "bnor", TheBlock);
	return llvm::BinaryOperator::createNot(bor,"bnor",TheBlock);
	}
	llvm::BinaryOperator* emitNot(llvm::Value* V1) const {
	return llvm::BinaryOperator::createNot(
	ConvertToBoolean(V1),"not",TheBlock);
	}
	llvm::BinaryOperator* emitAnd(llvm::Value* V1, llvm::Value* V2) const {
	return llvm::BinaryOperator::create(llvm::Instruction::And,
	ConvertToBoolean(V1), ConvertToBoolean(V2), "and", TheBlock);
	}
	llvm::BinaryOperator* emitOr(llvm::Value* V1, llvm::Value* V2) const {
	return llvm::BinaryOperator::create(llvm::Instruction::Or,
	ConvertToBoolean(V1), ConvertToBoolean(V2), "or", TheBlock);
	}
	llvm::BinaryOperator* emitXor(llvm::ValueV1, llvm::Value V2) const {
	return llvm::BinaryOperator::create(llvm::Instruction::Xor,
	ConvertToBoolean(V1), ConvertToBoolean(V2), "xor", TheBlock);
	}
	llvm::BinaryOperator* emitNor(llvm::Value* V1, llvm::Value* V2) const {
	llvm::BinaryOperator* op = llvm::BinaryOperator::create(
	llvm::Instruction::Or, ConvertToBoolean(V1), ConvertToBoolean(V2),
	"nor", TheBlock);
	return llvm::BinaryOperator::createNot(op,"nor",TheBlock);
	}
	llvm::SelectInst* emitSelect(llvm::Value* V1, llvm::Value* V2,
	llvm::Value* V3, const std::string& name) {
	return new llvm::SelectInst(V1,V2,V3,name,TheBlock);
	}
	llvm::BranchInst* emitBranch(llvm::BasicBlock* blk) {
	return new llvm::BranchInst(blk,TheBlock);
	}
	llvm::BranchInst* emitBreak() {
	llvm::BranchInst* brnch = new llvm::BranchInst(TheBlock,TheBlock);
	breaks.push_back(brnch);
	return brnch;
	}
	llvm::BranchInst* emitContinue() {
	llvm::BranchInst* brnch = new llvm::BranchInst(TheBlock,TheBlock);
	continues.push_back(brnch);
	return brnch;
	}

	llvm::ReturnInst* emitReturn(llvm::Value* V);

	llvm::CallInst* emitCall(llvm::Function* F, const ArgList& args);

	llvm::GetElementPtrInst* emitGEP(llvm::Value* V, const ArgList& indices) {
	return new llvm::GetElementPtrInst(V, &indices[0], indices.size(), "",
	TheBlock);
	}

	llvm::GetElementPtrInst* emitGEP(llvm::Value* V, llvm::Value* index) {
	llvm::Value* indices[2];
	indices[0] = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
	indices[1] = index;
	return new llvm::GetElementPtrInst(V, indices, 2, "",TheBlock);
	}

	/// This method implements an assignment of a src value to a pointer to a
	/// destination value. It handles all cases from a simple store instruction
	/// for first class types, to construction of temporary global variables
	/// for assignment of constant aggregates to variables.
	void emitAssign(llvm::Value* dest, llvm::Value* src);

	/// Copy one aggregate to another. This method will use individual load and
	/// store instructions for small aggregates or the llvm.memcpy intrinsic for
	/// larger ones.
	void emitAggregateCopy(
	llvm::Value *DestPtr, ///< Pointer to destination aggregate
	llvm::Value *SrcPtr ///< Pointer to source aggregate
	);

	/// Emit an llvm.memcpy.i64 intrinsic
	void emitMemCpy(
	llvm::Value *dest, ///< A Pointer type value to receive the data
	llvm::Value *src, ///< A Pointer type value that is the data source
	llvm::Value *size ///< A ULong Type value to specify # of bytes to copy
	);

	/// Emit an llvm.memmove.i64 intrinsic
	void emitMemMove(
	llvm::Value *dest, ///< A Pointer type value to receive the data
	llvm::Value *src, ///< A Pointer type value that is the data source
	llvm::Value *size ///< A ULong Type value to specify # of bytes to move
	);

	/// Emit an llvm.memset.i64 intrinsic
	void emitMemSet(
	llvm::Value *dest, ///< A Pointer type value to receive the data
	llvm::Value *val, ///< An integer type that specifies the byte to set
	llvm::Value *size ///< A ULong Type value to specif # of bytes to set
	);

	/// @}
	/// @name Emitters for Stream Operations
	/// @{
	public:
	llvm::CallInst* emitOpen(llvm::Value* strm);
	llvm::CallInst* emitClose(llvm::Value* strm);
	llvm::CallInst* emitRead(llvm::Value* strm,llvm::Value* V2,llvm::Value* V3);
	llvm::CallInst* emitWrite(llvm::Value* strm,llvm::Value*V2);

	/// @}
	/// @name Emitters for Math functions
	/// @{
	public:
	llvm::CallInst* emitIsPInf(llvm::Value* V);
	llvm::CallInst* emitIsNInf(llvm::Value* V);
	llvm::CallInst* emitIsNan(llvm::Value* V);
	llvm::CallInst* emitTrunc(llvm::Value* V);
	llvm::CallInst* emitRound(llvm::Value* V);
	llvm::CallInst* emitFloor(llvm::Value* V);
	llvm::CallInst* emitCeiling(llvm::Value* V);
	llvm::CallInst* emitLogE(llvm::Value* V);
	llvm::CallInst* emitLog2(llvm::Value* V);
	llvm::CallInst* emitLog10(llvm::Value* V);
	llvm::CallInst* emitSquareRoot(llvm::Value* V);
	llvm::CallInst* emitCubeRoot(llvm::Value* V);
	llvm::CallInst* emitFactorial(llvm::Value* V);
	llvm::CallInst* emitPower(llvm::Value* V1,llvm::Value*V2);
	llvm::CallInst* emitRoot(llvm::Value* V1,llvm::Value*V2);
	llvm::CallInst* emitGCD(llvm::Value* V1,llvm::Value*V2);
	llvm::CallInst* emitLCM(llvm::Value* V1,llvm::Value*V2);

	/// @}
	/// @name Other miscellaneous functions
	/// @{
	public:

	/// Return the unique ID of the specified basic
	/// block for uses that take the address of it.
	llvm::Constant getIndirectGotoBlockNumber(llvm::BasicBlock BB);

	/// Get (and potentially lazily create) the indirect
	/// goto block.
	llvm::BasicBlock *getIndirectGotoBlock();

	/// Zero the elements of DestPtr.
	void EmitAggregateZero(llvm::Value *DestPtr);

	/// Emit an unconditional branch to the specified basic block, running
	/// cleanups if the branch exits scopes. The argument specify
	/// how to handle these cleanups.
	void EmitBranchInternal(llvm::BasicBlock *Dest, bool IsExceptionEdge);

	/// Add the specified unconditional branch to the fixup list for the
	/// outermost exception scope, merging it if there is already a fixup that
	/// works.
	void AddBranchFixup(llvm::BranchInst *BI, bool isExceptionEdge);

	/// @}
	/// @name Data Members
	/// @{
	protected:
	BlockStack blocks; ///< The stack of nested blocks
	BranchList breaks; ///< The list of breaks to fix up later
	BranchList continues; ///< The list of continues to fix up later
	llvm::Module *TheModule; ///< The module that we are compiling into.
	llvm::Function * TheFunction; ///< The function we're constructing
	llvm::BasicBlock* TheEntryBlock;///< The function's entry block
	llvm::BasicBlock* TheExitBlock; ///< The function's exit (return) block
	llvm::Instruction* EntryInsertionPoint; ///< Insertion point for entry stuff
	llvm::BasicBlock* TheBlock; ///< The current block we're building
	/// @}
	};

	extern LLVMEmitter* new_LLVMEmitter();

	} // end hlvm namespace

	#endif