Move all of the header files which are involved in modelling the LLVM IR
authorChandler Carruth <chandlerc@gmail.com>
Wed, 2 Jan 2013 11:36:10 +0000 (11:36 +0000)
committerChandler Carruth <chandlerc@gmail.com>
Wed, 2 Jan 2013 11:36:10 +0000 (11:36 +0000)
into their new header subdirectory: include/llvm/IR. This matches the
directory structure of lib, and begins to correct a long standing point
of file layout clutter in LLVM.

There are still more header files to move here, but I wanted to handle
them in separate commits to make tracking what files make sense at each
layer easier.

The only really questionable files here are the target intrinsic
tablegen files. But that's a battle I'd rather not fight today.

I've updated both CMake and Makefile build systems (I think, and my
tests think, but I may have missed something).

I've also re-sorted the includes throughout the project. I'll be
committing updates to Clang, DragonEgg, and Polly momentarily.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171366 91177308-0d34-0410-b5e6-96231b3b80d8

645 files changed:
Makefile.rules
include/llvm-c/Core.h
include/llvm/Analysis/BlockFrequencyImpl.h
include/llvm/Analysis/CFGPrinter.h
include/llvm/Analysis/CallGraph.h
include/llvm/Analysis/CaptureTracking.h
include/llvm/Analysis/DependenceAnalysis.h
include/llvm/Analysis/Dominators.h
include/llvm/Analysis/InlineCost.h
include/llvm/Analysis/InstructionSimplify.h
include/llvm/Analysis/IntervalIterator.h
include/llvm/Analysis/Loads.h
include/llvm/Analysis/LoopPass.h
include/llvm/Analysis/MemoryBuiltins.h
include/llvm/Analysis/MemoryDependenceAnalysis.h
include/llvm/Analysis/PHITransAddr.h
include/llvm/Analysis/PathNumbering.h
include/llvm/Analysis/PathProfileInfo.h
include/llvm/Analysis/PtrUseVisitor.h
include/llvm/Analysis/RegionPass.h
include/llvm/Analysis/ScalarEvolution.h
include/llvm/Analysis/ScalarEvolutionExpander.h
include/llvm/Argument.h [deleted file]
include/llvm/Attributes.h [deleted file]
include/llvm/BasicBlock.h [deleted file]
include/llvm/CMakeLists.txt
include/llvm/CallingConv.h [deleted file]
include/llvm/CodeGen/Analysis.h
include/llvm/CodeGen/AsmPrinter.h
include/llvm/CodeGen/CallingConvLower.h
include/llvm/CodeGen/FunctionLoweringInfo.h
include/llvm/CodeGen/IntrinsicLowering.h
include/llvm/CodeGen/LexicalScopes.h
include/llvm/CodeGen/MachineInstr.h
include/llvm/CodeGen/MachineModuleInfo.h
include/llvm/CodeGen/PseudoSourceValue.h
include/llvm/CodeGen/SelectionDAGISel.h
include/llvm/CodeGen/SelectionDAGNodes.h
include/llvm/Constant.h [deleted file]
include/llvm/Constants.h [deleted file]
include/llvm/DataLayout.h [deleted file]
include/llvm/DerivedTypes.h [deleted file]
include/llvm/Function.h [deleted file]
include/llvm/GlobalAlias.h [deleted file]
include/llvm/GlobalValue.h [deleted file]
include/llvm/GlobalVariable.h [deleted file]
include/llvm/IR/Argument.h [new file with mode: 0644]
include/llvm/IR/Attributes.h [new file with mode: 0644]
include/llvm/IR/BasicBlock.h [new file with mode: 0644]
include/llvm/IR/CMakeLists.txt [new file with mode: 0644]
include/llvm/IR/CallingConv.h [new file with mode: 0644]
include/llvm/IR/Constant.h [new file with mode: 0644]
include/llvm/IR/Constants.h [new file with mode: 0644]
include/llvm/IR/DataLayout.h [new file with mode: 0644]
include/llvm/IR/DerivedTypes.h [new file with mode: 0644]
include/llvm/IR/Function.h [new file with mode: 0644]
include/llvm/IR/GlobalAlias.h [new file with mode: 0644]
include/llvm/IR/GlobalValue.h [new file with mode: 0644]
include/llvm/IR/GlobalVariable.h [new file with mode: 0644]
include/llvm/IR/IRBuilder.h [new file with mode: 0644]
include/llvm/IR/InlineAsm.h [new file with mode: 0644]
include/llvm/IR/InstrTypes.h [new file with mode: 0644]
include/llvm/IR/Instruction.def [new file with mode: 0644]
include/llvm/IR/Instruction.h [new file with mode: 0644]
include/llvm/IR/Instructions.h [new file with mode: 0644]
include/llvm/IR/IntrinsicInst.h [new file with mode: 0644]
include/llvm/IR/Intrinsics.h [new file with mode: 0644]
include/llvm/IR/Intrinsics.td [new file with mode: 0644]
include/llvm/IR/IntrinsicsARM.td [new file with mode: 0644]
include/llvm/IR/IntrinsicsHexagon.td [new file with mode: 0644]
include/llvm/IR/IntrinsicsMips.td [new file with mode: 0644]
include/llvm/IR/IntrinsicsNVVM.td [new file with mode: 0644]
include/llvm/IR/IntrinsicsPowerPC.td [new file with mode: 0644]
include/llvm/IR/IntrinsicsR600.td [new file with mode: 0644]
include/llvm/IR/IntrinsicsX86.td [new file with mode: 0644]
include/llvm/IR/IntrinsicsXCore.td [new file with mode: 0644]
include/llvm/IR/LLVMContext.h [new file with mode: 0644]
include/llvm/IR/MDBuilder.h [new file with mode: 0644]
include/llvm/IR/Metadata.h [new file with mode: 0644]
include/llvm/IR/Module.h [new file with mode: 0644]
include/llvm/IR/OperandTraits.h [new file with mode: 0644]
include/llvm/IR/Operator.h [new file with mode: 0644]
include/llvm/IR/SymbolTableListTraits.h [new file with mode: 0644]
include/llvm/IR/Type.h [new file with mode: 0644]
include/llvm/IR/TypeBuilder.h [new file with mode: 0644]
include/llvm/IR/Use.h [new file with mode: 0644]
include/llvm/IR/User.h [new file with mode: 0644]
include/llvm/IR/Value.h [new file with mode: 0644]
include/llvm/IR/ValueSymbolTable.h [new file with mode: 0644]
include/llvm/IRBuilder.h [deleted file]
include/llvm/InlineAsm.h [deleted file]
include/llvm/InstVisitor.h
include/llvm/InstrTypes.h [deleted file]
include/llvm/Instruction.def [deleted file]
include/llvm/Instruction.h [deleted file]
include/llvm/Instructions.h [deleted file]
include/llvm/IntrinsicInst.h [deleted file]
include/llvm/Intrinsics.h [deleted file]
include/llvm/Intrinsics.td [deleted file]
include/llvm/IntrinsicsARM.td [deleted file]
include/llvm/IntrinsicsHexagon.td [deleted file]
include/llvm/IntrinsicsMips.td [deleted file]
include/llvm/IntrinsicsNVVM.td [deleted file]
include/llvm/IntrinsicsPowerPC.td [deleted file]
include/llvm/IntrinsicsR600.td [deleted file]
include/llvm/IntrinsicsX86.td [deleted file]
include/llvm/IntrinsicsXCore.td [deleted file]
include/llvm/LLVMContext.h [deleted file]
include/llvm/LinkAllPasses.h
include/llvm/LinkAllVMCore.h
include/llvm/MDBuilder.h [deleted file]
include/llvm/Metadata.h [deleted file]
include/llvm/Module.h [deleted file]
include/llvm/OperandTraits.h [deleted file]
include/llvm/Operator.h [deleted file]
include/llvm/Support/CFG.h
include/llvm/Support/CallSite.h
include/llvm/Support/ConstantFolder.h
include/llvm/Support/DataFlow.h
include/llvm/Support/GetElementPtrTypeIterator.h
include/llvm/Support/InstIterator.h
include/llvm/Support/IntegersSubset.h
include/llvm/Support/NoFolder.h
include/llvm/Support/PatternMatch.h
include/llvm/Support/TargetFolder.h
include/llvm/Support/ValueHandle.h
include/llvm/SymbolTableListTraits.h [deleted file]
include/llvm/Target/Target.td
include/llvm/Target/TargetLowering.h
include/llvm/Target/TargetLoweringObjectFile.h
include/llvm/Target/TargetRegisterInfo.h
include/llvm/TargetTransformInfo.h
include/llvm/Transforms/Utils/BasicBlockUtils.h
include/llvm/Transforms/Utils/BuildLibCalls.h
include/llvm/Transforms/Utils/BypassSlowDivision.h
include/llvm/Transforms/Utils/CmpInstAnalysis.h
include/llvm/Transforms/Utils/Local.h
include/llvm/Type.h [deleted file]
include/llvm/TypeBuilder.h [deleted file]
include/llvm/Use.h [deleted file]
include/llvm/User.h [deleted file]
include/llvm/Value.h [deleted file]
include/llvm/ValueSymbolTable.h [deleted file]
lib/Analysis/AliasAnalysis.cpp
lib/Analysis/AliasAnalysisEvaluator.cpp
lib/Analysis/AliasDebugger.cpp
lib/Analysis/AliasSetTracker.cpp
lib/Analysis/BasicAliasAnalysis.cpp
lib/Analysis/BranchProbabilityInfo.cpp
lib/Analysis/CodeMetrics.cpp
lib/Analysis/ConstantFolding.cpp
lib/Analysis/CostModel.cpp
lib/Analysis/DbgInfoPrinter.cpp
lib/Analysis/DependenceAnalysis.cpp
lib/Analysis/IPA/CallGraph.cpp
lib/Analysis/IPA/CallGraphSCCPass.cpp
lib/Analysis/IPA/FindUsedTypes.cpp
lib/Analysis/IPA/GlobalsModRef.cpp
lib/Analysis/IVUsers.cpp
lib/Analysis/InlineCost.cpp
lib/Analysis/InstCount.cpp
lib/Analysis/InstructionSimplify.cpp
lib/Analysis/Interval.cpp
lib/Analysis/LazyValueInfo.cpp
lib/Analysis/LibCallAliasAnalysis.cpp
lib/Analysis/LibCallSemantics.cpp
lib/Analysis/Lint.cpp
lib/Analysis/Loads.cpp
lib/Analysis/LoopInfo.cpp
lib/Analysis/MemDepPrinter.cpp
lib/Analysis/MemoryBuiltins.cpp
lib/Analysis/MemoryDependenceAnalysis.cpp
lib/Analysis/ModuleDebugInfoPrinter.cpp
lib/Analysis/NoAliasAnalysis.cpp
lib/Analysis/PHITransAddr.cpp
lib/Analysis/PathNumbering.cpp
lib/Analysis/PathProfileInfo.cpp
lib/Analysis/PathProfileVerifier.cpp
lib/Analysis/PostDominators.cpp
lib/Analysis/ProfileDataLoader.cpp
lib/Analysis/ProfileDataLoaderPass.cpp
lib/Analysis/ProfileInfoLoader.cpp
lib/Analysis/ProfileInfoLoaderPass.cpp
lib/Analysis/ProfileVerifierPass.cpp
lib/Analysis/ScalarEvolution.cpp
lib/Analysis/ScalarEvolutionExpander.cpp
lib/Analysis/SparsePropagation.cpp
lib/Analysis/Trace.cpp
lib/Analysis/TypeBasedAliasAnalysis.cpp
lib/Analysis/ValueTracking.cpp
lib/Archive/Archive.cpp
lib/Archive/ArchiveReader.cpp
lib/Archive/ArchiveWriter.cpp
lib/AsmParser/LLLexer.cpp
lib/AsmParser/LLParser.cpp
lib/AsmParser/LLParser.h
lib/AsmParser/Parser.cpp
lib/Bitcode/Reader/BitReader.cpp
lib/Bitcode/Reader/BitcodeReader.cpp
lib/Bitcode/Reader/BitcodeReader.h
lib/Bitcode/Writer/BitcodeWriter.cpp
lib/Bitcode/Writer/ValueEnumerator.cpp
lib/Bitcode/Writer/ValueEnumerator.h
lib/CodeGen/Analysis.cpp
lib/CodeGen/AsmPrinter/ARMException.cpp
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
lib/CodeGen/AsmPrinter/DIE.cpp
lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
lib/CodeGen/AsmPrinter/DwarfException.cpp
lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp
lib/CodeGen/AsmPrinter/Win64Exception.cpp
lib/CodeGen/BranchFolding.cpp
lib/CodeGen/CallingConvLower.cpp
lib/CodeGen/DwarfEHPrepare.cpp
lib/CodeGen/GCMetadata.cpp
lib/CodeGen/GCStrategy.cpp
lib/CodeGen/IntrinsicLowering.cpp
lib/CodeGen/LexicalScopes.cpp
lib/CodeGen/LiveDebugVariables.cpp
lib/CodeGen/LiveIntervalAnalysis.cpp
lib/CodeGen/LocalStackSlotAllocation.cpp
lib/CodeGen/MachineBasicBlock.cpp
lib/CodeGen/MachineBranchProbabilityInfo.cpp
lib/CodeGen/MachineFunction.cpp
lib/CodeGen/MachineFunctionPass.cpp
lib/CodeGen/MachineInstr.cpp
lib/CodeGen/MachineModuleInfo.cpp
lib/CodeGen/MachineVerifier.cpp
lib/CodeGen/OptimizePHIs.cpp
lib/CodeGen/PHIElimination.cpp
lib/CodeGen/PrologEpilogInserter.cpp
lib/CodeGen/PseudoSourceValue.cpp
lib/CodeGen/RegAllocFast.cpp
lib/CodeGen/RegAllocPBQP.cpp
lib/CodeGen/RegisterCoalescer.cpp
lib/CodeGen/ScheduleDAGInstrs.cpp
lib/CodeGen/ScheduleDAGPrinter.cpp
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
lib/CodeGen/SelectionDAG/FastISel.cpp
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
lib/CodeGen/SelectionDAG/InstrEmitter.cpp
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp
lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp
lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp
lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp
lib/CodeGen/SelectionDAG/ScheduleDAGVLIW.cpp
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h
lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp
lib/CodeGen/SelectionDAG/TargetLowering.cpp
lib/CodeGen/ShadowStackGC.cpp
lib/CodeGen/SjLjEHPrepare.cpp
lib/CodeGen/StackColoring.cpp
lib/CodeGen/StackProtector.cpp
lib/CodeGen/StackSlotColoring.cpp
lib/CodeGen/TailDuplication.cpp
lib/CodeGen/TargetLoweringObjectFileImpl.cpp
lib/CodeGen/TwoAddressInstructionPass.cpp
lib/CodeGen/UnreachableBlockElim.cpp
lib/ExecutionEngine/EventListenerCommon.h
lib/ExecutionEngine/ExecutionEngine.cpp
lib/ExecutionEngine/IntelJITEvents/IntelJITEventListener.cpp
lib/ExecutionEngine/Interpreter/Execution.cpp
lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
lib/ExecutionEngine/Interpreter/Interpreter.cpp
lib/ExecutionEngine/Interpreter/Interpreter.h
lib/ExecutionEngine/JIT/JIT.cpp
lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp
lib/ExecutionEngine/JIT/JITEmitter.cpp
lib/ExecutionEngine/JIT/JITMemoryManager.cpp
lib/ExecutionEngine/MCJIT/MCJIT.cpp
lib/ExecutionEngine/OProfileJIT/OProfileJITEventListener.cpp
lib/ExecutionEngine/TargetSelect.cpp
lib/IR/AsmWriter.cpp
lib/IR/AttributeImpl.h
lib/IR/Attributes.cpp
lib/IR/AutoUpgrade.cpp
lib/IR/BasicBlock.cpp
lib/IR/ConstantFold.cpp
lib/IR/Constants.cpp
lib/IR/ConstantsContext.h
lib/IR/Core.cpp
lib/IR/DIBuilder.cpp
lib/IR/DataLayout.cpp
lib/IR/DebugInfo.cpp
lib/IR/Dominators.cpp
lib/IR/Function.cpp
lib/IR/Globals.cpp
lib/IR/IRBuilder.cpp
lib/IR/InlineAsm.cpp
lib/IR/Instruction.cpp
lib/IR/Instructions.cpp
lib/IR/IntrinsicInst.cpp
lib/IR/LLVMContext.cpp
lib/IR/LLVMContextImpl.cpp
lib/IR/LLVMContextImpl.h
lib/IR/LeakDetector.cpp
lib/IR/LeaksContext.h
lib/IR/Makefile
lib/IR/Metadata.cpp
lib/IR/Module.cpp
lib/IR/PassManager.cpp
lib/IR/PassRegistry.cpp
lib/IR/PrintModulePass.cpp
lib/IR/SymbolTableListTraitsImpl.h
lib/IR/Type.cpp
lib/IR/TypeFinder.cpp
lib/IR/Use.cpp
lib/IR/User.cpp
lib/IR/Value.cpp
lib/IR/ValueSymbolTable.cpp
lib/IR/ValueTypes.cpp
lib/IR/Verifier.cpp
lib/Linker/LinkArchives.cpp
lib/Linker/LinkItems.cpp
lib/Linker/LinkModules.cpp
lib/Linker/Linker.cpp
lib/Support/ConstantRange.cpp
lib/Target/ARM/ARMAsmPrinter.cpp
lib/Target/ARM/ARMBaseInstrInfo.cpp
lib/Target/ARM/ARMBaseRegisterInfo.cpp
lib/Target/ARM/ARMCallingConv.h
lib/Target/ARM/ARMCodeEmitter.cpp
lib/Target/ARM/ARMConstantIslandPass.cpp
lib/Target/ARM/ARMConstantPoolValue.cpp
lib/Target/ARM/ARMFastISel.cpp
lib/Target/ARM/ARMFrameLowering.cpp
lib/Target/ARM/ARMISelDAGToDAG.cpp
lib/Target/ARM/ARMISelLowering.cpp
lib/Target/ARM/ARMInstrInfo.cpp
lib/Target/ARM/ARMJITInfo.cpp
lib/Target/ARM/ARMLoadStoreOptimizer.cpp
lib/Target/ARM/ARMMCInstLower.cpp
lib/Target/ARM/ARMSelectionDAGInfo.cpp
lib/Target/ARM/ARMSubtarget.cpp
lib/Target/ARM/ARMTargetMachine.h
lib/Target/ARM/TargetInfo/ARMTargetInfo.cpp
lib/Target/ARM/Thumb1RegisterInfo.cpp
lib/Target/ARM/Thumb2RegisterInfo.cpp
lib/Target/ARM/Thumb2SizeReduction.cpp
lib/Target/CppBackend/CPPBackend.cpp
lib/Target/CppBackend/CPPTargetMachine.h
lib/Target/CppBackend/TargetInfo/CppBackendTargetInfo.cpp
lib/Target/Hexagon/HexagonAsmPrinter.cpp
lib/Target/Hexagon/HexagonCallingConvLower.cpp
lib/Target/Hexagon/HexagonFrameLowering.cpp
lib/Target/Hexagon/HexagonHardwareLoops.cpp
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
lib/Target/Hexagon/HexagonISelLowering.cpp
lib/Target/Hexagon/HexagonISelLowering.h
lib/Target/Hexagon/HexagonMCInstLower.cpp
lib/Target/Hexagon/HexagonPeephole.cpp
lib/Target/Hexagon/HexagonRegisterInfo.cpp
lib/Target/Hexagon/HexagonRemoveSZExtArgs.cpp
lib/Target/Hexagon/HexagonTargetMachine.cpp
lib/Target/Hexagon/HexagonTargetMachine.h
lib/Target/Hexagon/HexagonTargetObjectFile.cpp
lib/Target/Hexagon/TargetInfo/HexagonTargetInfo.cpp
lib/Target/MBlaze/MBlazeAsmPrinter.cpp
lib/Target/MBlaze/MBlazeFrameLowering.cpp
lib/Target/MBlaze/MBlazeISelDAGToDAG.cpp
lib/Target/MBlaze/MBlazeISelLowering.cpp
lib/Target/MBlaze/MBlazeIntrinsicInfo.cpp
lib/Target/MBlaze/MBlazeMCInstLower.cpp
lib/Target/MBlaze/MBlazeRegisterInfo.cpp
lib/Target/MBlaze/MBlazeTargetMachine.h
lib/Target/MBlaze/MBlazeTargetObjectFile.cpp
lib/Target/MBlaze/TargetInfo/MBlazeTargetInfo.cpp
lib/Target/MSP430/MSP430AsmPrinter.cpp
lib/Target/MSP430/MSP430FrameLowering.cpp
lib/Target/MSP430/MSP430ISelDAGToDAG.cpp
lib/Target/MSP430/MSP430ISelLowering.cpp
lib/Target/MSP430/MSP430InstrInfo.cpp
lib/Target/MSP430/MSP430RegisterInfo.cpp
lib/Target/MSP430/MSP430TargetMachine.h
lib/Target/MSP430/TargetInfo/MSP430TargetInfo.cpp
lib/Target/Mangler.cpp
lib/Target/Mips/Mips16FrameLowering.cpp
lib/Target/Mips/Mips16RegisterInfo.cpp
lib/Target/Mips/MipsAsmPrinter.cpp
lib/Target/Mips/MipsCodeEmitter.cpp
lib/Target/Mips/MipsFrameLowering.cpp
lib/Target/Mips/MipsISelDAGToDAG.cpp
lib/Target/Mips/MipsISelLowering.cpp
lib/Target/Mips/MipsJITInfo.cpp
lib/Target/Mips/MipsLongBranch.cpp
lib/Target/Mips/MipsMachineFunction.cpp
lib/Target/Mips/MipsRegisterInfo.cpp
lib/Target/Mips/MipsSEFrameLowering.cpp
lib/Target/Mips/MipsSERegisterInfo.cpp
lib/Target/Mips/MipsTargetMachine.h
lib/Target/Mips/MipsTargetObjectFile.cpp
lib/Target/Mips/TargetInfo/MipsTargetInfo.cpp
lib/Target/NVPTX/NVPTX.h
lib/Target/NVPTX/NVPTXAllocaHoisting.cpp
lib/Target/NVPTX/NVPTXAllocaHoisting.h
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
lib/Target/NVPTX/NVPTXAsmPrinter.h
lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp
lib/Target/NVPTX/NVPTXISelDAGToDAG.h
lib/Target/NVPTX/NVPTXISelLowering.cpp
lib/Target/NVPTX/NVPTXInstrInfo.cpp
lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp
lib/Target/NVPTX/NVPTXLowerAggrCopies.h
lib/Target/NVPTX/NVPTXSection.h
lib/Target/NVPTX/NVPTXSplitBBatBar.cpp
lib/Target/NVPTX/NVPTXTargetMachine.cpp
lib/Target/NVPTX/NVPTXTargetMachine.h
lib/Target/NVPTX/NVPTXUtilities.cpp
lib/Target/NVPTX/NVPTXUtilities.h
lib/Target/NVPTX/TargetInfo/NVPTXTargetInfo.cpp
lib/Target/NVPTX/VectorElementize.cpp
lib/Target/PowerPC/PPCAsmPrinter.cpp
lib/Target/PowerPC/PPCCTRLoops.cpp
lib/Target/PowerPC/PPCCodeEmitter.cpp
lib/Target/PowerPC/PPCFrameLowering.cpp
lib/Target/PowerPC/PPCISelDAGToDAG.cpp
lib/Target/PowerPC/PPCISelLowering.cpp
lib/Target/PowerPC/PPCJITInfo.cpp
lib/Target/PowerPC/PPCRegisterInfo.cpp
lib/Target/PowerPC/PPCSubtarget.cpp
lib/Target/PowerPC/PPCTargetMachine.h
lib/Target/PowerPC/TargetInfo/PowerPCTargetInfo.cpp
lib/Target/R600/AMDGPUMCInstLower.cpp
lib/Target/R600/AMDGPUStructurizeCFG.cpp
lib/Target/R600/AMDGPUTargetMachine.h
lib/Target/R600/AMDILISelLowering.cpp
lib/Target/R600/AMDILIntrinsicInfo.cpp
lib/Target/R600/AMDILIntrinsicInfo.h
lib/Target/R600/AMDILPeepholeOptimizer.cpp
lib/Target/R600/R600ISelLowering.cpp
lib/Target/R600/SIAnnotateControlFlow.cpp
lib/Target/Sparc/SparcFrameLowering.cpp
lib/Target/Sparc/SparcISelDAGToDAG.cpp
lib/Target/Sparc/SparcISelLowering.cpp
lib/Target/Sparc/SparcRegisterInfo.cpp
lib/Target/Sparc/SparcTargetMachine.h
lib/Target/Sparc/TargetInfo/SparcTargetInfo.cpp
lib/Target/Target.cpp
lib/Target/TargetIntrinsicInfo.cpp
lib/Target/TargetLoweringObjectFile.cpp
lib/Target/TargetMachine.cpp
lib/Target/TargetMachineC.cpp
lib/Target/TargetTransformImpl.cpp
lib/Target/X86/TargetInfo/X86TargetInfo.cpp
lib/Target/X86/X86AsmPrinter.cpp
lib/Target/X86/X86CodeEmitter.cpp
lib/Target/X86/X86FastISel.cpp
lib/Target/X86/X86FloatingPoint.cpp
lib/Target/X86/X86FrameLowering.cpp
lib/Target/X86/X86ISelDAGToDAG.cpp
lib/Target/X86/X86ISelLowering.cpp
lib/Target/X86/X86InstrInfo.cpp
lib/Target/X86/X86JITInfo.cpp
lib/Target/X86/X86JITInfo.h
lib/Target/X86/X86MCInstLower.cpp
lib/Target/X86/X86RegisterInfo.cpp
lib/Target/X86/X86SelectionDAGInfo.cpp
lib/Target/X86/X86Subtarget.cpp
lib/Target/X86/X86Subtarget.h
lib/Target/X86/X86TargetMachine.h
lib/Target/XCore/TargetInfo/XCoreTargetInfo.cpp
lib/Target/XCore/XCoreAsmPrinter.cpp
lib/Target/XCore/XCoreFrameLowering.cpp
lib/Target/XCore/XCoreISelDAGToDAG.cpp
lib/Target/XCore/XCoreISelLowering.cpp
lib/Target/XCore/XCoreRegisterInfo.cpp
lib/Target/XCore/XCoreTargetMachine.cpp
lib/Target/XCore/XCoreTargetMachine.h
lib/Transforms/Hello/Hello.cpp
lib/Transforms/IPO/ArgumentPromotion.cpp
lib/Transforms/IPO/ConstantMerge.cpp
lib/Transforms/IPO/DeadArgumentElimination.cpp
lib/Transforms/IPO/ExtractGV.cpp
lib/Transforms/IPO/FunctionAttrs.cpp
lib/Transforms/IPO/GlobalDCE.cpp
lib/Transforms/IPO/GlobalOpt.cpp
lib/Transforms/IPO/IPConstantPropagation.cpp
lib/Transforms/IPO/InlineAlways.cpp
lib/Transforms/IPO/InlineSimple.cpp
lib/Transforms/IPO/Inliner.cpp
lib/Transforms/IPO/Internalize.cpp
lib/Transforms/IPO/LoopExtractor.cpp
lib/Transforms/IPO/MergeFunctions.cpp
lib/Transforms/IPO/PartialInlining.cpp
lib/Transforms/IPO/PruneEH.cpp
lib/Transforms/IPO/StripDeadPrototypes.cpp
lib/Transforms/IPO/StripSymbols.cpp
lib/Transforms/InstCombine/InstCombine.h
lib/Transforms/InstCombine/InstCombineAddSub.cpp
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
lib/Transforms/InstCombine/InstCombineCalls.cpp
lib/Transforms/InstCombine/InstCombineCasts.cpp
lib/Transforms/InstCombine/InstCombineCompares.cpp
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
lib/Transforms/InstCombine/InstCombinePHI.cpp
lib/Transforms/InstCombine/InstCombineShifts.cpp
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
lib/Transforms/InstCombine/InstCombineWorklist.h
lib/Transforms/InstCombine/InstructionCombining.cpp
lib/Transforms/Instrumentation/AddressSanitizer.cpp
lib/Transforms/Instrumentation/BlackList.cpp
lib/Transforms/Instrumentation/BoundsChecking.cpp
lib/Transforms/Instrumentation/EdgeProfiling.cpp
lib/Transforms/Instrumentation/GCOVProfiling.cpp
lib/Transforms/Instrumentation/MaximumSpanningTree.h
lib/Transforms/Instrumentation/MemorySanitizer.cpp
lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
lib/Transforms/Instrumentation/PathProfiling.cpp
lib/Transforms/Instrumentation/ProfilingUtils.cpp
lib/Transforms/Instrumentation/ThreadSanitizer.cpp
lib/Transforms/Scalar/ADCE.cpp
lib/Transforms/Scalar/BasicBlockPlacement.cpp
lib/Transforms/Scalar/CodeGenPrepare.cpp
lib/Transforms/Scalar/ConstantProp.cpp
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp
lib/Transforms/Scalar/DCE.cpp
lib/Transforms/Scalar/DeadStoreElimination.cpp
lib/Transforms/Scalar/EarlyCSE.cpp
lib/Transforms/Scalar/GVN.cpp
lib/Transforms/Scalar/GlobalMerge.cpp
lib/Transforms/Scalar/IndVarSimplify.cpp
lib/Transforms/Scalar/JumpThreading.cpp
lib/Transforms/Scalar/LICM.cpp
lib/Transforms/Scalar/LoopIdiomRecognize.cpp
lib/Transforms/Scalar/LoopInstSimplify.cpp
lib/Transforms/Scalar/LoopRotation.cpp
lib/Transforms/Scalar/LoopStrengthReduce.cpp
lib/Transforms/Scalar/LoopUnrollPass.cpp
lib/Transforms/Scalar/LoopUnswitch.cpp
lib/Transforms/Scalar/LowerAtomic.cpp
lib/Transforms/Scalar/MemCpyOptimizer.cpp
lib/Transforms/Scalar/ObjCARC.cpp
lib/Transforms/Scalar/Reassociate.cpp
lib/Transforms/Scalar/Reg2Mem.cpp
lib/Transforms/Scalar/SCCP.cpp
lib/Transforms/Scalar/SROA.cpp
lib/Transforms/Scalar/Scalar.cpp
lib/Transforms/Scalar/ScalarReplAggregates.cpp
lib/Transforms/Scalar/SimplifyCFGPass.cpp
lib/Transforms/Scalar/SimplifyLibCalls.cpp
lib/Transforms/Scalar/Sink.cpp
lib/Transforms/Scalar/TailRecursionElimination.cpp
lib/Transforms/Utils/AddrModeMatcher.cpp
lib/Transforms/Utils/BasicBlockUtils.cpp
lib/Transforms/Utils/BreakCriticalEdges.cpp
lib/Transforms/Utils/BuildLibCalls.cpp
lib/Transforms/Utils/BypassSlowDivision.cpp
lib/Transforms/Utils/CloneFunction.cpp
lib/Transforms/Utils/CloneModule.cpp
lib/Transforms/Utils/CmpInstAnalysis.cpp
lib/Transforms/Utils/CodeExtractor.cpp
lib/Transforms/Utils/DemoteRegToStack.cpp
lib/Transforms/Utils/InlineFunction.cpp
lib/Transforms/Utils/InstructionNamer.cpp
lib/Transforms/Utils/IntegerDivision.cpp
lib/Transforms/Utils/LCSSA.cpp
lib/Transforms/Utils/Local.cpp
lib/Transforms/Utils/LoopSimplify.cpp
lib/Transforms/Utils/LoopUnroll.cpp
lib/Transforms/Utils/LoopUnrollRuntime.cpp
lib/Transforms/Utils/LowerExpectIntrinsic.cpp
lib/Transforms/Utils/LowerInvoke.cpp
lib/Transforms/Utils/LowerSwitch.cpp
lib/Transforms/Utils/Mem2Reg.cpp
lib/Transforms/Utils/MetaRenamer.cpp
lib/Transforms/Utils/ModuleUtils.cpp
lib/Transforms/Utils/PromoteMemoryToRegister.cpp
lib/Transforms/Utils/SSAUpdater.cpp
lib/Transforms/Utils/SimplifyCFG.cpp
lib/Transforms/Utils/SimplifyIndVar.cpp
lib/Transforms/Utils/SimplifyInstructions.cpp
lib/Transforms/Utils/SimplifyLibCalls.cpp
lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
lib/Transforms/Utils/ValueMapper.cpp
lib/Transforms/Vectorize/BBVectorize.cpp
lib/Transforms/Vectorize/LoopVectorize.cpp
lib/Transforms/Vectorize/LoopVectorize.h
tools/bugpoint-passes/TestPasses.cpp
tools/bugpoint/BugDriver.cpp
tools/bugpoint/CrashDebugger.cpp
tools/bugpoint/ExtractFunction.cpp
tools/bugpoint/Miscompilation.cpp
tools/bugpoint/OptimizerDriver.cpp
tools/bugpoint/bugpoint.cpp
tools/llc/llc.cpp
tools/lli/lli.cpp
tools/llvm-ar/llvm-ar.cpp
tools/llvm-as/llvm-as.cpp
tools/llvm-diff/DiffConsumer.cpp
tools/llvm-diff/DiffLog.cpp
tools/llvm-diff/DifferenceEngine.cpp
tools/llvm-diff/llvm-diff.cpp
tools/llvm-dis/llvm-dis.cpp
tools/llvm-extract/llvm-extract.cpp
tools/llvm-jitlistener/llvm-jitlistener.cpp
tools/llvm-link/llvm-link.cpp
tools/llvm-nm/llvm-nm.cpp
tools/llvm-prof/llvm-prof.cpp
tools/llvm-ranlib/llvm-ranlib.cpp
tools/llvm-stress/llvm-stress.cpp
tools/lto/LTOCodeGenerator.cpp
tools/lto/LTOModule.cpp
tools/lto/LTOModule.h
tools/opt/AnalysisWrappers.cpp
tools/opt/GraphPrinters.cpp
tools/opt/PrintSCC.cpp
tools/opt/opt.cpp
unittests/Analysis/ScalarEvolutionTest.cpp
unittests/Bitcode/BitReaderTest.cpp
unittests/ExecutionEngine/ExecutionEngineTest.cpp
unittests/ExecutionEngine/JIT/JITEventListenerTest.cpp
unittests/ExecutionEngine/JIT/JITEventListenerTestCommon.h
unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp
unittests/ExecutionEngine/JIT/JITTest.cpp
unittests/ExecutionEngine/JIT/MultiJITTest.cpp
unittests/ExecutionEngine/MCJIT/MCJITTestBase.h
unittests/Support/ConstantRangeTest.cpp
unittests/Support/ValueHandleTest.cpp
unittests/Transforms/Utils/Cloning.cpp
unittests/Transforms/Utils/IntegerDivision.cpp
unittests/Transforms/Utils/Local.cpp
unittests/VMCore/ConstantsTest.cpp
unittests/VMCore/DominatorTreeTest.cpp
unittests/VMCore/IRBuilderTest.cpp
unittests/VMCore/InstructionsTest.cpp
unittests/VMCore/MDBuilderTest.cpp
unittests/VMCore/MetadataTest.cpp
unittests/VMCore/PassManagerTest.cpp
unittests/VMCore/TypeBuilderTest.cpp
unittests/VMCore/TypesTest.cpp
unittests/VMCore/ValueMapTest.cpp
unittests/VMCore/VerifierTest.cpp
unittests/VMCore/WaymarkTest.cpp

index 727f8ed..c64275f 100644 (file)
@@ -1814,7 +1814,7 @@ TDFiles := $(strip $(wildcard $(PROJ_SRC_DIR)/*.td) \
            $(LLVM_SRC_ROOT)/include/llvm/Target/TargetSchedule.td \
            $(LLVM_SRC_ROOT)/include/llvm/Target/TargetSelectionDAG.td \
            $(LLVM_SRC_ROOT)/include/llvm/CodeGen/ValueTypes.td) \
-           $(wildcard $(LLVM_SRC_ROOT)/include/llvm/Intrinsics*.td)
+           $(wildcard $(LLVM_SRC_ROOT)/include/llvm/IR/Intrinsics*.td)
 
 # All .inc.tmp files depend on the .td files.
 $(INCTMPFiles) : $(TDFiles)
index 620d088..f2fe764 100644 (file)
@@ -21,8 +21,8 @@
 
 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap' 
    and 'unwrap' conversion functions. */
-#include "llvm/IRBuilder.h"
-#include "llvm/Module.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Module.h"
 #include "llvm/PassRegistry.h"
 
 extern "C" {
index c7b3684..f220c58 100644 (file)
@@ -16,9 +16,9 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PostOrderIterator.h"
-#include "llvm/BasicBlock.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/IR/BasicBlock.h"
 #include "llvm/Support/BlockFrequency.h"
 #include "llvm/Support/BranchProbability.h"
 #include "llvm/Support/Debug.h"
index 2af7a02..fa596c3 100644 (file)
@@ -16,9 +16,9 @@
 #define LLVM_ANALYSIS_CFGPRINTER_H
 
 #include "llvm/Assembly/Writer.h"
-#include "llvm/Constants.h"
-#include "llvm/Function.h"
-#include "llvm/Instructions.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/GraphWriter.h"
 
index d8b80df..591484d 100644 (file)
@@ -53,7 +53,7 @@
 
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Function.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CallSite.h"
 #include "llvm/Support/IncludeFile.h"
index 6ebe2d7..5e2a5ec 100644 (file)
@@ -15,8 +15,8 @@
 #define LLVM_ANALYSIS_CAPTURETRACKING_H
 
 #include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Constants.h"
-#include "llvm/Instructions.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/Support/CallSite.h"
 
 namespace llvm {
index de2b3df..f49efd9 100644 (file)
@@ -41,7 +41,7 @@
 #define LLVM_ANALYSIS_DEPENDENCEANALYSIS_H
 
 #include "llvm/ADT/SmallBitVector.h"
-#include "llvm/Instructions.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
index c69b1ed..d62a3ac 100644 (file)
@@ -20,7 +20,7 @@
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Function.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/Compiler.h"
index 515cbce..42e329e 100644 (file)
@@ -18,7 +18,7 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/ValueMap.h"
 #include "llvm/Analysis/CodeMetrics.h"
-#include "llvm/Function.h"
+#include "llvm/IR/Function.h"
 #include <cassert>
 #include <climits>
 #include <vector>
index e70bfe2..b653e79 100644 (file)
@@ -19,7 +19,7 @@
 #ifndef LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
 #define LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
 
-#include "llvm/User.h"
+#include "llvm/IR/User.h"
 
 namespace llvm {
   template<typename T>
index 0968c74..bd9ab20 100644 (file)
@@ -34,7 +34,7 @@
 #define LLVM_INTERVAL_ITERATOR_H
 
 #include "llvm/Analysis/IntervalPartition.h"
-#include "llvm/Function.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Support/CFG.h"
 #include <algorithm>
 #include <set>
index afc90c2..ebcb762 100644 (file)
@@ -14,7 +14,7 @@
 #ifndef LLVM_ANALYSIS_LOADS_H
 #define LLVM_ANALYSIS_LOADS_H
 
-#include "llvm/BasicBlock.h"
+#include "llvm/IR/BasicBlock.h"
 
 namespace llvm {
 
index 4c16daf..f78472a 100644 (file)
@@ -16,7 +16,7 @@
 #define LLVM_LOOP_PASS_H
 
 #include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Function.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/PassManagers.h"
 #include <deque>
index 73e0e98..f2c564f 100644 (file)
@@ -17,9 +17,9 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/IRBuilder.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Operator.h"
 #include "llvm/InstVisitor.h"
-#include "llvm/Operator.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/TargetFolder.h"
 #include "llvm/Support/ValueHandle.h"
index 121eede..b954840 100644 (file)
@@ -19,7 +19,7 @@
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/BasicBlock.h"
+#include "llvm/IR/BasicBlock.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/ValueHandle.h"
 
index 781ac07..d7a3dd8 100644 (file)
@@ -15,7 +15,7 @@
 #define LLVM_ANALYSIS_PHITRANSADDR_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Instruction.h"
+#include "llvm/IR/Instruction.h"
 
 namespace llvm {
   class DominatorTree;
index a9f7621..86b1520 100644 (file)
@@ -27,8 +27,8 @@
 #define LLVM_PATH_NUMBERING_H
 
 #include "llvm/Analysis/ProfileInfoTypes.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/Instructions.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CFG.h"
 #include <map>
index 5388069..8684f41 100644 (file)
@@ -15,7 +15,7 @@
 #define LLVM_PATHPROFILEINFO_H
 
 #include "llvm/Analysis/PathNumbering.h"
-#include "llvm/BasicBlock.h"
+#include "llvm/IR/BasicBlock.h"
 
 namespace llvm {
 
index f5daf2c..1802fe8 100644 (file)
@@ -25,9 +25,9 @@
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/DataLayout.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/InstVisitor.h"
-#include "llvm/IntrinsicInst.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
index 7d45088..54f96d6 100644 (file)
@@ -17,7 +17,7 @@
 #define LLVM_REGION_PASS_H
 
 #include "llvm/Analysis/RegionInfo.h"
-#include "llvm/Function.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/PassManagers.h"
 #include <deque>
index dcefaa0..f8f261f 100644 (file)
@@ -23,9 +23,9 @@
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
-#include "llvm/Function.h"
-#include "llvm/Instructions.h"
-#include "llvm/Operator.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Operator.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ConstantRange.h"
index 95772a8..9ee3a97 100644 (file)
@@ -16,7 +16,7 @@
 
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/ScalarEvolutionNormalization.h"
-#include "llvm/IRBuilder.h"
+#include "llvm/IR/IRBuilder.h"
 #include "llvm/Support/TargetFolder.h"
 #include "llvm/Support/ValueHandle.h"
 #include <set>
diff --git a/include/llvm/Argument.h b/include/llvm/Argument.h
deleted file mode 100644 (file)
index e457595..0000000
+++ /dev/null
@@ -1,91 +0,0 @@
-//===-- llvm/Argument.h - Definition of the Argument class ------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares the Argument class. 
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ARGUMENT_H
-#define LLVM_ARGUMENT_H
-
-#include "llvm/ADT/Twine.h"
-#include "llvm/ADT/ilist_node.h"
-#include "llvm/Attributes.h"
-#include "llvm/Value.h"
-
-namespace llvm {
-
-template<typename ValueSubClass, typename ItemParentClass>
-  class SymbolTableListTraits;
-
-/// A class to represent an incoming formal argument to a Function. An argument
-/// is a very simple Value. It is essentially a named (optional) type. When used
-/// in the body of a function, it represents the value of the actual argument
-/// the function was called with.
-/// @brief LLVM Argument representation  
-class Argument : public Value, public ilist_node<Argument> {
-  virtual void anchor();
-  Function *Parent;
-
-  friend class SymbolTableListTraits<Argument, Function>;
-  void setParent(Function *parent);
-
-public:
-  /// Argument ctor - If Function argument is specified, this argument is
-  /// inserted at the end of the argument list for the function.
-  ///
-  explicit Argument(Type *Ty, const Twine &Name = "", Function *F = 0);
-
-  inline const Function *getParent() const { return Parent; }
-  inline       Function *getParent()       { return Parent; }
-
-  /// getArgNo - Return the index of this formal argument in its containing
-  /// function.  For example in "void foo(int a, float b)" a is 0 and b is 1. 
-  unsigned getArgNo() const;
-  
-  /// hasByValAttr - Return true if this argument has the byval attribute on it
-  /// in its containing function.
-  bool hasByValAttr() const;
-  
-  /// getParamAlignment - If this is a byval argument, return its alignment.
-  unsigned getParamAlignment() const;
-
-  /// hasNestAttr - Return true if this argument has the nest attribute on
-  /// it in its containing function.
-  bool hasNestAttr() const;
-
-  /// hasNoAliasAttr - Return true if this argument has the noalias attribute on
-  /// it in its containing function.
-  bool hasNoAliasAttr() const;
-  
-  /// hasNoCaptureAttr - Return true if this argument has the nocapture
-  /// attribute on it in its containing function.
-  bool hasNoCaptureAttr() const;
-  
-  /// hasStructRetAttr - Return true if this argument has the sret attribute on
-  /// it in its containing function.
-  bool hasStructRetAttr() const;
-
-  /// addAttr - Add a Attribute to an argument
-  void addAttr(Attribute);
-  
-  /// removeAttr - Remove a Attribute from an argument
-  void removeAttr(Attribute);
-
-  /// classof - Methods for support type inquiry through isa, cast, and
-  /// dyn_cast:
-  ///
-  static inline bool classof(const Value *V) {
-    return V->getValueID() == ArgumentVal;
-  }
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h
deleted file mode 100644 (file)
index c28f0bd..0000000
+++ /dev/null
@@ -1,399 +0,0 @@
-//===-- llvm/Attributes.h - Container for Attributes ------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file contains the simple types necessary to represent the
-/// attributes associated with functions and their calls.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ATTRIBUTES_H
-#define LLVM_ATTRIBUTES_H
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/Support/MathExtras.h"
-#include <cassert>
-#include <string>
-
-namespace llvm {
-
-class AttrBuilder;
-class AttributeImpl;
-class LLVMContext;
-class Type;
-
-//===----------------------------------------------------------------------===//
-/// \class
-/// \brief Functions, function parameters, and return types can have attributes
-/// to indicate how they should be treated by optimizations and code
-/// generation. This class represents one of those attributes. It's light-weight
-/// and should be passed around by-value.
-class Attribute {
-public:
-  /// This enumeration lists the attributes that can be associated with
-  /// parameters, function results or the function itself.
-  ///
-  /// Note: uwtable is about the ABI or the user mandating an entry in the
-  /// unwind table. The nounwind attribute is about an exception passing by the
-  /// function.
-  ///
-  /// In a theoretical system that uses tables for profiling and sjlj for
-  /// exceptions, they would be fully independent. In a normal system that uses
-  /// tables for both, the semantics are:
-  ///
-  /// nil                = Needs an entry because an exception might pass by.
-  /// nounwind           = No need for an entry
-  /// uwtable            = Needs an entry because the ABI says so and because
-  ///                      an exception might pass by.
-  /// uwtable + nounwind = Needs an entry because the ABI says so.
-
-  enum AttrKind {
-    // IR-Level Attributes
-    None,                  ///< No attributes have been set
-    AddressSafety,         ///< Address safety checking is on.
-    Alignment,             ///< Alignment of parameter (5 bits)
-                           ///< stored as log2 of alignment with +1 bias
-                           ///< 0 means unaligned (different from align(1))
-    AlwaysInline,          ///< inline=always
-    ByVal,                 ///< Pass structure by value
-    InlineHint,            ///< Source said inlining was desirable
-    InReg,                 ///< Force argument to be passed in register
-    MinSize,               ///< Function must be optimized for size first
-    Naked,                 ///< Naked function
-    Nest,                  ///< Nested function static chain
-    NoAlias,               ///< Considered to not alias after call
-    NoCapture,             ///< Function creates no aliases of pointer
-    NoDuplicate,           ///< Call cannot be duplicated
-    NoImplicitFloat,       ///< Disable implicit floating point insts
-    NoInline,              ///< inline=never
-    NonLazyBind,           ///< Function is called early and/or
-                           ///< often, so lazy binding isn't worthwhile
-    NoRedZone,             ///< Disable redzone
-    NoReturn,              ///< Mark the function as not returning
-    NoUnwind,              ///< Function doesn't unwind stack
-    OptimizeForSize,       ///< opt_size
-    ReadNone,              ///< Function does not access memory
-    ReadOnly,              ///< Function only reads from memory
-    ReturnsTwice,          ///< Function can return twice
-    SExt,                  ///< Sign extended before/after call
-    StackAlignment,        ///< Alignment of stack for function (3 bits)
-                           ///< stored as log2 of alignment with +1 bias 0
-                           ///< means unaligned (different from
-                           ///< alignstack=(1))
-    StackProtect,          ///< Stack protection.
-    StackProtectReq,       ///< Stack protection required.
-    StructRet,             ///< Hidden pointer to structure to return
-    UWTable,               ///< Function must be in a unwind table
-    ZExt                   ///< Zero extended before/after call
-  };
-private:
-  AttributeImpl *pImpl;
-  Attribute(AttributeImpl *A) : pImpl(A) {}
-public:
-  Attribute() : pImpl(0) {}
-
-  /// \brief Return a uniquified Attribute object. This takes the uniquified
-  /// value from the Builder and wraps it in the Attribute class.
-  static Attribute get(LLVMContext &Context, ArrayRef<AttrKind> Vals);
-  static Attribute get(LLVMContext &Context, AttrBuilder &B);
-
-  /// \brief Return true if the attribute is present.
-  bool hasAttribute(AttrKind Val) const;
-
-  /// \brief Return true if attributes exist
-  bool hasAttributes() const;
-
-  /// \brief Return true if the attributes are a non-null intersection.
-  bool hasAttributes(const Attribute &A) const;
-
-  /// \brief Returns the alignment field of an attribute as a byte alignment
-  /// value.
-  unsigned getAlignment() const;
-
-  /// \brief Returns the stack alignment field of an attribute as a byte
-  /// alignment value.
-  unsigned getStackAlignment() const;
-
-  bool operator==(AttrKind K) const;
-  bool operator!=(AttrKind K) const;
-
-  // FIXME: Remove these 'operator' methods.
-  bool operator==(const Attribute &A) const {
-    return pImpl == A.pImpl;
-  }
-  bool operator!=(const Attribute &A) const {
-    return pImpl != A.pImpl;
-  }
-
-  uint64_t getBitMask() const;
-
-  /// \brief Which attributes cannot be applied to a type.
-  static Attribute typeIncompatible(Type *Ty);
-
-  /// \brief This returns an integer containing an encoding of all the LLVM
-  /// attributes found in the given attribute bitset.  Any change to this
-  /// encoding is a breaking change to bitcode compatibility.
-  static uint64_t encodeLLVMAttributesForBitcode(Attribute Attrs);
-
-  /// \brief This returns an attribute bitset containing the LLVM attributes
-  /// that have been decoded from the given integer.  This function must stay in
-  /// sync with 'encodeLLVMAttributesForBitcode'.
-  static Attribute decodeLLVMAttributesForBitcode(LLVMContext &C,
-                                                  uint64_t EncodedAttrs);
-
-  /// \brief The Attribute is converted to a string of equivalent mnemonic. This
-  /// is, presumably, for writing out the mnemonics for the assembly writer.
-  std::string getAsString() const;
-};
-
-//===----------------------------------------------------------------------===//
-/// \class
-/// \brief This class is used in conjunction with the Attribute::get method to
-/// create an Attribute object. The object itself is uniquified. The Builder's
-/// value, however, is not. So this can be used as a quick way to test for
-/// equality, presence of attributes, etc.
-class AttrBuilder {
-  uint64_t Bits;
-public:
-  AttrBuilder() : Bits(0) {}
-  explicit AttrBuilder(uint64_t B) : Bits(B) {}
-  AttrBuilder(const Attribute &A) : Bits(A.getBitMask()) {}
-
-  void clear() { Bits = 0; }
-
-  /// addAttribute - Add an attribute to the builder.
-  AttrBuilder &addAttribute(Attribute::AttrKind Val);
-
-  /// removeAttribute - Remove an attribute from the builder.
-  AttrBuilder &removeAttribute(Attribute::AttrKind Val);
-
-  /// addAttribute - Add the attributes from A to the builder.
-  AttrBuilder &addAttributes(const Attribute &A);
-
-  /// removeAttribute - Remove the attributes from A from the builder.
-  AttrBuilder &removeAttributes(const Attribute &A);
-
-  /// \brief Return true if the builder has the specified attribute.
-  bool contains(Attribute::AttrKind A) const;
-
-  /// hasAttributes - Return true if the builder has IR-level attributes.
-  bool hasAttributes() const;
-
-  /// hasAttributes - Return true if the builder has any attribute that's in the
-  /// specified attribute.
-  bool hasAttributes(const Attribute &A) const;
-
-  /// hasAlignmentAttr - Return true if the builder has an alignment attribute.
-  bool hasAlignmentAttr() const;
-
-  /// getAlignment - Retrieve the alignment attribute, if it exists.
-  uint64_t getAlignment() const;
-
-  /// getStackAlignment - Retrieve the stack alignment attribute, if it exists.
-  uint64_t getStackAlignment() const;
-
-  /// addAlignmentAttr - This turns an int alignment (which must be a power of
-  /// 2) into the form used internally in Attribute.
-  AttrBuilder &addAlignmentAttr(unsigned Align);
-
-  /// addStackAlignmentAttr - This turns an int stack alignment (which must be a
-  /// power of 2) into the form used internally in Attribute.
-  AttrBuilder &addStackAlignmentAttr(unsigned Align);
-
-  /// addRawValue - Add the raw value to the internal representation.
-  /// N.B. This should be used ONLY for decoding LLVM bitcode!
-  AttrBuilder &addRawValue(uint64_t Val);
-
-  /// @brief Remove attributes that are used on functions only.
-  void removeFunctionOnlyAttrs() {
-    removeAttribute(Attribute::NoReturn)
-      .removeAttribute(Attribute::NoUnwind)
-      .removeAttribute(Attribute::ReadNone)
-      .removeAttribute(Attribute::ReadOnly)
-      .removeAttribute(Attribute::NoInline)
-      .removeAttribute(Attribute::AlwaysInline)
-      .removeAttribute(Attribute::OptimizeForSize)
-      .removeAttribute(Attribute::StackProtect)
-      .removeAttribute(Attribute::StackProtectReq)
-      .removeAttribute(Attribute::NoRedZone)
-      .removeAttribute(Attribute::NoImplicitFloat)
-      .removeAttribute(Attribute::Naked)
-      .removeAttribute(Attribute::InlineHint)
-      .removeAttribute(Attribute::StackAlignment)
-      .removeAttribute(Attribute::UWTable)
-      .removeAttribute(Attribute::NonLazyBind)
-      .removeAttribute(Attribute::ReturnsTwice)
-      .removeAttribute(Attribute::AddressSafety)
-      .removeAttribute(Attribute::MinSize)
-      .removeAttribute(Attribute::NoDuplicate);
-  }
-
-  uint64_t getBitMask() const { return Bits; }
-
-  bool operator==(const AttrBuilder &B) {
-    return Bits == B.Bits;
-  }
-  bool operator!=(const AttrBuilder &B) {
-    return Bits != B.Bits;
-  }
-};
-
-//===----------------------------------------------------------------------===//
-/// \class
-/// \brief This is just a pair of values to associate a set of attributes with
-/// an index.
-struct AttributeWithIndex {
-  Attribute Attrs;  ///< The attributes that are set, or'd together.
-  unsigned Index;   ///< Index of the parameter for which the attributes apply.
-                    ///< Index 0 is used for return value attributes.
-                    ///< Index ~0U is used for function attributes.
-
-  static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
-                                ArrayRef<Attribute::AttrKind> Attrs) {
-    return get(Idx, Attribute::get(C, Attrs));
-  }
-  static AttributeWithIndex get(unsigned Idx, Attribute Attrs) {
-    AttributeWithIndex P;
-    P.Index = Idx;
-    P.Attrs = Attrs;
-    return P;
-  }
-};
-
-//===----------------------------------------------------------------------===//
-// AttributeSet Smart Pointer
-//===----------------------------------------------------------------------===//
-
-class AttributeSetImpl;
-
-//===----------------------------------------------------------------------===//
-/// \class
-/// \brief This class manages the ref count for the opaque AttributeSetImpl
-/// object and provides accessors for it.
-class AttributeSet {
-public:
-  enum AttrIndex {
-    ReturnIndex = 0U,
-    FunctionIndex = ~0U
-  };
-private:
-  /// \brief The attributes that we are managing.  This can be null to represent
-  /// the empty attributes list.
-  AttributeSetImpl *AttrList;
-
-  /// \brief The attributes for the specified index are returned.  Attributes
-  /// for the result are denoted with Idx = 0.
-  Attribute getAttributes(unsigned Idx) const;
-
-  explicit AttributeSet(AttributeSetImpl *LI) : AttrList(LI) {}
-public:
-  AttributeSet() : AttrList(0) {}
-  AttributeSet(const AttributeSet &P) : AttrList(P.AttrList) {}
-  const AttributeSet &operator=(const AttributeSet &RHS);
-
-  //===--------------------------------------------------------------------===//
-  // Attribute List Construction and Mutation
-  //===--------------------------------------------------------------------===//
-
-  /// \brief Return an AttributeSet with the specified parameters in it.
-  static AttributeSet get(LLVMContext &C, ArrayRef<AttributeWithIndex> Attrs);
-
-  /// \brief Add the specified attribute at the specified index to this
-  /// attribute list.  Since attribute lists are immutable, this returns the new
-  /// list.
-  AttributeSet addAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const;
-
-  /// \brief Remove the specified attribute at the specified index from this
-  /// attribute list.  Since attribute lists are immutable, this returns the new
-  /// list.
-  AttributeSet removeAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const;
-
-  //===--------------------------------------------------------------------===//
-  // Attribute List Accessors
-  //===--------------------------------------------------------------------===//
-
-  /// \brief The attributes for the specified index are returned.
-  Attribute getParamAttributes(unsigned Idx) const {
-    return getAttributes(Idx);
-  }
-
-  /// \brief The attributes for the ret value are returned.
-  Attribute getRetAttributes() const {
-    return getAttributes(ReturnIndex);
-  }
-
-  /// \brief The function attributes are returned.
-  Attribute getFnAttributes() const {
-    return getAttributes(FunctionIndex);
-  }
-
-  /// \brief Return the alignment for the specified function parameter.
-  unsigned getParamAlignment(unsigned Idx) const {
-    return getAttributes(Idx).getAlignment();
-  }
-
-  /// \brief Return true if the attribute exists at the given index.
-  bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
-
-  /// \brief Return true if attribute exists at the given index.
-  bool hasAttributes(unsigned Index) const;
-
-  /// \brief Get the stack alignment.
-  unsigned getStackAlignment(unsigned Index) const;
-
-  /// \brief Return the attributes at the index as a string.
-  std::string getAsString(unsigned Index) const;
-
-  uint64_t getBitMask(unsigned Index) const;
-
-  /// \brief Return true if the specified attribute is set for at least one
-  /// parameter or for the return value.
-  bool hasAttrSomewhere(Attribute::AttrKind Attr) const;
-
-  /// operator==/!= - Provide equality predicates.
-  bool operator==(const AttributeSet &RHS) const {
-    return AttrList == RHS.AttrList;
-  }
-  bool operator!=(const AttributeSet &RHS) const {
-    return AttrList != RHS.AttrList;
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Attribute List Introspection
-  //===--------------------------------------------------------------------===//
-
-  /// \brief Return a raw pointer that uniquely identifies this attribute list.
-  void *getRawPointer() const {
-    return AttrList;
-  }
-
-  // Attributes are stored as a dense set of slots, where there is one slot for
-  // each argument that has an attribute.  This allows walking over the dense
-  // set instead of walking the sparse list of attributes.
-
-  /// \brief Return true if there are no attributes.
-  bool isEmpty() const {
-    return AttrList == 0;
-  }
-
-  /// \brief Return the number of slots used in this attribute list.  This is
-  /// the number of arguments that have an attribute set on them (including the
-  /// function itself).
-  unsigned getNumSlots() const;
-
-  /// \brief Return the AttributeWithIndex at the specified slot.  This holds a
-  /// index number plus a set of attributes.
-  const AttributeWithIndex &getSlot(unsigned Slot) const;
-
-  void dump() const;
-};
-
-} // end llvm namespace
-
-#endif
diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
deleted file mode 100644 (file)
index e900102..0000000
+++ /dev/null
@@ -1,297 +0,0 @@
-//===-- llvm/BasicBlock.h - Represent a basic block in the VM ---*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the declaration of the BasicBlock class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BASICBLOCK_H
-#define LLVM_BASICBLOCK_H
-
-#include "llvm/ADT/Twine.h"
-#include "llvm/ADT/ilist.h"
-#include "llvm/Instruction.h"
-#include "llvm/Support/DataTypes.h"
-#include "llvm/SymbolTableListTraits.h"
-
-namespace llvm {
-
-class LandingPadInst;
-class TerminatorInst;
-class LLVMContext;
-class BlockAddress;
-
-template<> struct ilist_traits<Instruction>
-  : public SymbolTableListTraits<Instruction, BasicBlock> {
-  // createSentinel is used to get hold of a node that marks the end of
-  // the list...
-  // The sentinel is relative to this instance, so we use a non-static
-  // method.
-  Instruction *createSentinel() const {
-    // since i(p)lists always publicly derive from the corresponding
-    // traits, placing a data member in this class will augment i(p)list.
-    // But since the NodeTy is expected to publicly derive from
-    // ilist_node<NodeTy>, there is a legal viable downcast from it
-    // to NodeTy. We use this trick to superpose i(p)list with a "ghostly"
-    // NodeTy, which becomes the sentinel. Dereferencing the sentinel is
-    // forbidden (save the ilist_node<NodeTy>) so no one will ever notice
-    // the superposition.
-    return static_cast<Instruction*>(&Sentinel);
-  }
-  static void destroySentinel(Instruction*) {}
-
-  Instruction *provideInitialHead() const { return createSentinel(); }
-  Instruction *ensureHead(Instruction*) const { return createSentinel(); }
-  static void noteHead(Instruction*, Instruction*) {}
-private:
-  mutable ilist_half_node<Instruction> Sentinel;
-};
-
-/// This represents a single basic block in LLVM. A basic block is simply a
-/// container of instructions that execute sequentially. Basic blocks are Values
-/// because they are referenced by instructions such as branches and switch
-/// tables. The type of a BasicBlock is "Type::LabelTy" because the basic block
-/// represents a label to which a branch can jump.
-///
-/// A well formed basic block is formed of a list of non-terminating
-/// instructions followed by a single TerminatorInst instruction.
-/// TerminatorInst's may not occur in the middle of basic blocks, and must
-/// terminate the blocks. The BasicBlock class allows malformed basic blocks to
-/// occur because it may be useful in the intermediate stage of constructing or
-/// modifying a program. However, the verifier will ensure that basic blocks
-/// are "well formed".
-/// @brief LLVM Basic Block Representation
-class BasicBlock : public Value, // Basic blocks are data objects also
-                   public ilist_node<BasicBlock> {
-  friend class BlockAddress;
-public:
-  typedef iplist<Instruction> InstListType;
-private:
-  InstListType InstList;
-  Function *Parent;
-
-  void setParent(Function *parent);
-  friend class SymbolTableListTraits<BasicBlock, Function>;
-
-  BasicBlock(const BasicBlock &) LLVM_DELETED_FUNCTION;
-  void operator=(const BasicBlock &) LLVM_DELETED_FUNCTION;
-
-  /// BasicBlock ctor - If the function parameter is specified, the basic block
-  /// is automatically inserted at either the end of the function (if
-  /// InsertBefore is null), or before the specified basic block.
-  ///
-  explicit BasicBlock(LLVMContext &C, const Twine &Name = "",
-                      Function *Parent = 0, BasicBlock *InsertBefore = 0);
-public:
-  /// getContext - Get the context in which this basic block lives.
-  LLVMContext &getContext() const;
-
-  /// Instruction iterators...
-  typedef InstListType::iterator iterator;
-  typedef InstListType::const_iterator const_iterator;
-  typedef InstListType::reverse_iterator reverse_iterator;
-  typedef InstListType::const_reverse_iterator const_reverse_iterator;
-
-  /// Create - Creates a new BasicBlock. If the Parent parameter is specified,
-  /// the basic block is automatically inserted at either the end of the
-  /// function (if InsertBefore is 0), or before the specified basic block.
-  static BasicBlock *Create(LLVMContext &Context, const Twine &Name = "",
-                            Function *Parent = 0,BasicBlock *InsertBefore = 0) {
-    return new BasicBlock(Context, Name, Parent, InsertBefore);
-  }
-  ~BasicBlock();
-
-  /// getParent - Return the enclosing method, or null if none
-  ///
-  const Function *getParent() const { return Parent; }
-        Function *getParent()       { return Parent; }
-
-  /// getTerminator() - If this is a well formed basic block, then this returns
-  /// a pointer to the terminator instruction.  If it is not, then you get a
-  /// null pointer back.
-  ///
-  TerminatorInst *getTerminator();
-  const TerminatorInst *getTerminator() const;
-
-  /// Returns a pointer to the first instructon in this block that is not a
-  /// PHINode instruction. When adding instruction to the beginning of the
-  /// basic block, they should be added before the returned value, not before
-  /// the first instruction, which might be PHI.
-  /// Returns 0 is there's no non-PHI instruction.
-  Instruction* getFirstNonPHI();
-  const Instruction* getFirstNonPHI() const {
-    return const_cast<BasicBlock*>(this)->getFirstNonPHI();
-  }
-
-  // Same as above, but also skip debug intrinsics.
-  Instruction* getFirstNonPHIOrDbg();
-  const Instruction* getFirstNonPHIOrDbg() const {
-    return const_cast<BasicBlock*>(this)->getFirstNonPHIOrDbg();
-  }
-
-  // Same as above, but also skip lifetime intrinsics.
-  Instruction* getFirstNonPHIOrDbgOrLifetime();
-  const Instruction* getFirstNonPHIOrDbgOrLifetime() const {
-    return const_cast<BasicBlock*>(this)->getFirstNonPHIOrDbgOrLifetime();
-  }
-
-  /// getFirstInsertionPt - Returns an iterator to the first instruction in this
-  /// block that is suitable for inserting a non-PHI instruction. In particular,
-  /// it skips all PHIs and LandingPad instructions.
-  iterator getFirstInsertionPt();
-  const_iterator getFirstInsertionPt() const {
-    return const_cast<BasicBlock*>(this)->getFirstInsertionPt();
-  }
-
-  /// removeFromParent - This method unlinks 'this' from the containing
-  /// function, but does not delete it.
-  ///
-  void removeFromParent();
-
-  /// eraseFromParent - This method unlinks 'this' from the containing function
-  /// and deletes it.
-  ///
-  void eraseFromParent();
-
-  /// moveBefore - Unlink this basic block from its current function and
-  /// insert it into the function that MovePos lives in, right before MovePos.
-  void moveBefore(BasicBlock *MovePos);
-
-  /// moveAfter - Unlink this basic block from its current function and
-  /// insert it into the function that MovePos lives in, right after MovePos.
-  void moveAfter(BasicBlock *MovePos);
-
-
-  /// getSinglePredecessor - If this basic block has a single predecessor block,
-  /// return the block, otherwise return a null pointer.
-  BasicBlock *getSinglePredecessor();
-  const BasicBlock *getSinglePredecessor() const {
-    return const_cast<BasicBlock*>(this)->getSinglePredecessor();
-  }
-
-  /// getUniquePredecessor - If this basic block has a unique predecessor block,
-  /// return the block, otherwise return a null pointer.
-  /// Note that unique predecessor doesn't mean single edge, there can be
-  /// multiple edges from the unique predecessor to this block (for example
-  /// a switch statement with multiple cases having the same destination).
-  BasicBlock *getUniquePredecessor();
-  const BasicBlock *getUniquePredecessor() const {
-    return const_cast<BasicBlock*>(this)->getUniquePredecessor();
-  }
-
-  //===--------------------------------------------------------------------===//
-  /// Instruction iterator methods
-  ///
-  inline iterator                begin()       { return InstList.begin(); }
-  inline const_iterator          begin() const { return InstList.begin(); }
-  inline iterator                end  ()       { return InstList.end();   }
-  inline const_iterator          end  () const { return InstList.end();   }
-
-  inline reverse_iterator        rbegin()       { return InstList.rbegin(); }
-  inline const_reverse_iterator  rbegin() const { return InstList.rbegin(); }
-  inline reverse_iterator        rend  ()       { return InstList.rend();   }
-  inline const_reverse_iterator  rend  () const { return InstList.rend();   }
-
-  inline size_t                   size() const { return InstList.size();  }
-  inline bool                    empty() const { return InstList.empty(); }
-  inline const Instruction      &front() const { return InstList.front(); }
-  inline       Instruction      &front()       { return InstList.front(); }
-  inline const Instruction       &back() const { return InstList.back();  }
-  inline       Instruction       &back()       { return InstList.back();  }
-
-  /// getInstList() - Return the underlying instruction list container.  You
-  /// need to access it directly if you want to modify it currently.
-  ///
-  const InstListType &getInstList() const { return InstList; }
-        InstListType &getInstList()       { return InstList; }
-
-  /// getSublistAccess() - returns pointer to member of instruction list
-  static iplist<Instruction> BasicBlock::*getSublistAccess(Instruction*) {
-    return &BasicBlock::InstList;
-  }
-
-  /// getValueSymbolTable() - returns pointer to symbol table (if any)
-  ValueSymbolTable *getValueSymbolTable();
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Value *V) {
-    return V->getValueID() == Value::BasicBlockVal;
-  }
-
-  /// dropAllReferences() - This function causes all the subinstructions to "let
-  /// go" of all references that they are maintaining.  This allows one to
-  /// 'delete' a whole class at a time, even though there may be circular
-  /// references... first all references are dropped, and all use counts go to
-  /// zero.  Then everything is delete'd for real.  Note that no operations are
-  /// valid on an object that has "dropped all references", except operator
-  /// delete.
-  ///
-  void dropAllReferences();
-
-  /// removePredecessor - This method is used to notify a BasicBlock that the
-  /// specified Predecessor of the block is no longer able to reach it.  This is
-  /// actually not used to update the Predecessor list, but is actually used to
-  /// update the PHI nodes that reside in the block.  Note that this should be
-  /// called while the predecessor still refers to this block.
-  ///
-  void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs = false);
-
-  /// splitBasicBlock - This splits a basic block into two at the specified
-  /// instruction.  Note that all instructions BEFORE the specified iterator
-  /// stay as part of the original basic block, an unconditional branch is added
-  /// to the original BB, and the rest of the instructions in the BB are moved
-  /// to the new BB, including the old terminator.  The newly formed BasicBlock
-  /// is returned.  This function invalidates the specified iterator.
-  ///
-  /// Note that this only works on well formed basic blocks (must have a
-  /// terminator), and 'I' must not be the end of instruction list (which would
-  /// cause a degenerate basic block to be formed, having a terminator inside of
-  /// the basic block).
-  ///
-  /// Also note that this doesn't preserve any passes. To split blocks while
-  /// keeping loop information consistent, use the SplitBlock utility function.
-  ///
-  BasicBlock *splitBasicBlock(iterator I, const Twine &BBName = "");
-
-  /// hasAddressTaken - returns true if there are any uses of this basic block
-  /// other than direct branches, switches, etc. to it.
-  bool hasAddressTaken() const { return getSubclassDataFromValue() != 0; }
-
-  /// replaceSuccessorsPhiUsesWith - Update all phi nodes in all our successors
-  /// to refer to basic block New instead of to us.
-  void replaceSuccessorsPhiUsesWith(BasicBlock *New);
-
-  /// isLandingPad - Return true if this basic block is a landing pad. I.e.,
-  /// it's the destination of the 'unwind' edge of an invoke instruction.
-  bool isLandingPad() const;
-
-  /// getLandingPadInst() - Return the landingpad instruction associated with
-  /// the landing pad.
-  LandingPadInst *getLandingPadInst();
-  const LandingPadInst *getLandingPadInst() const;
-
-private:
-  /// AdjustBlockAddressRefCount - BasicBlock stores the number of BlockAddress
-  /// objects using it.  This is almost always 0, sometimes one, possibly but
-  /// almost never 2, and inconceivably 3 or more.
-  void AdjustBlockAddressRefCount(int Amt) {
-    setValueSubclassData(getSubclassDataFromValue()+Amt);
-    assert((int)(signed char)getSubclassDataFromValue() >= 0 &&
-           "Refcount wrap-around");
-  }
-  // Shadow Value::setValueSubclassData with a private forwarding method so that
-  // any future subclasses cannot accidentally use it.
-  void setValueSubclassData(unsigned short D) {
-    Value::setValueSubclassData(D);
-  }
-};
-
-} // End llvm namespace
-
-#endif
index f8cb425..32ffca7 100644 (file)
@@ -1,10 +1,4 @@
-set(LLVM_TARGET_DEFINITIONS Intrinsics.td)
-
-tablegen(LLVM Intrinsics.gen -gen-intrinsic)
-
-add_custom_target(intrinsics_gen ALL
-  DEPENDS ${llvm_builded_incs_dir}/Intrinsics.gen)
-set_target_properties(intrinsics_gen PROPERTIES FOLDER "Tablegenning")
+add_subdirectory(IR)
 
 if( MSVC_IDE OR XCODE )
   # Creates a dummy target containing all headers for the benefit of
diff --git a/include/llvm/CallingConv.h b/include/llvm/CallingConv.h
deleted file mode 100644 (file)
index 699cea3..0000000
+++ /dev/null
@@ -1,129 +0,0 @@
-//===-- llvm/CallingConv.h - LLVM Calling Conventions -----------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines LLVM's set of calling conventions.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CALLINGCONV_H
-#define LLVM_CALLINGCONV_H
-
-namespace llvm {
-
-/// CallingConv Namespace - This namespace contains an enum with a value for
-/// the well-known calling conventions.
-///
-namespace CallingConv {
-  /// A set of enums which specify the assigned numeric values for known llvm
-  /// calling conventions.
-  /// @brief LLVM Calling Convention Representation
-  enum ID {
-    /// C - The default llvm calling convention, compatible with C.  This
-    /// convention is the only calling convention that supports varargs calls.
-    /// As with typical C calling conventions, the callee/caller have to
-    /// tolerate certain amounts of prototype mismatch.
-    C = 0,
-
-    // Generic LLVM calling conventions.  None of these calling conventions
-    // support varargs calls, and all assume that the caller and callee
-    // prototype exactly match.
-
-    /// Fast - This calling convention attempts to make calls as fast as
-    /// possible (e.g. by passing things in registers).
-    Fast = 8,
-
-    // Cold - This calling convention attempts to make code in the caller as
-    // efficient as possible under the assumption that the call is not commonly
-    // executed.  As such, these calls often preserve all registers so that the
-    // call does not break any live ranges in the caller side.
-    Cold = 9,
-
-    // GHC - Calling convention used by the Glasgow Haskell Compiler (GHC).
-    GHC = 10,
-
-    // HiPE - Calling convention used by the High-Performance Erlang Compiler
-    // (HiPE).
-    HiPE = 11,
-
-    // Target - This is the start of the target-specific calling conventions,
-    // e.g. fastcall and thiscall on X86.
-    FirstTargetCC = 64,
-
-    /// X86_StdCall - stdcall is the calling conventions mostly used by the
-    /// Win32 API. It is basically the same as the C convention with the
-    /// difference in that the callee is responsible for popping the arguments
-    /// from the stack.
-    X86_StdCall = 64,
-
-    /// X86_FastCall - 'fast' analog of X86_StdCall. Passes first two arguments
-    /// in ECX:EDX registers, others - via stack. Callee is responsible for
-    /// stack cleaning.
-    X86_FastCall = 65,
-
-    /// ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete,
-    /// but still used on some targets).
-    ARM_APCS = 66,
-
-    /// ARM_AAPCS - ARM Architecture Procedure Calling Standard calling
-    /// convention (aka EABI). Soft float variant.
-    ARM_AAPCS = 67,
-
-    /// ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
-    ARM_AAPCS_VFP = 68,
-
-    /// MSP430_INTR - Calling convention used for MSP430 interrupt routines.
-    MSP430_INTR = 69,
-
-    /// X86_ThisCall - Similar to X86_StdCall. Passes first argument in ECX,
-    /// others via stack. Callee is responsible for stack cleaning. MSVC uses
-    /// this by default for methods in its ABI.
-    X86_ThisCall = 70,
-
-    /// PTX_Kernel - Call to a PTX kernel.
-    /// Passes all arguments in parameter space.
-    PTX_Kernel = 71,
-
-    /// PTX_Device - Call to a PTX device function.
-    /// Passes all arguments in register or parameter space.
-    PTX_Device = 72,
-
-    /// MBLAZE_INTR - Calling convention used for MBlaze interrupt routines.
-    MBLAZE_INTR = 73,
-
-    /// MBLAZE_INTR - Calling convention used for MBlaze interrupt support
-    /// routines (i.e. GCC's save_volatiles attribute).
-    MBLAZE_SVOL = 74,
-
-    /// SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
-    /// No lowering or expansion of arguments.
-    /// Structures are passed as a pointer to a struct with the byval attribute.
-    /// Functions can only call SPIR_FUNC and SPIR_KERNEL functions.
-    /// Functions can only have zero or one return values.
-    /// Variable arguments are not allowed, except for printf.
-    /// How arguments/return values are lowered are not specified.
-    /// Functions are only visible to the devices.
-    SPIR_FUNC = 75,
-
-    /// SPIR_KERNEL - Calling convention for SPIR kernel functions.
-    /// Inherits the restrictions of SPIR_FUNC, except
-    /// Cannot have non-void return values.
-    /// Cannot have variable arguments.
-    /// Can also be called by the host.
-    /// Is externally visible.
-    SPIR_KERNEL = 76,
-
-    /// Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins
-    Intel_OCL_BI = 77
-
-  };
-} // End CallingConv namespace
-
-} // End llvm namespace
-
-#endif
index e8e991c..b54c762 100644 (file)
@@ -18,8 +18,8 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/ValueTypes.h"
-#include "llvm/InlineAsm.h"
-#include "llvm/Instructions.h"
+#include "llvm/IR/InlineAsm.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/Support/CallSite.h"
 
 namespace llvm {
index 751199b..e0a6e3f 100644 (file)
@@ -17,7 +17,7 @@
 #define LLVM_CODEGEN_ASMPRINTER_H
 
 #include "llvm/CodeGen/MachineFunctionPass.h"
-#include "llvm/InlineAsm.h"
+#include "llvm/IR/InlineAsm.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 
index 8fa8bed..fab470b 100644 (file)
 #define LLVM_CODEGEN_CALLINGCONVLOWER_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/CallingConv.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/IR/CallingConv.h"
 #include "llvm/Target/TargetCallingConv.h"
 
 namespace llvm {
index 451dc99..72e0937 100644 (file)
@@ -25,8 +25,8 @@
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/ValueTypes.h"
-#include "llvm/InlineAsm.h"
-#include "llvm/Instructions.h"
+#include "llvm/IR/InlineAsm.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/Support/CallSite.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include <vector>
index 5a3fb4b..68389dd 100644 (file)
@@ -16,7 +16,7 @@
 #ifndef LLVM_CODEGEN_INTRINSICLOWERING_H
 #define LLVM_CODEGEN_INTRINSICLOWERING_H
 
-#include "llvm/Intrinsics.h"
+#include "llvm/IR/Intrinsics.h"
 
 namespace llvm {
   class CallInst;
index 9d54ad8..3cb6b4d 100644 (file)
@@ -21,7 +21,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Metadata.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/Support/DebugLoc.h"
 #include "llvm/Support/ValueHandle.h"
 #include <utility>
index de553a7..4af48f7 100644 (file)
@@ -23,7 +23,7 @@
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/CodeGen/MachineOperand.h"
-#include "llvm/InlineAsm.h"
+#include "llvm/IR/InlineAsm.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/Support/DebugLoc.h"
 #include "llvm/Target/TargetOpcodes.h"
index cf9e8b6..6194d05 100644 (file)
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/GlobalValue.h"
+#include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MachineLocation.h"
-#include "llvm/Metadata.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/DebugLoc.h"
index 8f52d3b..df74d08 100644 (file)
@@ -14,7 +14,7 @@
 #ifndef LLVM_CODEGEN_PSEUDOSOURCEVALUE_H
 #define LLVM_CODEGEN_PSEUDOSOURCEVALUE_H
 
-#include "llvm/Value.h"
+#include "llvm/IR/Value.h"
 
 namespace llvm {
   class MachineFrameInfo;
index 95d4c37..782118f 100644 (file)
@@ -15,9 +15,9 @@
 #ifndef LLVM_CODEGEN_SELECTIONDAG_ISEL_H
 #define LLVM_CODEGEN_SELECTIONDAG_ISEL_H
 
-#include "llvm/BasicBlock.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/SelectionDAG.h"
+#include "llvm/IR/BasicBlock.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
index 82fa3f8..2c34b4f 100644 (file)
@@ -28,8 +28,8 @@
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/CodeGen/ValueTypes.h"
-#include "llvm/Constants.h"
-#include "llvm/Instructions.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/DebugLoc.h"
 #include "llvm/Support/MathExtras.h"
diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h
deleted file mode 100644 (file)
index b3cb449..0000000
+++ /dev/null
@@ -1,167 +0,0 @@
-//===-- llvm/Constant.h - Constant class definition -------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the declaration of the Constant class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CONSTANT_H
-#define LLVM_CONSTANT_H
-
-#include "llvm/User.h"
-
-namespace llvm {
-  class APInt;
-
-  template<typename T> class SmallVectorImpl;
-
-/// This is an important base class in LLVM. It provides the common facilities
-/// of all constant values in an LLVM program. A constant is a value that is
-/// immutable at runtime. Functions are constants because their address is
-/// immutable. Same with global variables. 
-/// 
-/// All constants share the capabilities provided in this class. All constants
-/// can have a null value. They can have an operand list. Constants can be
-/// simple (integer and floating point values), complex (arrays and structures),
-/// or expression based (computations yielding a constant value composed of 
-/// only certain operators and other constant values).
-/// 
-/// Note that Constants are immutable (once created they never change) 
-/// and are fully shared by structural equivalence.  This means that two 
-/// structurally equivalent constants will always have the same address.  
-/// Constants are created on demand as needed and never deleted: thus clients 
-/// don't have to worry about the lifetime of the objects.
-/// @brief LLVM Constant Representation
-class Constant : public User {
-  void operator=(const Constant &) LLVM_DELETED_FUNCTION;
-  Constant(const Constant &) LLVM_DELETED_FUNCTION;
-  virtual void anchor();
-  
-protected:
-  Constant(Type *ty, ValueTy vty, Use *Ops, unsigned NumOps)
-    : User(ty, vty, Ops, NumOps) {}
-
-  void destroyConstantImpl();
-public:
-  /// isNullValue - Return true if this is the value that would be returned by
-  /// getNullValue.
-  bool isNullValue() const;
-
-  /// isAllOnesValue - Return true if this is the value that would be returned by
-  /// getAllOnesValue.
-  bool isAllOnesValue() const;
-
-  /// isNegativeZeroValue - Return true if the value is what would be returned 
-  /// by getZeroValueForNegation.
-  bool isNegativeZeroValue() const;
-
-  /// canTrap - Return true if evaluation of this constant could trap.  This is
-  /// true for things like constant expressions that could divide by zero.
-  bool canTrap() const;
-
-  /// isThreadDependent - Return true if the value can vary between threads.
-  bool isThreadDependent() const;
-
-  /// isConstantUsed - Return true if the constant has users other than constant
-  /// exprs and other dangling things.
-  bool isConstantUsed() const;
-  
-  enum PossibleRelocationsTy {
-    NoRelocation = 0,
-    LocalRelocation = 1,
-    GlobalRelocations = 2
-  };
-  
-  /// getRelocationInfo - This method classifies the entry according to
-  /// whether or not it may generate a relocation entry.  This must be
-  /// conservative, so if it might codegen to a relocatable entry, it should say
-  /// so.  The return values are:
-  /// 
-  ///  NoRelocation: This constant pool entry is guaranteed to never have a
-  ///     relocation applied to it (because it holds a simple constant like
-  ///     '4').
-  ///  LocalRelocation: This entry has relocations, but the entries are
-  ///     guaranteed to be resolvable by the static linker, so the dynamic
-  ///     linker will never see them.
-  ///  GlobalRelocations: This entry may have arbitrary relocations.
-  ///
-  /// FIXME: This really should not be in VMCore.
-  PossibleRelocationsTy getRelocationInfo() const;
-  
-  /// getAggregateElement - For aggregates (struct/array/vector) return the
-  /// constant that corresponds to the specified element if possible, or null if
-  /// not.  This can return null if the element index is a ConstantExpr, or if
-  /// 'this' is a constant expr.
-  Constant *getAggregateElement(unsigned Elt) const;
-  Constant *getAggregateElement(Constant *Elt) const;
-
-  /// getSplatValue - If this is a splat vector constant, meaning that all of
-  /// the elements have the same value, return that value. Otherwise return 0.
-  Constant *getSplatValue() const;
-
-  /// If C is a constant integer then return its value, otherwise C must be a
-  /// vector of constant integers, all equal, and the common value is returned.
-  const APInt &getUniqueInteger() const;
-
-  /// destroyConstant - Called if some element of this constant is no longer
-  /// valid.  At this point only other constants may be on the use_list for this
-  /// constant.  Any constants on our Use list must also be destroy'd.  The
-  /// implementation must be sure to remove the constant from the list of
-  /// available cached constants.  Implementations should call
-  /// destroyConstantImpl as the last thing they do, to destroy all users and
-  /// delete this.
-  virtual void destroyConstant() { llvm_unreachable("Not reached!"); }
-
-  //// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Value *V) {
-    return V->getValueID() >= ConstantFirstVal &&
-           V->getValueID() <= ConstantLastVal;
-  }
-
-  /// replaceUsesOfWithOnConstant - This method is a special form of
-  /// User::replaceUsesOfWith (which does not work on constants) that does work
-  /// on constants.  Basically this method goes through the trouble of building
-  /// a new constant that is equivalent to the current one, with all uses of
-  /// From replaced with uses of To.  After this construction is completed, all
-  /// of the users of 'this' are replaced to use the new constant, and then
-  /// 'this' is deleted.  In general, you should not call this method, instead,
-  /// use Value::replaceAllUsesWith, which automatically dispatches to this
-  /// method as needed.
-  ///
-  virtual void replaceUsesOfWithOnConstant(Value *, Value *, Use *) {
-    // Provide a default implementation for constants (like integers) that
-    // cannot use any other values.  This cannot be called at runtime, but needs
-    // to be here to avoid link errors.
-    assert(getNumOperands() == 0 && "replaceUsesOfWithOnConstant must be "
-           "implemented for all constants that have operands!");
-    llvm_unreachable("Constants that do not have operands cannot be using "
-                     "'From'!");
-  }
-
-  static Constant *getNullValue(Type* Ty);
-
-  /// @returns the value for an integer or vector of integer constant of the
-  /// given type that has all its bits set to true.
-  /// @brief Get the all ones value
-  static Constant *getAllOnesValue(Type* Ty);
-
-  /// getIntegerValue - Return the value for an integer or pointer constant,
-  /// or a vector thereof, with the given scalar value.
-  static Constant *getIntegerValue(Type* Ty, const APInt &V);
-  
-  /// removeDeadConstantUsers - If there are any dead constant users dangling
-  /// off of this constant, remove them.  This method is useful for clients
-  /// that want to check to see if a global is unused, but don't want to deal
-  /// with potentially dead constants hanging off of the globals.
-  void removeDeadConstantUsers() const;
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
deleted file mode 100644 (file)
index 23e548a..0000000
+++ /dev/null
@@ -1,1163 +0,0 @@
-//===-- llvm/Constants.h - Constant class subclass definitions --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-/// @file
-/// This file contains the declarations for the subclasses of Constant,
-/// which represent the different flavors of constant values that live in LLVM.
-/// Note that Constants are immutable (once created they never change) and are
-/// fully shared by structural equivalence.  This means that two structurally
-/// equivalent constants will always have the same address.  Constant's are
-/// created on demand as needed and never deleted: thus clients don't have to
-/// worry about the lifetime of the objects.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CONSTANTS_H
-#define LLVM_CONSTANTS_H
-
-#include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/Constant.h"
-#include "llvm/OperandTraits.h"
-
-namespace llvm {
-
-class ArrayType;
-class IntegerType;
-class StructType;
-class PointerType;
-class VectorType;
-class SequentialType;
-
-template<class ConstantClass, class TypeClass, class ValType>
-struct ConstantCreator;
-template<class ConstantClass, class TypeClass>
-struct ConstantArrayCreator;
-template<class ConstantClass, class TypeClass>
-struct ConvertConstantType;
-
-//===----------------------------------------------------------------------===//
-/// This is the shared class of boolean and integer constants. This class
-/// represents both boolean and integral constants.
-/// @brief Class for constant integers.
-class ConstantInt : public Constant {
-  virtual void anchor();
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  ConstantInt(const ConstantInt &) LLVM_DELETED_FUNCTION;
-  ConstantInt(IntegerType *Ty, const APInt& V);
-  APInt Val;
-protected:
-  // allocate space for exactly zero operands
-  void *operator new(size_t s) {
-    return User::operator new(s, 0);
-  }
-public:
-  static ConstantInt *getTrue(LLVMContext &Context);
-  static ConstantInt *getFalse(LLVMContext &Context);
-  static Constant *getTrue(Type *Ty);
-  static Constant *getFalse(Type *Ty);
-
-  /// If Ty is a vector type, return a Constant with a splat of the given
-  /// value. Otherwise return a ConstantInt for the given value.
-  static Constant *get(Type *Ty, uint64_t V, bool isSigned = false);
-
-  /// Return a ConstantInt with the specified integer value for the specified
-  /// type. If the type is wider than 64 bits, the value will be zero-extended
-  /// to fit the type, unless isSigned is true, in which case the value will
-  /// be interpreted as a 64-bit signed integer and sign-extended to fit
-  /// the type.
-  /// @brief Get a ConstantInt for a specific value.
-  static ConstantInt *get(IntegerType *Ty, uint64_t V,
-                          bool isSigned = false);
-
-  /// Return a ConstantInt with the specified value for the specified type. The
-  /// value V will be canonicalized to a an unsigned APInt. Accessing it with
-  /// either getSExtValue() or getZExtValue() will yield a correctly sized and
-  /// signed value for the type Ty.
-  /// @brief Get a ConstantInt for a specific signed value.
-  static ConstantInt *getSigned(IntegerType *Ty, int64_t V);
-  static Constant *getSigned(Type *Ty, int64_t V);
-
-  /// Return a ConstantInt with the specified value and an implied Type. The
-  /// type is the integer type that corresponds to the bit width of the value.
-  static ConstantInt *get(LLVMContext &Context, const APInt &V);
-
-  /// Return a ConstantInt constructed from the string strStart with the given
-  /// radix.
-  static ConstantInt *get(IntegerType *Ty, StringRef Str,
-                          uint8_t radix);
-
-  /// If Ty is a vector type, return a Constant with a splat of the given
-  /// value. Otherwise return a ConstantInt for the given value.
-  static Constant *get(Type* Ty, const APInt& V);
-
-  /// Return the constant as an APInt value reference. This allows clients to
-  /// obtain a copy of the value, with all its precision in tact.
-  /// @brief Return the constant's value.
-  inline const APInt &getValue() const {
-    return Val;
-  }
-
-  /// getBitWidth - Return the bitwidth of this constant.
-  unsigned getBitWidth() const { return Val.getBitWidth(); }
-
-  /// Return the constant as a 64-bit unsigned integer value after it
-  /// has been zero extended as appropriate for the type of this constant. Note
-  /// that this method can assert if the value does not fit in 64 bits.
-  /// @deprecated
-  /// @brief Return the zero extended value.
-  inline uint64_t getZExtValue() const {
-    return Val.getZExtValue();
-  }
-
-  /// Return the constant as a 64-bit integer value after it has been sign
-  /// extended as appropriate for the type of this constant. Note that
-  /// this method can assert if the value does not fit in 64 bits.
-  /// @deprecated
-  /// @brief Return the sign extended value.
-  inline int64_t getSExtValue() const {
-    return Val.getSExtValue();
-  }
-
-  /// A helper method that can be used to determine if the constant contained
-  /// within is equal to a constant.  This only works for very small values,
-  /// because this is all that can be represented with all types.
-  /// @brief Determine if this constant's value is same as an unsigned char.
-  bool equalsInt(uint64_t V) const {
-    return Val == V;
-  }
-
-  /// getType - Specialize the getType() method to always return an IntegerType,
-  /// which reduces the amount of casting needed in parts of the compiler.
-  ///
-  inline IntegerType *getType() const {
-    return reinterpret_cast<IntegerType*>(Value::getType());
-  }
-
-  /// This static method returns true if the type Ty is big enough to
-  /// represent the value V. This can be used to avoid having the get method
-  /// assert when V is larger than Ty can represent. Note that there are two
-  /// versions of this method, one for unsigned and one for signed integers.
-  /// Although ConstantInt canonicalizes everything to an unsigned integer,
-  /// the signed version avoids callers having to convert a signed quantity
-  /// to the appropriate unsigned type before calling the method.
-  /// @returns true if V is a valid value for type Ty
-  /// @brief Determine if the value is in range for the given type.
-  static bool isValueValidForType(Type *Ty, uint64_t V);
-  static bool isValueValidForType(Type *Ty, int64_t V);
-
-  bool isNegative() const { return Val.isNegative(); }
-
-  /// This is just a convenience method to make client code smaller for a
-  /// common code. It also correctly performs the comparison without the
-  /// potential for an assertion from getZExtValue().
-  bool isZero() const {
-    return Val == 0;
-  }
-
-  /// This is just a convenience method to make client code smaller for a
-  /// common case. It also correctly performs the comparison without the
-  /// potential for an assertion from getZExtValue().
-  /// @brief Determine if the value is one.
-  bool isOne() const {
-    return Val == 1;
-  }
-
-  /// This function will return true iff every bit in this constant is set
-  /// to true.
-  /// @returns true iff this constant's bits are all set to true.
-  /// @brief Determine if the value is all ones.
-  bool isMinusOne() const {
-    return Val.isAllOnesValue();
-  }
-
-  /// This function will return true iff this constant represents the largest
-  /// value that may be represented by the constant's type.
-  /// @returns true iff this is the largest value that may be represented
-  /// by this type.
-  /// @brief Determine if the value is maximal.
-  bool isMaxValue(bool isSigned) const {
-    if (isSigned)
-      return Val.isMaxSignedValue();
-    else
-      return Val.isMaxValue();
-  }
-
-  /// This function will return true iff this constant represents the smallest
-  /// value that may be represented by this constant's type.
-  /// @returns true if this is the smallest value that may be represented by
-  /// this type.
-  /// @brief Determine if the value is minimal.
-  bool isMinValue(bool isSigned) const {
-    if (isSigned)
-      return Val.isMinSignedValue();
-    else
-      return Val.isMinValue();
-  }
-
-  /// This function will return true iff this constant represents a value with
-  /// active bits bigger than 64 bits or a value greater than the given uint64_t
-  /// value.
-  /// @returns true iff this constant is greater or equal to the given number.
-  /// @brief Determine if the value is greater or equal to the given number.
-  bool uge(uint64_t Num) const {
-    return Val.getActiveBits() > 64 || Val.getZExtValue() >= Num;
-  }
-
-  /// getLimitedValue - If the value is smaller than the specified limit,
-  /// return it, otherwise return the limit value.  This causes the value
-  /// to saturate to the limit.
-  /// @returns the min of the value of the constant and the specified value
-  /// @brief Get the constant's value with a saturation limit
-  uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const {
-    return Val.getLimitedValue(Limit);
-  }
-
-  /// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantIntVal;
-  }
-};
-
-
-//===----------------------------------------------------------------------===//
-/// ConstantFP - Floating Point Values [float, double]
-///
-class ConstantFP : public Constant {
-  APFloat Val;
-  virtual void anchor();
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  ConstantFP(const ConstantFP &) LLVM_DELETED_FUNCTION;
-  friend class LLVMContextImpl;
-protected:
-  ConstantFP(Type *Ty, const APFloat& V);
-protected:
-  // allocate space for exactly zero operands
-  void *operator new(size_t s) {
-    return User::operator new(s, 0);
-  }
-public:
-  /// Floating point negation must be implemented with f(x) = -0.0 - x. This
-  /// method returns the negative zero constant for floating point or vector
-  /// floating point types; for all other types, it returns the null value.
-  static Constant *getZeroValueForNegation(Type *Ty);
-
-  /// get() - This returns a ConstantFP, or a vector containing a splat of a
-  /// ConstantFP, for the specified value in the specified type.  This should
-  /// only be used for simple constant values like 2.0/1.0 etc, that are
-  /// known-valid both as host double and as the target format.
-  static Constant *get(Type* Ty, double V);
-  static Constant *get(Type* Ty, StringRef Str);
-  static ConstantFP *get(LLVMContext &Context, const APFloat &V);
-  static ConstantFP *getNegativeZero(Type* Ty);
-  static ConstantFP *getInfinity(Type *Ty, bool Negative = false);
-
-  /// isValueValidForType - return true if Ty is big enough to represent V.
-  static bool isValueValidForType(Type *Ty, const APFloat &V);
-  inline const APFloat &getValueAPF() const { return Val; }
-
-  /// isZero - Return true if the value is positive or negative zero.
-  bool isZero() const { return Val.isZero(); }
-
-  /// isNegative - Return true if the sign bit is set.
-  bool isNegative() const { return Val.isNegative(); }
-
-  /// isNaN - Return true if the value is a NaN.
-  bool isNaN() const { return Val.isNaN(); }
-
-  /// isExactlyValue - We don't rely on operator== working on double values, as
-  /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
-  /// As such, this method can be used to do an exact bit-for-bit comparison of
-  /// two floating point values.  The version with a double operand is retained
-  /// because it's so convenient to write isExactlyValue(2.0), but please use
-  /// it only for simple constants.
-  bool isExactlyValue(const APFloat &V) const;
-
-  bool isExactlyValue(double V) const {
-    bool ignored;
-    APFloat FV(V);
-    FV.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven, &ignored);
-    return isExactlyValue(FV);
-  }
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantFPVal;
-  }
-};
-
-//===----------------------------------------------------------------------===//
-/// ConstantAggregateZero - All zero aggregate value
-///
-class ConstantAggregateZero : public Constant {
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  ConstantAggregateZero(const ConstantAggregateZero &) LLVM_DELETED_FUNCTION;
-protected:
-  explicit ConstantAggregateZero(Type *ty)
-    : Constant(ty, ConstantAggregateZeroVal, 0, 0) {}
-protected:
-  // allocate space for exactly zero operands
-  void *operator new(size_t s) {
-    return User::operator new(s, 0);
-  }
-public:
-  static ConstantAggregateZero *get(Type *Ty);
-
-  virtual void destroyConstant();
-
-  /// getSequentialElement - If this CAZ has array or vector type, return a zero
-  /// with the right element type.
-  Constant *getSequentialElement() const;
-
-  /// getStructElement - If this CAZ has struct type, return a zero with the
-  /// right element type for the specified element.
-  Constant *getStructElement(unsigned Elt) const;
-
-  /// getElementValue - Return a zero of the right value for the specified GEP
-  /// index.
-  Constant *getElementValue(Constant *C) const;
-
-  /// getElementValue - Return a zero of the right value for the specified GEP
-  /// index.
-  Constant *getElementValue(unsigned Idx) const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  ///
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantAggregateZeroVal;
-  }
-};
-
-
-//===----------------------------------------------------------------------===//
-/// ConstantArray - Constant Array Declarations
-///
-class ConstantArray : public Constant {
-  friend struct ConstantArrayCreator<ConstantArray, ArrayType>;
-  ConstantArray(const ConstantArray &) LLVM_DELETED_FUNCTION;
-protected:
-  ConstantArray(ArrayType *T, ArrayRef<Constant *> Val);
-public:
-  // ConstantArray accessors
-  static Constant *get(ArrayType *T, ArrayRef<Constant*> V);
-
-  /// Transparently provide more efficient getOperand methods.
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
-
-  /// getType - Specialize the getType() method to always return an ArrayType,
-  /// which reduces the amount of casting needed in parts of the compiler.
-  ///
-  inline ArrayType *getType() const {
-    return reinterpret_cast<ArrayType*>(Value::getType());
-  }
-
-  virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantArrayVal;
-  }
-};
-
-template <>
-struct OperandTraits<ConstantArray> :
-  public VariadicOperandTraits<ConstantArray> {
-};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantArray, Constant)
-
-//===----------------------------------------------------------------------===//
-// ConstantStruct - Constant Struct Declarations
-//
-class ConstantStruct : public Constant {
-  friend struct ConstantArrayCreator<ConstantStruct, StructType>;
-  ConstantStruct(const ConstantStruct &) LLVM_DELETED_FUNCTION;
-protected:
-  ConstantStruct(StructType *T, ArrayRef<Constant *> Val);
-public:
-  // ConstantStruct accessors
-  static Constant *get(StructType *T, ArrayRef<Constant*> V);
-  static Constant *get(StructType *T, ...) END_WITH_NULL;
-
-  /// getAnon - Return an anonymous struct that has the specified
-  /// elements.  If the struct is possibly empty, then you must specify a
-  /// context.
-  static Constant *getAnon(ArrayRef<Constant*> V, bool Packed = false) {
-    return get(getTypeForElements(V, Packed), V);
-  }
-  static Constant *getAnon(LLVMContext &Ctx,
-                           ArrayRef<Constant*> V, bool Packed = false) {
-    return get(getTypeForElements(Ctx, V, Packed), V);
-  }
-
-  /// getTypeForElements - Return an anonymous struct type to use for a constant
-  /// with the specified set of elements.  The list must not be empty.
-  static StructType *getTypeForElements(ArrayRef<Constant*> V,
-                                        bool Packed = false);
-  /// getTypeForElements - This version of the method allows an empty list.
-  static StructType *getTypeForElements(LLVMContext &Ctx,
-                                        ArrayRef<Constant*> V,
-                                        bool Packed = false);
-
-  /// Transparently provide more efficient getOperand methods.
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
-
-  /// getType() specialization - Reduce amount of casting...
-  ///
-  inline StructType *getType() const {
-    return reinterpret_cast<StructType*>(Value::getType());
-  }
-
-  virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantStructVal;
-  }
-};
-
-template <>
-struct OperandTraits<ConstantStruct> :
-  public VariadicOperandTraits<ConstantStruct> {
-};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantStruct, Constant)
-
-
-//===----------------------------------------------------------------------===//
-/// ConstantVector - Constant Vector Declarations
-///
-class ConstantVector : public Constant {
-  friend struct ConstantArrayCreator<ConstantVector, VectorType>;
-  ConstantVector(const ConstantVector &) LLVM_DELETED_FUNCTION;
-protected:
-  ConstantVector(VectorType *T, ArrayRef<Constant *> Val);
-public:
-  // ConstantVector accessors
-  static Constant *get(ArrayRef<Constant*> V);
-
-  /// getSplat - Return a ConstantVector with the specified constant in each
-  /// element.
-  static Constant *getSplat(unsigned NumElts, Constant *Elt);
-
-  /// Transparently provide more efficient getOperand methods.
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
-
-  /// getType - Specialize the getType() method to always return a VectorType,
-  /// which reduces the amount of casting needed in parts of the compiler.
-  ///
-  inline VectorType *getType() const {
-    return reinterpret_cast<VectorType*>(Value::getType());
-  }
-
-  /// getSplatValue - If this is a splat constant, meaning that all of the
-  /// elements have the same value, return that value. Otherwise return NULL.
-  Constant *getSplatValue() const;
-
-  virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantVectorVal;
-  }
-};
-
-template <>
-struct OperandTraits<ConstantVector> :
-  public VariadicOperandTraits<ConstantVector> {
-};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantVector, Constant)
-
-//===----------------------------------------------------------------------===//
-/// ConstantPointerNull - a constant pointer value that points to null
-///
-class ConstantPointerNull : public Constant {
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  ConstantPointerNull(const ConstantPointerNull &) LLVM_DELETED_FUNCTION;
-protected:
-  explicit ConstantPointerNull(PointerType *T)
-    : Constant(reinterpret_cast<Type*>(T),
-               Value::ConstantPointerNullVal, 0, 0) {}
-
-protected:
-  // allocate space for exactly zero operands
-  void *operator new(size_t s) {
-    return User::operator new(s, 0);
-  }
-public:
-  /// get() - Static factory methods - Return objects of the specified value
-  static ConstantPointerNull *get(PointerType *T);
-
-  virtual void destroyConstant();
-
-  /// getType - Specialize the getType() method to always return an PointerType,
-  /// which reduces the amount of casting needed in parts of the compiler.
-  ///
-  inline PointerType *getType() const {
-    return reinterpret_cast<PointerType*>(Value::getType());
-  }
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantPointerNullVal;
-  }
-};
-
-//===----------------------------------------------------------------------===//
-/// ConstantDataSequential - A vector or array constant whose element type is a
-/// simple 1/2/4/8-byte integer or float/double, and whose elements are just
-/// simple data values (i.e. ConstantInt/ConstantFP).  This Constant node has no
-/// operands because it stores all of the elements of the constant as densely
-/// packed data, instead of as Value*'s.
-///
-/// This is the common base class of ConstantDataArray and ConstantDataVector.
-///
-class ConstantDataSequential : public Constant {
-  friend class LLVMContextImpl;
-  /// DataElements - A pointer to the bytes underlying this constant (which is
-  /// owned by the uniquing StringMap).
-  const char *DataElements;
-
-  /// Next - This forms a link list of ConstantDataSequential nodes that have
-  /// the same value but different type.  For example, 0,0,0,1 could be a 4
-  /// element array of i8, or a 1-element array of i32.  They'll both end up in
-  /// the same StringMap bucket, linked up.
-  ConstantDataSequential *Next;
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  ConstantDataSequential(const ConstantDataSequential &) LLVM_DELETED_FUNCTION;
-protected:
-  explicit ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
-    : Constant(ty, VT, 0, 0), DataElements(Data), Next(0) {}
-  ~ConstantDataSequential() { delete Next; }
-
-  static Constant *getImpl(StringRef Bytes, Type *Ty);
-
-protected:
-  // allocate space for exactly zero operands.
-  void *operator new(size_t s) {
-    return User::operator new(s, 0);
-  }
-public:
-
-  /// isElementTypeCompatible - Return true if a ConstantDataSequential can be
-  /// formed with a vector or array of the specified element type.
-  /// ConstantDataArray only works with normal float and int types that are
-  /// stored densely in memory, not with things like i42 or x86_f80.
-  static bool isElementTypeCompatible(const Type *Ty);
-
-  /// getElementAsInteger - If this is a sequential container of integers (of
-  /// any size), return the specified element in the low bits of a uint64_t.
-  uint64_t getElementAsInteger(unsigned i) const;
-
-  /// getElementAsAPFloat - If this is a sequential container of floating point
-  /// type, return the specified element as an APFloat.
-  APFloat getElementAsAPFloat(unsigned i) const;
-
-  /// getElementAsFloat - If this is an sequential container of floats, return
-  /// the specified element as a float.
-  float getElementAsFloat(unsigned i) const;
-
-  /// getElementAsDouble - If this is an sequential container of doubles, return
-  /// the specified element as a double.
-  double getElementAsDouble(unsigned i) const;
-
-  /// getElementAsConstant - Return a Constant for a specified index's element.
-  /// Note that this has to compute a new constant to return, so it isn't as
-  /// efficient as getElementAsInteger/Float/Double.
-  Constant *getElementAsConstant(unsigned i) const;
-
-  /// getType - Specialize the getType() method to always return a
-  /// SequentialType, which reduces the amount of casting needed in parts of the
-  /// compiler.
-  inline SequentialType *getType() const {
-    return reinterpret_cast<SequentialType*>(Value::getType());
-  }
-
-  /// getElementType - Return the element type of the array/vector.
-  Type *getElementType() const;
-
-  /// getNumElements - Return the number of elements in the array or vector.
-  unsigned getNumElements() const;
-
-  /// getElementByteSize - Return the size (in bytes) of each element in the
-  /// array/vector.  The size of the elements is known to be a multiple of one
-  /// byte.
-  uint64_t getElementByteSize() const;
-
-
-  /// isString - This method returns true if this is an array of i8.
-  bool isString() const;
-
-  /// isCString - This method returns true if the array "isString", ends with a
-  /// nul byte, and does not contains any other nul bytes.
-  bool isCString() const;
-
-  /// getAsString - If this array is isString(), then this method returns the
-  /// array as a StringRef.  Otherwise, it asserts out.
-  ///
-  StringRef getAsString() const {
-    assert(isString() && "Not a string");
-    return getRawDataValues();
-  }
-
-  /// getAsCString - If this array is isCString(), then this method returns the
-  /// array (without the trailing null byte) as a StringRef. Otherwise, it
-  /// asserts out.
-  ///
-  StringRef getAsCString() const {
-    assert(isCString() && "Isn't a C string");
-    StringRef Str = getAsString();
-    return Str.substr(0, Str.size()-1);
-  }
-
-  /// getRawDataValues - Return the raw, underlying, bytes of this data.  Note
-  /// that this is an extremely tricky thing to work with, as it exposes the
-  /// host endianness of the data elements.
-  StringRef getRawDataValues() const;
-
-  virtual void destroyConstant();
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  ///
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantDataArrayVal ||
-           V->getValueID() == ConstantDataVectorVal;
-  }
-private:
-  const char *getElementPointer(unsigned Elt) const;
-};
-
-//===----------------------------------------------------------------------===//
-/// ConstantDataArray - An array constant whose element type is a simple
-/// 1/2/4/8-byte integer or float/double, and whose elements are just simple
-/// data values (i.e. ConstantInt/ConstantFP).  This Constant node has no
-/// operands because it stores all of the elements of the constant as densely
-/// packed data, instead of as Value*'s.
-class ConstantDataArray : public ConstantDataSequential {
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  ConstantDataArray(const ConstantDataArray &) LLVM_DELETED_FUNCTION;
-  virtual void anchor();
-  friend class ConstantDataSequential;
-  explicit ConstantDataArray(Type *ty, const char *Data)
-    : ConstantDataSequential(ty, ConstantDataArrayVal, Data) {}
-protected:
-  // allocate space for exactly zero operands.
-  void *operator new(size_t s) {
-    return User::operator new(s, 0);
-  }
-public:
-
-  /// get() constructors - Return a constant with array type with an element
-  /// count and element type matching the ArrayRef passed in.  Note that this
-  /// can return a ConstantAggregateZero object.
-  static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint16_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint32_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint64_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
-
-  /// getString - This method constructs a CDS and initializes it with a text
-  /// string. The default behavior (AddNull==true) causes a null terminator to
-  /// be placed at the end of the array (increasing the length of the string by
-  /// one more than the StringRef would normally indicate.  Pass AddNull=false
-  /// to disable this behavior.
-  static Constant *getString(LLVMContext &Context, StringRef Initializer,
-                             bool AddNull = true);
-
-  /// getType - Specialize the getType() method to always return an ArrayType,
-  /// which reduces the amount of casting needed in parts of the compiler.
-  ///
-  inline ArrayType *getType() const {
-    return reinterpret_cast<ArrayType*>(Value::getType());
-  }
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  ///
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantDataArrayVal;
-  }
-};
-
-//===----------------------------------------------------------------------===//
-/// ConstantDataVector - A vector constant whose element type is a simple
-/// 1/2/4/8-byte integer or float/double, and whose elements are just simple
-/// data values (i.e. ConstantInt/ConstantFP).  This Constant node has no
-/// operands because it stores all of the elements of the constant as densely
-/// packed data, instead of as Value*'s.
-class ConstantDataVector : public ConstantDataSequential {
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  ConstantDataVector(const ConstantDataVector &) LLVM_DELETED_FUNCTION;
-  virtual void anchor();
-  friend class ConstantDataSequential;
-  explicit ConstantDataVector(Type *ty, const char *Data)
-  : ConstantDataSequential(ty, ConstantDataVectorVal, Data) {}
-protected:
-  // allocate space for exactly zero operands.
-  void *operator new(size_t s) {
-    return User::operator new(s, 0);
-  }
-public:
-
-  /// get() constructors - Return a constant with vector type with an element
-  /// count and element type matching the ArrayRef passed in.  Note that this
-  /// can return a ConstantAggregateZero object.
-  static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint16_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint32_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint64_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
-
-  /// getSplat - Return a ConstantVector with the specified constant in each
-  /// element.  The specified constant has to be a of a compatible type (i8/i16/
-  /// i32/i64/float/double) and must be a ConstantFP or ConstantInt.
-  static Constant *getSplat(unsigned NumElts, Constant *Elt);
-
-  /// getSplatValue - If this is a splat constant, meaning that all of the
-  /// elements have the same value, return that value. Otherwise return NULL.
-  Constant *getSplatValue() const;
-
-  /// getType - Specialize the getType() method to always return a VectorType,
-  /// which reduces the amount of casting needed in parts of the compiler.
-  ///
-  inline VectorType *getType() const {
-    return reinterpret_cast<VectorType*>(Value::getType());
-  }
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  ///
-  static bool classof(const Value *V) {
-    return V->getValueID() == ConstantDataVectorVal;
-  }
-};
-
-
-
-/// BlockAddress - The address of a basic block.
-///
-class BlockAddress : public Constant {
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  void *operator new(size_t s) { return User::operator new(s, 2); }
-  BlockAddress(Function *F, BasicBlock *BB);
-public:
-  /// get - Return a BlockAddress for the specified function and basic block.
-  static BlockAddress *get(Function *F, BasicBlock *BB);
-
-  /// get - Return a BlockAddress for the specified basic block.  The basic
-  /// block must be embedded into a function.
-  static BlockAddress *get(BasicBlock *BB);
-
-  /// Transparently provide more efficient getOperand methods.
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
-
-  Function *getFunction() const { return (Function*)Op<0>().get(); }
-  BasicBlock *getBasicBlock() const { return (BasicBlock*)Op<1>().get(); }
-
-  virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Value *V) {
-    return V->getValueID() == BlockAddressVal;
-  }
-};
-
-template <>
-struct OperandTraits<BlockAddress> :
-  public FixedNumOperandTraits<BlockAddress, 2> {
-};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
-
-
-//===----------------------------------------------------------------------===//
-/// ConstantExpr - a constant value that is initialized with an expression using
-/// other constant values.
-///
-/// This class uses the standard Instruction opcodes to define the various
-/// constant expressions.  The Opcode field for the ConstantExpr class is
-/// maintained in the Value::SubclassData field.
-class ConstantExpr : public Constant {
-  friend struct ConstantCreator<ConstantExpr,Type,
-                            std::pair<unsigned, std::vector<Constant*> > >;
-  friend struct ConvertConstantType<ConstantExpr, Type>;
-
-protected:
-  ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
-    : Constant(ty, ConstantExprVal, Ops, NumOps) {
-    // Operation type (an Instruction opcode) is stored as the SubclassData.
-    setValueSubclassData(Opcode);
-  }
-
-public:
-  // Static methods to construct a ConstantExpr of different kinds.  Note that
-  // these methods may return a object that is not an instance of the
-  // ConstantExpr class, because they will attempt to fold the constant
-  // expression into something simpler if possible.
-
-  /// getAlignOf constant expr - computes the alignment of a type in a target
-  /// independent way (Note: the return type is an i64).
-  static Constant *getAlignOf(Type *Ty);
-
-  /// getSizeOf constant expr - computes the (alloc) size of a type (in
-  /// address-units, not bits) in a target independent way (Note: the return
-  /// type is an i64).
-  ///
-  static Constant *getSizeOf(Type *Ty);
-
-  /// getOffsetOf constant expr - computes the offset of a struct field in a
-  /// target independent way (Note: the return type is an i64).
-  ///
-  static Constant *getOffsetOf(StructType *STy, unsigned FieldNo);
-
-  /// getOffsetOf constant expr - This is a generalized form of getOffsetOf,
-  /// which supports any aggregate type, and any Constant index.
-  ///
-  static Constant *getOffsetOf(Type *Ty, Constant *FieldNo);
-
-  static Constant *getNeg(Constant *C, bool HasNUW = false, bool HasNSW =false);
-  static Constant *getFNeg(Constant *C);
-  static Constant *getNot(Constant *C);
-  static Constant *getAdd(Constant *C1, Constant *C2,
-                          bool HasNUW = false, bool HasNSW = false);
-  static Constant *getFAdd(Constant *C1, Constant *C2);
-  static Constant *getSub(Constant *C1, Constant *C2,
-                          bool HasNUW = false, bool HasNSW = false);
-  static Constant *getFSub(Constant *C1, Constant *C2);
-  static Constant *getMul(Constant *C1, Constant *C2,
-                          bool HasNUW = false, bool HasNSW = false);
-  static Constant *getFMul(Constant *C1, Constant *C2);
-  static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false);
-  static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false);
-  static Constant *getFDiv(Constant *C1, Constant *C2);
-  static Constant *getURem(Constant *C1, Constant *C2);
-  static Constant *getSRem(Constant *C1, Constant *C2);
-  static Constant *getFRem(Constant *C1, Constant *C2);
-  static Constant *getAnd(Constant *C1, Constant *C2);
-  static Constant *getOr(Constant *C1, Constant *C2);
-  static Constant *getXor(Constant *C1, Constant *C2);
-  static Constant *getShl(Constant *C1, Constant *C2,
-                          bool HasNUW = false, bool HasNSW = false);
-  static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
-  static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false);
-  static Constant *getTrunc   (Constant *C, Type *Ty);
-  static Constant *getSExt    (Constant *C, Type *Ty);
-  static Constant *getZExt    (Constant *C, Type *Ty);
-  static Constant *getFPTrunc (Constant *C, Type *Ty);
-  static Constant *getFPExtend(Constant *C, Type *Ty);
-  static Constant *getUIToFP  (Constant *C, Type *Ty);
-  static Constant *getSIToFP  (Constant *C, Type *Ty);
-  static Constant *getFPToUI  (Constant *C, Type *Ty);
-  static Constant *getFPToSI  (Constant *C, Type *Ty);
-  static Constant *getPtrToInt(Constant *C, Type *Ty);
-  static Constant *getIntToPtr(Constant *C, Type *Ty);
-  static Constant *getBitCast (Constant *C, Type *Ty);
-
-  static Constant *getNSWNeg(Constant *C) { return getNeg(C, false, true); }
-  static Constant *getNUWNeg(Constant *C) { return getNeg(C, true, false); }
-  static Constant *getNSWAdd(Constant *C1, Constant *C2) {
-    return getAdd(C1, C2, false, true);
-  }
-  static Constant *getNUWAdd(Constant *C1, Constant *C2) {
-    return getAdd(C1, C2, true, false);
-  }
-  static Constant *getNSWSub(Constant *C1, Constant *C2) {
-    return getSub(C1, C2, false, true);
-  }
-  static Constant *getNUWSub(Constant *C1, Constant *C2) {
-    return getSub(C1, C2, true, false);
-  }
-  static Constant *getNSWMul(Constant *C1, Constant *C2) {
-    return getMul(C1, C2, false, true);
-  }
-  static Constant *getNUWMul(Constant *C1, Constant *C2) {
-    return getMul(C1, C2, true, false);
-  }
-  static Constant *getNSWShl(Constant *C1, Constant *C2) {
-    return getShl(C1, C2, false, true);
-  }
-  static Constant *getNUWShl(Constant *C1, Constant *C2) {
-    return getShl(C1, C2, true, false);
-  }
-  static Constant *getExactSDiv(Constant *C1, Constant *C2) {
-    return getSDiv(C1, C2, true);
-  }
-  static Constant *getExactUDiv(Constant *C1, Constant *C2) {
-    return getUDiv(C1, C2, true);
-  }
-  static Constant *getExactAShr(Constant *C1, Constant *C2) {
-    return getAShr(C1, C2, true);
-  }
-  static Constant *getExactLShr(Constant *C1, Constant *C2) {
-    return getLShr(C1, C2, true);
-  }
-
-  /// getBinOpIdentity - Return the identity for the given binary operation,
-  /// i.e. a constant C such that X op C = X and C op X = X for every X.  It
-  /// returns null if the operator doesn't have an identity.
-  static Constant *getBinOpIdentity(unsigned Opcode, Type *Ty);
-
-  /// getBinOpAbsorber - Return the absorbing element for the given binary
-  /// operation, i.e. a constant C such that X op C = C and C op X = C for
-  /// every X.  For example, this returns zero for integer multiplication.
-  /// It returns null if the operator doesn't have an absorbing element.
-  static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty);
-
-  /// Transparently provide more efficient getOperand methods.
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
-
-  // @brief Convenience function for getting one of the casting operations
-  // using a CastOps opcode.
-  static Constant *getCast(
-    unsigned ops,  ///< The opcode for the conversion
-    Constant *C,   ///< The constant to be converted
-    Type *Ty ///< The type to which the constant is converted
-  );
-
-  // @brief Create a ZExt or BitCast cast constant expression
-  static Constant *getZExtOrBitCast(
-    Constant *C,   ///< The constant to zext or bitcast
-    Type *Ty ///< The type to zext or bitcast C to
-  );
-
-  // @brief Create a SExt or BitCast cast constant expression
-  static Constant *getSExtOrBitCast(
-    Constant *C,   ///< The constant to sext or bitcast
-    Type *Ty ///< The type to sext or bitcast C to
-  );
-
-  // @brief Create a Trunc or BitCast cast constant expression
-  static Constant *getTruncOrBitCast(
-    Constant *C,   ///< The constant to trunc or bitcast
-    Type *Ty ///< The type to trunc or bitcast C to
-  );
-
-  /// @brief Create a BitCast or a PtrToInt cast constant expression
-  static Constant *getPointerCast(
-    Constant *C,   ///< The pointer value to be casted (operand 0)
-    Type *Ty ///< The type to which cast should be made
-  );
-
-  /// @brief Create a ZExt, Bitcast or Trunc for integer -> integer casts
-  static Constant *getIntegerCast(
-    Constant *C,    ///< The integer constant to be casted
-    Type *Ty, ///< The integer type to cast to
-    bool isSigned   ///< Whether C should be treated as signed or not
-  );
-
-  /// @brief Create a FPExt, Bitcast or FPTrunc for fp -> fp casts
-  static Constant *getFPCast(
-    Constant *C,    ///< The integer constant to be casted
-    Type *Ty ///< The integer type to cast to
-  );
-
-  /// @brief Return true if this is a convert constant expression
-  bool isCast() const;
-
-  /// @brief Return true if this is a compare constant expression
-  bool isCompare() const;
-
-  /// @brief Return true if this is an insertvalue or extractvalue expression,
-  /// and the getIndices() method may be used.
-  bool hasIndices() const;
-
-  /// @brief Return true if this is a getelementptr expression and all
-  /// the index operands are compile-time known integers within the
-  /// corresponding notional static array extents. Note that this is
-  /// not equivalant to, a subset of, or a superset of the "inbounds"
-  /// property.
-  bool isGEPWithNoNotionalOverIndexing() const;
-
-  /// Select constant expr
-  ///
-  static Constant *getSelect(Constant *C, Constant *V1, Constant *V2);
-
-  /// get - Return a binary or shift operator constant expression,
-  /// folding if possible.
-  ///
-  static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
-                       unsigned Flags = 0);
-
-  /// @brief Return an ICmp or FCmp comparison operator constant expression.
-  static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2);
-
-  /// get* - Return some common constants without having to
-  /// specify the full Instruction::OPCODE identifier.
-  ///
-  static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS);
-  static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS);
-
-  /// Getelementptr form.  Value* is only accepted for convenience;
-  /// all elements must be Constant's.
-  ///
-  static Constant *getGetElementPtr(Constant *C,
-                                    ArrayRef<Constant *> IdxList,
-                                    bool InBounds = false) {
-    return getGetElementPtr(C, makeArrayRef((Value * const *)IdxList.data(),
-                                            IdxList.size()),
-                            InBounds);
-  }
-  static Constant *getGetElementPtr(Constant *C,
-                                    Constant *Idx,
-                                    bool InBounds = false) {
-    // This form of the function only exists to avoid ambiguous overload
-    // warnings about whether to convert Idx to ArrayRef<Constant *> or
-    // ArrayRef<Value *>.
-    return getGetElementPtr(C, cast<Value>(Idx), InBounds);
-  }
-  static Constant *getGetElementPtr(Constant *C,
-                                    ArrayRef<Value *> IdxList,
-                                    bool InBounds = false);
-
-  /// Create an "inbounds" getelementptr. See the documentation for the
-  /// "inbounds" flag in LangRef.html for details.
-  static Constant *getInBoundsGetElementPtr(Constant *C,
-                                            ArrayRef<Constant *> IdxList) {
-    return getGetElementPtr(C, IdxList, true);
-  }
-  static Constant *getInBoundsGetElementPtr(Constant *C,
-                                            Constant *Idx) {
-    // This form of the function only exists to avoid ambiguous overload
-    // warnings about whether to convert Idx to ArrayRef<Constant *> or
-    // ArrayRef<Value *>.
-    return getGetElementPtr(C, Idx, true);
-  }
-  static Constant *getInBoundsGetElementPtr(Constant *C,
-                                            ArrayRef<Value *> IdxList) {
-    return getGetElementPtr(C, IdxList, true);
-  }
-
-  static Constant *getExtractElement(Constant *Vec, Constant *Idx);
-  static Constant *getInsertElement(Constant *Vec, Constant *Elt,Constant *Idx);
-  static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask);
-  static Constant *getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs);
-  static Constant *getInsertValue(Constant *Agg, Constant *Val,
-                                  ArrayRef<unsigned> Idxs);
-
-  /// getOpcode - Return the opcode at the root of this constant expression
-  unsigned getOpcode() const { return getSubclassDataFromValue(); }
-
-  /// getPredicate - Return the ICMP or FCMP predicate value. Assert if this is
-  /// not an ICMP or FCMP constant expression.
-  unsigned getPredicate() const;
-
-  /// getIndices - Assert that this is an insertvalue or exactvalue
-  /// expression and return the list of indices.
-  ArrayRef<unsigned> getIndices() const;
-
-  /// getOpcodeName - Return a string representation for an opcode.
-  const char *getOpcodeName() const;
-
-  /// getWithOperandReplaced - Return a constant expression identical to this
-  /// one, but with the specified operand set to the specified value.
-  Constant *getWithOperandReplaced(unsigned OpNo, Constant *Op) const;
-
-  /// getWithOperands - This returns the current constant expression with the
-  /// operands replaced with the specified values.  The specified array must
-  /// have the same number of operands as our current one.
-  Constant *getWithOperands(ArrayRef<Constant*> Ops) const {
-    return getWithOperands(Ops, getType());
-  }
-
-  /// getWithOperands - This returns the current constant expression with the
-  /// operands replaced with the specified values and with the specified result
-  /// type.  The specified array must have the same number of operands as our
-  /// current one.
-  Constant *getWithOperands(ArrayRef<Constant*> Ops, Type *Ty) const;
-
-  /// getAsInstruction - Returns an Instruction which implements the same operation
-  /// as this ConstantExpr. The instruction is not linked to any basic block.
-  ///
-  /// A better approach to this could be to have a constructor for Instruction
-  /// which would take a ConstantExpr parameter, but that would have spread 
-  /// implementation details of ConstantExpr outside of Constants.cpp, which 
-  /// would make it harder to remove ConstantExprs altogether.
-  Instruction *getAsInstruction();
-
-  virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Value *V) {
-    return V->getValueID() == ConstantExprVal;
-  }
-
-private:
-  // Shadow Value::setValueSubclassData with a private forwarding method so that
-  // subclasses cannot accidentally use it.
-  void setValueSubclassData(unsigned short D) {
-    Value::setValueSubclassData(D);
-  }
-};
-
-template <>
-struct OperandTraits<ConstantExpr> :
-  public VariadicOperandTraits<ConstantExpr, 1> {
-};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant)
-
-//===----------------------------------------------------------------------===//
-/// UndefValue - 'undef' values are things that do not have specified contents.
-/// These are used for a variety of purposes, including global variable
-/// initializers and operands to instructions.  'undef' values can occur with
-/// any first-class type.
-///
-/// Undef values aren't exactly constants; if they have multiple uses, they
-/// can appear to have different bit patterns at each use. See
-/// LangRef.html#undefvalues for details.
-///
-class UndefValue : public Constant {
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  UndefValue(const UndefValue &) LLVM_DELETED_FUNCTION;
-protected:
-  explicit UndefValue(Type *T) : Constant(T, UndefValueVal, 0, 0) {}
-protected:
-  // allocate space for exactly zero operands
-  void *operator new(size_t s) {
-    return User::operator new(s, 0);
-  }
-public:
-  /// get() - Static factory methods - Return an 'undef' object of the specified
-  /// type.
-  ///
-  static UndefValue *get(Type *T);
-
-  /// getSequentialElement - If this Undef has array or vector type, return a
-  /// undef with the right element type.
-  UndefValue *getSequentialElement() const;
-
-  /// getStructElement - If this undef has struct type, return a undef with the
-  /// right element type for the specified element.
-  UndefValue *getStructElement(unsigned Elt) const;
-
-  /// getElementValue - Return an undef of the right value for the specified GEP
-  /// index.
-  UndefValue *getElementValue(Constant *C) const;
-
-  /// getElementValue - Return an undef of the right value for the specified GEP
-  /// index.
-  UndefValue *getElementValue(unsigned Idx) const;
-
-  virtual void destroyConstant();
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static bool classof(const Value *V) {
-    return V->getValueID() == UndefValueVal;
-  }
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/DataLayout.h b/include/llvm/DataLayout.h
deleted file mode 100644 (file)
index cc02017..0000000
+++ /dev/null
@@ -1,427 +0,0 @@
-//===--------- llvm/DataLayout.h - Data size & alignment info ---*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines layout properties related to datatype size/offset/alignment
-// information.  It uses lazy annotations to cache information about how
-// structure types are laid out and used.
-//
-// This structure should be created once, filled in if the defaults are not
-// correct and then passed around by const&.  None of the members functions
-// require modification to the object.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DATALAYOUT_H
-#define LLVM_DATALAYOUT_H
-
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/DataTypes.h"
-
-namespace llvm {
-
-class Value;
-class Type;
-class IntegerType;
-class StructType;
-class StructLayout;
-class GlobalVariable;
-class LLVMContext;
-template<typename T>
-class ArrayRef;
-
-/// Enum used to categorize the alignment types stored by LayoutAlignElem
-enum AlignTypeEnum {
-  INVALID_ALIGN = 0,                 ///< An invalid alignment
-  INTEGER_ALIGN = 'i',               ///< Integer type alignment
-  VECTOR_ALIGN = 'v',                ///< Vector type alignment
-  FLOAT_ALIGN = 'f',                 ///< Floating point type alignment
-  AGGREGATE_ALIGN = 'a',             ///< Aggregate alignment
-  STACK_ALIGN = 's'                  ///< Stack objects alignment
-};
-
-/// Layout alignment element.
-///
-/// Stores the alignment data associated with a given alignment type (integer,
-/// vector, float) and type bit width.
-///
-/// @note The unusual order of elements in the structure attempts to reduce
-/// padding and make the structure slightly more cache friendly.
-struct LayoutAlignElem {
-  unsigned AlignType    : 8;  ///< Alignment type (AlignTypeEnum)
-  unsigned TypeBitWidth : 24; ///< Type bit width
-  unsigned ABIAlign     : 16; ///< ABI alignment for this type/bitw
-  unsigned PrefAlign    : 16; ///< Pref. alignment for this type/bitw
-
-  /// Initializer
-  static LayoutAlignElem get(AlignTypeEnum align_type, unsigned abi_align,
-                             unsigned pref_align, uint32_t bit_width);
-  /// Equality predicate
-  bool operator==(const LayoutAlignElem &rhs) const;
-};
-
-/// Layout pointer alignment element.
-///
-/// Stores the alignment data associated with a given pointer and address space.
-///
-/// @note The unusual order of elements in the structure attempts to reduce
-/// padding and make the structure slightly more cache friendly.
-struct PointerAlignElem {
-  unsigned            ABIAlign;       ///< ABI alignment for this type/bitw
-  unsigned            PrefAlign;      ///< Pref. alignment for this type/bitw
-  uint32_t            TypeBitWidth;   ///< Type bit width
-  uint32_t            AddressSpace;   ///< Address space for the pointer type
-
-  /// Initializer
-  static PointerAlignElem get(uint32_t addr_space, unsigned abi_align,
-                             unsigned pref_align, uint32_t bit_width);
-  /// Equality predicate
-  bool operator==(const PointerAlignElem &rhs) const;
-};
-
-
-/// DataLayout - This class holds a parsed version of the target data layout
-/// string in a module and provides methods for querying it.  The target data
-/// layout string is specified *by the target* - a frontend generating LLVM IR
-/// is required to generate the right target data for the target being codegen'd
-/// to.  If some measure of portability is desired, an empty string may be
-/// specified in the module.
-class DataLayout : public ImmutablePass {
-private:
-  bool          LittleEndian;          ///< Defaults to false
-  unsigned      StackNaturalAlign;     ///< Stack natural alignment
-
-  SmallVector<unsigned char, 8> LegalIntWidths; ///< Legal Integers.
-
-  /// Alignments- Where the primitive type alignment data is stored.
-  ///
-  /// @sa init().
-  /// @note Could support multiple size pointer alignments, e.g., 32-bit
-  /// pointers vs. 64-bit pointers by extending LayoutAlignment, but for now,
-  /// we don't.
-  SmallVector<LayoutAlignElem, 16> Alignments;
-  DenseMap<unsigned, PointerAlignElem> Pointers;
-
-  /// InvalidAlignmentElem - This member is a signal that a requested alignment
-  /// type and bit width were not found in the SmallVector.
-  static const LayoutAlignElem InvalidAlignmentElem;
-
-  /// InvalidPointerElem - This member is a signal that a requested pointer
-  /// type and bit width were not found in the DenseSet.
-  static const PointerAlignElem InvalidPointerElem;
-
-  // The StructType -> StructLayout map.
-  mutable void *LayoutMap;
-
-  //! Set/initialize target alignments
-  void setAlignment(AlignTypeEnum align_type, unsigned abi_align,
-                    unsigned pref_align, uint32_t bit_width);
-  unsigned getAlignmentInfo(AlignTypeEnum align_type, uint32_t bit_width,
-                            bool ABIAlign, Type *Ty) const;
-
-  //! Set/initialize pointer alignments
-  void setPointerAlignment(uint32_t addr_space, unsigned abi_align,
-      unsigned pref_align, uint32_t bit_width);
-
-  //! Internal helper method that returns requested alignment for type.
-  unsigned getAlignment(Type *Ty, bool abi_or_pref) const;
-
-  /// Valid alignment predicate.
-  ///
-  /// Predicate that tests a LayoutAlignElem reference returned by get() against
-  /// InvalidAlignmentElem.
-  bool validAlignment(const LayoutAlignElem &align) const {
-    return &align != &InvalidAlignmentElem;
-  }
-
-  /// Valid pointer predicate.
-  ///
-  /// Predicate that tests a PointerAlignElem reference returned by get() against
-  /// InvalidPointerElem.
-  bool validPointer(const PointerAlignElem &align) const {
-    return &align != &InvalidPointerElem;
-  }
-
-  /// Parses a target data specification string. Assert if the string is
-  /// malformed.
-  void parseSpecifier(StringRef LayoutDescription);
-
-public:
-  /// Default ctor.
-  ///
-  /// @note This has to exist, because this is a pass, but it should never be
-  /// used.
-  DataLayout();
-
-  /// Constructs a DataLayout from a specification string. See init().
-  explicit DataLayout(StringRef LayoutDescription)
-    : ImmutablePass(ID) {
-    init(LayoutDescription);
-  }
-
-  /// Initialize target data from properties stored in the module.
-  explicit DataLayout(const Module *M);
-
-  DataLayout(const DataLayout &TD) :
-    ImmutablePass(ID),
-    LittleEndian(TD.isLittleEndian()),
-    LegalIntWidths(TD.LegalIntWidths),
-    Alignments(TD.Alignments),
-    Pointers(TD.Pointers),
-    LayoutMap(0)
-  { }
-
-  ~DataLayout();  // Not virtual, do not subclass this class
-
-  /// Parse a data layout string (with fallback to default values). Ensure that
-  /// the data layout pass is registered.
-  void init(StringRef LayoutDescription);
-
-  /// Layout endianness...
-  bool isLittleEndian() const { return LittleEndian; }
-  bool isBigEndian() const { return !LittleEndian; }
-
-  /// getStringRepresentation - Return the string representation of the
-  /// DataLayout.  This representation is in the same format accepted by the
-  /// string constructor above.
-  std::string getStringRepresentation() const;
-
-  /// isLegalInteger - This function returns true if the specified type is
-  /// known to be a native integer type supported by the CPU.  For example,
-  /// i64 is not native on most 32-bit CPUs and i37 is not native on any known
-  /// one.  This returns false if the integer width is not legal.
-  ///
-  /// The width is specified in bits.
-  ///
-  bool isLegalInteger(unsigned Width) const {
-    for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
-      if (LegalIntWidths[i] == Width)
-        return true;
-    return false;
-  }
-
-  bool isIllegalInteger(unsigned Width) const {
-    return !isLegalInteger(Width);
-  }
-
-  /// Returns true if the given alignment exceeds the natural stack alignment.
-  bool exceedsNaturalStackAlignment(unsigned Align) const {
-    return (StackNaturalAlign != 0) && (Align > StackNaturalAlign);
-  }
-
-  /// fitsInLegalInteger - This function returns true if the specified type fits
-  /// in a native integer type supported by the CPU.  For example, if the CPU
-  /// only supports i32 as a native integer type, then i27 fits in a legal
-  // integer type but i45 does not.
-  bool fitsInLegalInteger(unsigned Width) const {
-    for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
-      if (Width <= LegalIntWidths[i])
-        return true;
-    return false;
-  }
-
-  /// Layout pointer alignment
-  /// FIXME: The defaults need to be removed once all of
-  /// the backends/clients are updated.
-  unsigned getPointerABIAlignment(unsigned AS = 0)  const {
-    DenseMap<unsigned, PointerAlignElem>::const_iterator val = Pointers.find(AS);
-    if (val == Pointers.end()) {
-      val = Pointers.find(0);
-    }
-    return val->second.ABIAlign;
-  }
-  /// Return target's alignment for stack-based pointers
-  /// FIXME: The defaults need to be removed once all of
-  /// the backends/clients are updated.
-  unsigned getPointerPrefAlignment(unsigned AS = 0) const {
-    DenseMap<unsigned, PointerAlignElem>::const_iterator val = Pointers.find(AS);
-    if (val == Pointers.end()) {
-      val = Pointers.find(0);
-    }
-    return val->second.PrefAlign;
-  }
-  /// Layout pointer size
-  /// FIXME: The defaults need to be removed once all of
-  /// the backends/clients are updated.
-  unsigned getPointerSize(unsigned AS = 0)          const {
-    DenseMap<unsigned, PointerAlignElem>::const_iterator val = Pointers.find(AS);
-    if (val == Pointers.end()) {
-      val = Pointers.find(0);
-    }
-    return val->second.TypeBitWidth;
-  }
-  /// Layout pointer size, in bits
-  /// FIXME: The defaults need to be removed once all of
-  /// the backends/clients are updated.
-  unsigned getPointerSizeInBits(unsigned AS = 0)    const {
-    return getPointerSize(AS) * 8;
-  }
-  /// Size examples:
-  ///
-  /// Type        SizeInBits  StoreSizeInBits  AllocSizeInBits[*]
-  /// ----        ----------  ---------------  ---------------
-  ///  i1            1           8                8
-  ///  i8            8           8                8
-  ///  i19          19          24               32
-  ///  i32          32          32               32
-  ///  i100        100         104              128
-  ///  i128        128         128              128
-  ///  Float        32          32               32
-  ///  Double       64          64               64
-  ///  X86_FP80     80          80               96
-  ///
-  /// [*] The alloc size depends on the alignment, and thus on the target.
-  ///     These values are for x86-32 linux.
-
-  /// getTypeSizeInBits - Return the number of bits necessary to hold the
-  /// specified type.  For example, returns 36 for i36 and 80 for x86_fp80.
-  /// The type passed must have a size (Type::isSized() must return true).
-  uint64_t getTypeSizeInBits(Type* Ty) const;
-
-  /// getTypeStoreSize - Return the maximum number of bytes that may be
-  /// overwritten by storing the specified type.  For example, returns 5
-  /// for i36 and 10 for x86_fp80.
-  uint64_t getTypeStoreSize(Type *Ty) const {
-    return (getTypeSizeInBits(Ty)+7)/8;
-  }
-
-  /// getTypeStoreSizeInBits - Return the maximum number of bits that may be
-  /// overwritten by storing the specified type; always a multiple of 8.  For
-  /// example, returns 40 for i36 and 80 for x86_fp80.
-  uint64_t getTypeStoreSizeInBits(Type *Ty) const {
-    return 8*getTypeStoreSize(Ty);
-  }
-
-  /// getTypeAllocSize - Return the offset in bytes between successive objects
-  /// of the specified type, including alignment padding.  This is the amount
-  /// that alloca reserves for this type.  For example, returns 12 or 16 for
-  /// x86_fp80, depending on alignment.
-  uint64_t getTypeAllocSize(Type* Ty) const {
-    // Round up to the next alignment boundary.
-    return RoundUpAlignment(getTypeStoreSize(Ty), getABITypeAlignment(Ty));
-  }
-
-  /// getTypeAllocSizeInBits - Return the offset in bits between successive
-  /// objects of the specified type, including alignment padding; always a
-  /// multiple of 8.  This is the amount that alloca reserves for this type.
-  /// For example, returns 96 or 128 for x86_fp80, depending on alignment.
-  uint64_t getTypeAllocSizeInBits(Type* Ty) const {
-    return 8*getTypeAllocSize(Ty);
-  }
-
-  /// getABITypeAlignment - Return the minimum ABI-required alignment for the
-  /// specified type.
-  unsigned getABITypeAlignment(Type *Ty) const;
-
-  /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
-  /// an integer type of the specified bitwidth.
-  unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const;
-
-
-  /// getCallFrameTypeAlignment - Return the minimum ABI-required alignment
-  /// for the specified type when it is part of a call frame.
-  unsigned getCallFrameTypeAlignment(Type *Ty) const;
-
-
-  /// getPrefTypeAlignment - Return the preferred stack/global alignment for
-  /// the specified type.  This is always at least as good as the ABI alignment.
-  unsigned getPrefTypeAlignment(Type *Ty) const;
-
-  /// getPreferredTypeAlignmentShift - Return the preferred alignment for the
-  /// specified type, returned as log2 of the value (a shift amount).
-  ///
-  unsigned getPreferredTypeAlignmentShift(Type *Ty) const;
-
-  /// getIntPtrType - Return an integer type with size at least as big as that
-  /// of a pointer in the given address space.
-  IntegerType *getIntPtrType(LLVMContext &C, unsigned AddressSpace = 0) const;
-
-  /// getIntPtrType - Return an integer (vector of integer) type with size at
-  /// least as big as that of a pointer of the given pointer (vector of pointer)
-  /// type.
-  Type *getIntPtrType(Type *) const;
-
-  /// getIndexedOffset - return the offset from the beginning of the type for
-  /// the specified indices.  This is used to implement getelementptr.
-  ///
-  uint64_t getIndexedOffset(Type *Ty, ArrayRef<Value *> Indices) const;
-
-  /// getStructLayout - Return a StructLayout object, indicating the alignment
-  /// of the struct, its size, and the offsets of its fields.  Note that this
-  /// information is lazily cached.
-  const StructLayout *getStructLayout(StructType *Ty) const;
-
-  /// getPreferredAlignment - Return the preferred alignment of the specified
-  /// global.  This includes an explicitly requested alignment (if the global
-  /// has one).
-  unsigned getPreferredAlignment(const GlobalVariable *GV) const;
-
-  /// getPreferredAlignmentLog - Return the preferred alignment of the
-  /// specified global, returned in log form.  This includes an explicitly
-  /// requested alignment (if the global has one).
-  unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const;
-
-  /// RoundUpAlignment - Round the specified value up to the next alignment
-  /// boundary specified by Alignment.  For example, 7 rounded up to an
-  /// alignment boundary of 4 is 8.  8 rounded up to the alignment boundary of 4
-  /// is 8 because it is already aligned.
-  template <typename UIntTy>
-  static UIntTy RoundUpAlignment(UIntTy Val, unsigned Alignment) {
-    assert((Alignment & (Alignment-1)) == 0 && "Alignment must be power of 2!");
-    return (Val + (Alignment-1)) & ~UIntTy(Alignment-1);
-  }
-
-  static char ID; // Pass identification, replacement for typeid
-};
-
-/// StructLayout - used to lazily calculate structure layout information for a
-/// target machine, based on the DataLayout structure.
-///
-class StructLayout {
-  uint64_t StructSize;
-  unsigned StructAlignment;
-  unsigned NumElements;
-  uint64_t MemberOffsets[1];  // variable sized array!
-public:
-
-  uint64_t getSizeInBytes() const {
-    return StructSize;
-  }
-
-  uint64_t getSizeInBits() const {
-    return 8*StructSize;
-  }
-
-  unsigned getAlignment() const {
-    return StructAlignment;
-  }
-
-  /// getElementContainingOffset - Given a valid byte offset into the structure,
-  /// return the structure index that contains it.
-  ///
-  unsigned getElementContainingOffset(uint64_t Offset) const;
-
-  uint64_t getElementOffset(unsigned Idx) const {
-    assert(Idx < NumElements && "Invalid element idx!");
-    return MemberOffsets[Idx];
-  }
-
-  uint64_t getElementOffsetInBits(unsigned Idx) const {
-    return getElementOffset(Idx)*8;
-  }
-
-private:
-  friend class DataLayout;   // Only DataLayout can create this class
-  StructLayout(StructType *ST, const DataLayout &TD);
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
deleted file mode 100644 (file)
index 6068b8c..0000000
+++ /dev/null
@@ -1,455 +0,0 @@
-//===-- llvm/DerivedTypes.h - Classes for handling data types ---*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the declarations of classes that represent "derived
-// types".  These are things like "arrays of x" or "structure of x, y, z" or
-// "function returning x taking (y,z) as parameters", etc...
-//
-// The implementations of these classes live in the Type.cpp file.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DERIVED_TYPES_H
-#define LLVM_DERIVED_TYPES_H
-
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Type.h"
-
-namespace llvm {
-
-class Value;
-class APInt;
-class LLVMContext;
-template<typename T> class ArrayRef;
-class StringRef;
-
-/// Class to represent integer types. Note that this class is also used to
-/// represent the built-in integer types: Int1Ty, Int8Ty, Int16Ty, Int32Ty and
-/// Int64Ty.
-/// @brief Integer representation type
-class IntegerType : public Type {
-  friend class LLVMContextImpl;
-  
-protected:
-  explicit IntegerType(LLVMContext &C, unsigned NumBits) : Type(C, IntegerTyID){
-    setSubclassData(NumBits);
-  }
-public:
-  /// This enum is just used to hold constants we need for IntegerType.
-  enum {
-    MIN_INT_BITS = 1,        ///< Minimum number of bits that can be specified
-    MAX_INT_BITS = (1<<23)-1 ///< Maximum number of bits that can be specified
-      ///< Note that bit width is stored in the Type classes SubclassData field
-      ///< which has 23 bits. This yields a maximum bit width of 8,388,607 bits.
-  };
-
-  /// This static method is the primary way of constructing an IntegerType.
-  /// If an IntegerType with the same NumBits value was previously instantiated,
-  /// that instance will be returned. Otherwise a new one will be created. Only
-  /// one instance with a given NumBits value is ever created.
-  /// @brief Get or create an IntegerType instance.
-  static IntegerType *get(LLVMContext &C, unsigned NumBits);
-
-  /// @brief Get the number of bits in this IntegerType
-  unsigned getBitWidth() const { return getSubclassData(); }
-
-  /// getBitMask - Return a bitmask with ones set for all of the bits
-  /// that can be set by an unsigned version of this type.  This is 0xFF for
-  /// i8, 0xFFFF for i16, etc.
-  uint64_t getBitMask() const {
-    return ~uint64_t(0UL) >> (64-getBitWidth());
-  }
-
-  /// getSignBit - Return a uint64_t with just the most significant bit set (the
-  /// sign bit, if the value is treated as a signed number).
-  uint64_t getSignBit() const {
-    return 1ULL << (getBitWidth()-1);
-  }
-
-  /// For example, this is 0xFF for an 8 bit integer, 0xFFFF for i16, etc.
-  /// @returns a bit mask with ones set for all the bits of this type.
-  /// @brief Get a bit mask for this type.
-  APInt getMask() const;
-
-  /// This method determines if the width of this IntegerType is a power-of-2
-  /// in terms of 8 bit bytes.
-  /// @returns true if this is a power-of-2 byte width.
-  /// @brief Is this a power-of-2 byte-width IntegerType ?
-  bool isPowerOf2ByteWidth() const;
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const Type *T) {
-    return T->getTypeID() == IntegerTyID;
-  }
-};
-
-
-/// FunctionType - Class to represent function types
-///
-class FunctionType : public Type {
-  FunctionType(const FunctionType &) LLVM_DELETED_FUNCTION;
-  const FunctionType &operator=(const FunctionType &) LLVM_DELETED_FUNCTION;
-  FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs);
-
-public:
-  /// FunctionType::get - This static method is the primary way of constructing
-  /// a FunctionType.
-  ///
-  static FunctionType *get(Type *Result,
-                           ArrayRef<Type*> Params, bool isVarArg);
-
-  /// FunctionType::get - Create a FunctionType taking no parameters.
-  ///
-  static FunctionType *get(Type *Result, bool isVarArg);
-  
-  /// isValidReturnType - Return true if the specified type is valid as a return
-  /// type.
-  static bool isValidReturnType(Type *RetTy);
-
-  /// isValidArgumentType - Return true if the specified type is valid as an
-  /// argument type.
-  static bool isValidArgumentType(Type *ArgTy);
-
-  bool isVarArg() const { return getSubclassData(); }
-  Type *getReturnType() const { return ContainedTys[0]; }
-
-  typedef Type::subtype_iterator param_iterator;
-  param_iterator param_begin() const { return ContainedTys + 1; }
-  param_iterator param_end() const { return &ContainedTys[NumContainedTys]; }
-
-  // Parameter type accessors.
-  Type *getParamType(unsigned i) const { return ContainedTys[i+1]; }
-
-  /// getNumParams - Return the number of fixed parameters this function type
-  /// requires.  This does not consider varargs.
-  ///
-  unsigned getNumParams() const { return NumContainedTys - 1; }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const Type *T) {
-    return T->getTypeID() == FunctionTyID;
-  }
-};
-
-
-/// CompositeType - Common super class of ArrayType, StructType, PointerType
-/// and VectorType.
-class CompositeType : public Type {
-protected:
-  explicit CompositeType(LLVMContext &C, TypeID tid) : Type(C, tid) { }
-public:
-
-  /// getTypeAtIndex - Given an index value into the type, return the type of
-  /// the element.
-  ///
-  Type *getTypeAtIndex(const Value *V);
-  Type *getTypeAtIndex(unsigned Idx);
-  bool indexValid(const Value *V) const;
-  bool indexValid(unsigned Idx) const;
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const Type *T) {
-    return T->getTypeID() == ArrayTyID ||
-           T->getTypeID() == StructTyID ||
-           T->getTypeID() == PointerTyID ||
-           T->getTypeID() == VectorTyID;
-  }
-};
-
-
-/// StructType - Class to represent struct types.  There are two different kinds
-/// of struct types: Literal structs and Identified structs.
-///
-/// Literal struct types (e.g. { i32, i32 }) are uniqued structurally, and must
-/// always have a body when created.  You can get one of these by using one of
-/// the StructType::get() forms.
-///  
-/// Identified structs (e.g. %foo or %42) may optionally have a name and are not
-/// uniqued.  The names for identified structs are managed at the LLVMContext
-/// level, so there can only be a single identified struct with a given name in
-/// a particular LLVMContext.  Identified structs may also optionally be opaque
-/// (have no body specified).  You get one of these by using one of the
-/// StructType::create() forms.
-///
-/// Independent of what kind of struct you have, the body of a struct type are
-/// laid out in memory consequtively with the elements directly one after the
-/// other (if the struct is packed) or (if not packed) with padding between the
-/// elements as defined by DataLayout (which is required to match what the code
-/// generator for a target expects).
-///
-class StructType : public CompositeType {
-  StructType(const StructType &) LLVM_DELETED_FUNCTION;
-  const StructType &operator=(const StructType &) LLVM_DELETED_FUNCTION;
-  StructType(LLVMContext &C)
-    : CompositeType(C, StructTyID), SymbolTableEntry(0) {}
-  enum {
-    // This is the contents of the SubClassData field.
-    SCDB_HasBody = 1,
-    SCDB_Packed = 2,
-    SCDB_IsLiteral = 4,
-    SCDB_IsSized = 8
-  };
-
-  /// SymbolTableEntry - For a named struct that actually has a name, this is a
-  /// pointer to the symbol table entry (maintained by LLVMContext) for the
-  /// struct.  This is null if the type is an literal struct or if it is
-  /// a identified type that has an empty name.
-  /// 
-  void *SymbolTableEntry;
-public:
-  ~StructType() {
-    delete [] ContainedTys; // Delete the body.
-  }
-
-  /// StructType::create - This creates an identified struct.
-  static StructType *create(LLVMContext &Context, StringRef Name);
-  static StructType *create(LLVMContext &Context);
-  
-  static StructType *create(ArrayRef<Type*> Elements,
-                            StringRef Name,
-                            bool isPacked = false);
-  static StructType *create(ArrayRef<Type*> Elements);
-  static StructType *create(LLVMContext &Context,
-                            ArrayRef<Type*> Elements,
-                            StringRef Name,
-                            bool isPacked = false);
-  static StructType *create(LLVMContext &Context, ArrayRef<Type*> Elements);
-  static StructType *create(StringRef Name, Type *elt1, ...) END_WITH_NULL;
-
-  /// StructType::get - This static method is the primary way to create a
-  /// literal StructType.
-  static StructType *get(LLVMContext &Context, ArrayRef<Type*> Elements,
-                         bool isPacked = false);
-
-  /// StructType::get - Create an empty structure type.
-  ///
-  static StructType *get(LLVMContext &Context, bool isPacked = false);
-  
-  /// StructType::get - This static method is a convenience method for creating
-  /// structure types by specifying the elements as arguments.  Note that this
-  /// method always returns a non-packed struct, and requires at least one
-  /// element type.
-  static StructType *get(Type *elt1, ...) END_WITH_NULL;
-
-  bool isPacked() const { return (getSubclassData() & SCDB_Packed) != 0; }
-  
-  /// isLiteral - Return true if this type is uniqued by structural
-  /// equivalence, false if it is a struct definition.
-  bool isLiteral() const { return (getSubclassData() & SCDB_IsLiteral) != 0; }
-  
-  /// isOpaque - Return true if this is a type with an identity that has no body
-  /// specified yet.  These prints as 'opaque' in .ll files.
-  bool isOpaque() const { return (getSubclassData() & SCDB_HasBody) == 0; }
-
-  /// isSized - Return true if this is a sized type.
-  bool isSized() const;
-  
-  /// hasName - Return true if this is a named struct that has a non-empty name.
-  bool hasName() const { return SymbolTableEntry != 0; }
-  
-  /// getName - Return the name for this struct type if it has an identity.
-  /// This may return an empty string for an unnamed struct type.  Do not call
-  /// this on an literal type.
-  StringRef getName() const;
-  
-  /// setName - Change the name of this type to the specified name, or to a name
-  /// with a suffix if there is a collision.  Do not call this on an literal
-  /// type.
-  void setName(StringRef Name);
-
-  /// setBody - Specify a body for an opaque identified type.
-  void setBody(ArrayRef<Type*> Elements, bool isPacked = false);
-  void setBody(Type *elt1, ...) END_WITH_NULL;
-  
-  /// isValidElementType - Return true if the specified type is valid as a
-  /// element type.
-  static bool isValidElementType(Type *ElemTy);
-  
-
-  // Iterator access to the elements.
-  typedef Type::subtype_iterator element_iterator;
-  element_iterator element_begin() const { return ContainedTys; }
-  element_iterator element_end() const { return &ContainedTys[NumContainedTys];}
-
-  /// isLayoutIdentical - Return true if this is layout identical to the
-  /// specified struct.
-  bool isLayoutIdentical(StructType *Other) const;  
-  
-  // Random access to the elements
-  unsigned getNumElements() const { return NumContainedTys; }
-  Type *getElementType(unsigned N) const {
-    assert(N < NumContainedTys && "Element number out of range!");
-    return ContainedTys[N];
-  }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const Type *T) {
-    return T->getTypeID() == StructTyID;
-  }
-};
-
-/// SequentialType - This is the superclass of the array, pointer and vector
-/// type classes.  All of these represent "arrays" in memory.  The array type
-/// represents a specifically sized array, pointer types are unsized/unknown
-/// size arrays, vector types represent specifically sized arrays that
-/// allow for use of SIMD instructions.  SequentialType holds the common
-/// features of all, which stem from the fact that all three lay their
-/// components out in memory identically.
-///
-class SequentialType : public CompositeType {
-  Type *ContainedType;               ///< Storage for the single contained type.
-  SequentialType(const SequentialType &) LLVM_DELETED_FUNCTION;
-  const SequentialType &operator=(const SequentialType &) LLVM_DELETED_FUNCTION;
-
-protected:
-  SequentialType(TypeID TID, Type *ElType)
-    : CompositeType(ElType->getContext(), TID), ContainedType(ElType) {
-    ContainedTys = &ContainedType;
-    NumContainedTys = 1;
-  }
-
-public:
-  Type *getElementType() const { return ContainedTys[0]; }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const Type *T) {
-    return T->getTypeID() == ArrayTyID ||
-           T->getTypeID() == PointerTyID ||
-           T->getTypeID() == VectorTyID;
-  }
-};
-
-
-/// ArrayType - Class to represent array types.
-///
-class ArrayType : public SequentialType {
-  uint64_t NumElements;
-
-  ArrayType(const ArrayType &) LLVM_DELETED_FUNCTION;
-  const ArrayType &operator=(const ArrayType &) LLVM_DELETED_FUNCTION;
-  ArrayType(Type *ElType, uint64_t NumEl);
-public:
-  /// ArrayType::get - This static method is the primary way to construct an
-  /// ArrayType
-  ///
-  static ArrayType *get(Type *ElementType, uint64_t NumElements);
-
-  /// isValidElementType - Return true if the specified type is valid as a
-  /// element type.
-  static bool isValidElementType(Type *ElemTy);
-
-  uint64_t getNumElements() const { return NumElements; }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const Type *T) {
-    return T->getTypeID() == ArrayTyID;
-  }
-};
-
-/// VectorType - Class to represent vector types.
-///
-class VectorType : public SequentialType {
-  unsigned NumElements;
-
-  VectorType(const VectorType &) LLVM_DELETED_FUNCTION;
-  const VectorType &operator=(const VectorType &) LLVM_DELETED_FUNCTION;
-  VectorType(Type *ElType, unsigned NumEl);
-public:
-  /// VectorType::get - This static method is the primary way to construct an
-  /// VectorType.
-  ///
-  static VectorType *get(Type *ElementType, unsigned NumElements);
-
-  /// VectorType::getInteger - This static method gets a VectorType with the
-  /// same number of elements as the input type, and the element type is an
-  /// integer type of the same width as the input element type.
-  ///
-  static VectorType *getInteger(VectorType *VTy) {
-    unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
-    assert(EltBits && "Element size must be of a non-zero size");
-    Type *EltTy = IntegerType::get(VTy->getContext(), EltBits);
-    return VectorType::get(EltTy, VTy->getNumElements());
-  }
-
-  /// VectorType::getExtendedElementVectorType - This static method is like
-  /// getInteger except that the element types are twice as wide as the
-  /// elements in the input type.
-  ///
-  static VectorType *getExtendedElementVectorType(VectorType *VTy) {
-    unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
-    Type *EltTy = IntegerType::get(VTy->getContext(), EltBits * 2);
-    return VectorType::get(EltTy, VTy->getNumElements());
-  }
-
-  /// VectorType::getTruncatedElementVectorType - This static method is like
-  /// getInteger except that the element types are half as wide as the
-  /// elements in the input type.
-  ///
-  static VectorType *getTruncatedElementVectorType(VectorType *VTy) {
-    unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
-    assert((EltBits & 1) == 0 &&
-           "Cannot truncate vector element with odd bit-width");
-    Type *EltTy = IntegerType::get(VTy->getContext(), EltBits / 2);
-    return VectorType::get(EltTy, VTy->getNumElements());
-  }
-
-  /// isValidElementType - Return true if the specified type is valid as a
-  /// element type.
-  static bool isValidElementType(Type *ElemTy);
-
-  /// @brief Return the number of elements in the Vector type.
-  unsigned getNumElements() const { return NumElements; }
-
-  /// @brief Return the number of bits in the Vector type.
-  /// Returns zero when the vector is a vector of pointers.
-  unsigned getBitWidth() const {
-    return NumElements * getElementType()->getPrimitiveSizeInBits();
-  }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const Type *T) {
-    return T->getTypeID() == VectorTyID;
-  }
-};
-
-
-/// PointerType - Class to represent pointers.
-///
-class PointerType : public SequentialType {
-  PointerType(const PointerType &) LLVM_DELETED_FUNCTION;
-  const PointerType &operator=(const PointerType &) LLVM_DELETED_FUNCTION;
-  explicit PointerType(Type *ElType, unsigned AddrSpace);
-public:
-  /// PointerType::get - This constructs a pointer to an object of the specified
-  /// type in a numbered address space.
-  static PointerType *get(Type *ElementType, unsigned AddressSpace);
-
-  /// PointerType::getUnqual - This constructs a pointer to an object of the
-  /// specified type in the generic address space (address space zero).
-  static PointerType *getUnqual(Type *ElementType) {
-    return PointerType::get(ElementType, 0);
-  }
-
-  /// isValidElementType - Return true if the specified type is valid as a
-  /// element type.
-  static bool isValidElementType(Type *ElemTy);
-
-  /// @brief Return the address space of the Pointer type.
-  inline unsigned getAddressSpace() const { return getSubclassData(); }
-
-  // Implement support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const Type *T) {
-    return T->getTypeID() == PointerTyID;
-  }
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/Function.h b/include/llvm/Function.h
deleted file mode 100644 (file)
index d551cae..0000000
+++ /dev/null
@@ -1,452 +0,0 @@
-//===-- llvm/Function.h - Class to represent a single function --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the declaration of the Function class, which represents a
-// single function/procedure in LLVM.
-//
-// A function basically consists of a list of basic blocks, a list of arguments,
-// and a symbol table.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUNCTION_H
-#define LLVM_FUNCTION_H
-
-#include "llvm/Argument.h"
-#include "llvm/Attributes.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/CallingConv.h"
-#include "llvm/GlobalValue.h"
-#include "llvm/Support/Compiler.h"
-
-namespace llvm {
-
-class FunctionType;
-class LLVMContext;
-
-// Traits for intrusive list of basic blocks...
-template<> struct ilist_traits<BasicBlock>
-  : public SymbolTableListTraits<BasicBlock, Function> {
-
-  // createSentinel is used to get hold of the node that marks the end of the
-  // list... (same trick used here as in ilist_traits<Instruction>)
-  BasicBlock *createSentinel() const {
-    return static_cast<BasicBlock*>(&Sentinel);
-  }
-  static void destroySentinel(BasicBlock*) {}
-
-  BasicBlock *provideInitialHead() const { return createSentinel(); }
-  BasicBlock *ensureHead(BasicBlock*) const { return createSentinel(); }
-  static void noteHead(BasicBlock*, BasicBlock*) {}
-
-  static ValueSymbolTable *getSymTab(Function *ItemParent);
-private:
-  mutable ilist_half_node<BasicBlock> Sentinel;
-};
-
-template<> struct ilist_traits<Argument>
-  : public SymbolTableListTraits<Argument, Function> {
-
-  Argument *createSentinel() const {
-    return static_cast<Argument*>(&Sentinel);
-  }
-  static void destroySentinel(Argument*) {}
-
-  Argument *provideInitialHead() const { return createSentinel(); }
-  Argument *ensureHead(Argument*) const { return createSentinel(); }
-  static void noteHead(Argument*, Argument*) {}
-
-  static ValueSymbolTable *getSymTab(Function *ItemParent);
-private:
-  mutable ilist_half_node<Argument> Sentinel;
-};
-
-class Function : public GlobalValue,
-                 public ilist_node<Function> {
-public:
-  typedef iplist<Argument> ArgumentListType;
-  typedef iplist<BasicBlock> BasicBlockListType;
-
-  // BasicBlock iterators...
-  typedef BasicBlockListType::iterator iterator;
-  typedef BasicBlockListType::const_iterator const_iterator;
-
-  typedef ArgumentListType::iterator arg_iterator;
-  typedef ArgumentListType::const_iterator const_arg_iterator;
-
-private:
-  // Important things that make up a function!
-  BasicBlockListType  BasicBlocks;        ///< The basic blocks
-  mutable ArgumentListType ArgumentList;  ///< The formal arguments
-  ValueSymbolTable *SymTab;               ///< Symbol table of args/instructions
-  AttributeSet AttributeList;              ///< Parameter attributes
-
-  // HasLazyArguments is stored in Value::SubclassData.
-  /*bool HasLazyArguments;*/
-
-  // The Calling Convention is stored in Value::SubclassData.
-  /*CallingConv::ID CallingConvention;*/
-
-  friend class SymbolTableListTraits<Function, Module>;
-
-  void setParent(Module *parent);
-
-  /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
-  /// built on demand, so that the list isn't allocated until the first client
-  /// needs it.  The hasLazyArguments predicate returns true if the arg list
-  /// hasn't been set up yet.
-  bool hasLazyArguments() const {
-    return getSubclassDataFromValue() & 1;
-  }
-  void CheckLazyArguments() const {
-    if (hasLazyArguments())
-      BuildLazyArguments();
-  }
-  void BuildLazyArguments() const;
-
-  Function(const Function&) LLVM_DELETED_FUNCTION;
-  void operator=(const Function&) LLVM_DELETED_FUNCTION;
-
-  /// Function ctor - If the (optional) Module argument is specified, the
-  /// function is automatically inserted into the end of the function list for
-  /// the module.
-  ///
-  Function(FunctionType *Ty, LinkageTypes Linkage,
-           const Twine &N = "", Module *M = 0);
-
-public:
-  static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
-                          const Twine &N = "", Module *M = 0) {
-    return new(0) Function(Ty, Linkage, N, M);
-  }
-
-  ~Function();
-
-  Type *getReturnType() const;           // Return the type of the ret val
-  FunctionType *getFunctionType() const; // Return the FunctionType for me
-
-  /// getContext - Return a pointer to the LLVMContext associated with this
-  /// function, or NULL if this function is not bound to a context yet.
-  LLVMContext &getContext() const;
-
-  /// isVarArg - Return true if this function takes a variable number of
-  /// arguments.
-  bool isVarArg() const;
-
-  /// getIntrinsicID - This method returns the ID number of the specified
-  /// function, or Intrinsic::not_intrinsic if the function is not an
-  /// instrinsic, or if the pointer is null.  This value is always defined to be
-  /// zero to allow easy checking for whether a function is intrinsic or not.
-  /// The particular intrinsic functions which correspond to this value are
-  /// defined in llvm/Intrinsics.h.
-  ///
-  unsigned getIntrinsicID() const LLVM_READONLY;
-  bool isIntrinsic() const { return getName().startswith("llvm."); }
-
-  /// getCallingConv()/setCallingConv(CC) - These method get and set the
-  /// calling convention of this function.  The enum values for the known
-  /// calling conventions are defined in CallingConv.h.
-  CallingConv::ID getCallingConv() const {
-    return static_cast<CallingConv::ID>(getSubclassDataFromValue() >> 1);
-  }
-  void setCallingConv(CallingConv::ID CC) {
-    setValueSubclassData((getSubclassDataFromValue() & 1) |
-                         (static_cast<unsigned>(CC) << 1));
-  }
-
-  /// getAttributes - Return the attribute list for this Function.
-  ///
-  const AttributeSet &getAttributes() const { return AttributeList; }
-
-  /// setAttributes - Set the attribute list for this Function.
-  ///
-  void setAttributes(const AttributeSet &attrs) { AttributeList = attrs; }
-
-  /// addFnAttr - Add function attributes to this function.
-  ///
-  void addFnAttr(Attribute::AttrKind N) {
-    // Function Attribute are stored at ~0 index
-    addAttribute(AttributeSet::FunctionIndex, Attribute::get(getContext(), N));
-  }
-
-  /// removeFnAttr - Remove function attributes from this function.
-  ///
-  void removeFnAttr(Attribute N) {
-    // Function Attribute are stored at ~0 index
-    removeAttribute(~0U, N);
-  }
-
-  /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
-  ///                             to use during code generation.
-  bool hasGC() const;
-  const char *getGC() const;
-  void setGC(const char *Str);
-  void clearGC();
-
-  /// addAttribute - adds the attribute to the list of attributes.
-  void addAttribute(unsigned i, Attribute attr);
-
-  /// removeAttribute - removes the attribute from the list of attributes.
-  void removeAttribute(unsigned i, Attribute attr);
-
-  /// @brief Extract the alignment for a call or parameter (0=unknown).
-  unsigned getParamAlignment(unsigned i) const {
-    return AttributeList.getParamAlignment(i);
-  }
-
-  /// @brief Determine if the function does not access memory.
-  bool doesNotAccessMemory() const {
-    return AttributeList.hasAttribute(AttributeSet::FunctionIndex,
-                                      Attribute::ReadNone);
-  }
-  void setDoesNotAccessMemory() {
-    addFnAttr(Attribute::ReadNone);
-  }
-
-  /// @brief Determine if the function does not access or only reads memory.
-  bool onlyReadsMemory() const {
-    return doesNotAccessMemory() ||
-      AttributeList.hasAttribute(AttributeSet::FunctionIndex,
-                                 Attribute::ReadOnly);
-  }
-  void setOnlyReadsMemory() {
-    addFnAttr(Attribute::ReadOnly);
-  }
-
-  /// @brief Determine if the function cannot return.
-  bool doesNotReturn() const {
-    return AttributeList.hasAttribute(AttributeSet::FunctionIndex,
-                                      Attribute::NoReturn);
-  }
-  void setDoesNotReturn() {
-    addFnAttr(Attribute::NoReturn);
-  }
-
-  /// @brief Determine if the function cannot unwind.
-  bool doesNotThrow() const {
-    return AttributeList.hasAttribute(AttributeSet::FunctionIndex,
-                                      Attribute::NoUnwind);
-  }
-  void setDoesNotThrow() {
-    addFnAttr(Attribute::NoUnwind);
-  }
-
-  /// @brief Determine if the call cannot be duplicated.
-  bool cannotDuplicate() const {
-    return AttributeList.hasAttribute(AttributeSet::FunctionIndex,
-                                      Attribute::NoDuplicate);
-  }
-  void setCannotDuplicate() {
-    addFnAttr(Attribute::NoDuplicate);
-  }
-
-  /// @brief True if the ABI mandates (or the user requested) that this
-  /// function be in a unwind table.
-  bool hasUWTable() const {
-    return AttributeList.hasAttribute(AttributeSet::FunctionIndex,
-                                      Attribute::UWTable);
-  }
-  void setHasUWTable() {
-    addFnAttr(Attribute::UWTable);
-  }
-
-  /// @brief True if this function needs an unwind table.
-  bool needsUnwindTableEntry() const {
-    return hasUWTable() || !doesNotThrow();
-  }
-
-  /// @brief Determine if the function returns a structure through first
-  /// pointer argument.
-  bool hasStructRetAttr() const {
-    return AttributeList.hasAttribute(1, Attribute::StructRet);
-  }
-
-  /// @brief Determine if the parameter does not alias other parameters.
-  /// @param n The parameter to check. 1 is the first parameter, 0 is the return
-  bool doesNotAlias(unsigned n) const {
-    return AttributeList.hasAttribute(n, Attribute::NoAlias);
-  }
-  void setDoesNotAlias(unsigned n) {
-    addAttribute(n, Attribute::get(getContext(), Attribute::NoAlias));
-  }
-
-  /// @brief Determine if the parameter can be captured.
-  /// @param n The parameter to check. 1 is the first parameter, 0 is the return
-  bool doesNotCapture(unsigned n) const {
-    return AttributeList.hasAttribute(n, Attribute::NoCapture);
-  }
-  void setDoesNotCapture(unsigned n) {
-    addAttribute(n, Attribute::get(getContext(), Attribute::NoCapture));
-  }
-
-  /// copyAttributesFrom - copy all additional attributes (those not needed to
-  /// create a Function) from the Function Src to this one.
-  void copyAttributesFrom(const GlobalValue *Src);
-
-  /// deleteBody - This method deletes the body of the function, and converts
-  /// the linkage to external.
-  ///
-  void deleteBody() {
-    dropAllReferences();
-    setLinkage(ExternalLinkage);
-  }
-
-  /// removeFromParent - This method unlinks 'this' from the containing module,
-  /// but does not delete it.
-  ///
-  virtual void removeFromParent();
-
-  /// eraseFromParent - This method unlinks 'this' from the containing module
-  /// and deletes it.
-  ///
-  virtual void eraseFromParent();
-
-
-  /// Get the underlying elements of the Function... the basic block list is
-  /// empty for external functions.
-  ///
-  const ArgumentListType &getArgumentList() const {
-    CheckLazyArguments();
-    return ArgumentList;
-  }
-  ArgumentListType &getArgumentList() {
-    CheckLazyArguments();
-    return ArgumentList;
-  }
-  static iplist<Argument> Function::*getSublistAccess(Argument*) {
-    return &Function::ArgumentList;
-  }
-
-  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
-        BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }
-  static iplist<BasicBlock> Function::*getSublistAccess(BasicBlock*) {
-    return &Function::BasicBlocks;
-  }
-
-  const BasicBlock       &getEntryBlock() const   { return front(); }
-        BasicBlock       &getEntryBlock()         { return front(); }
-
-  //===--------------------------------------------------------------------===//
-  // Symbol Table Accessing functions...
-
-  /// getSymbolTable() - Return the symbol table...
-  ///
-  inline       ValueSymbolTable &getValueSymbolTable()       { return *SymTab; }
-  inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; }
-
-
-  //===--------------------------------------------------------------------===//
-  // BasicBlock iterator forwarding functions
-  //
-  iterator                begin()       { return BasicBlocks.begin(); }
-  const_iterator          begin() const { return BasicBlocks.begin(); }
-  iterator                end  ()       { return BasicBlocks.end();   }
-  const_iterator          end  () const { return BasicBlocks.end();   }
-
-  size_t                   size() const { return BasicBlocks.size();  }
-  bool                    empty() const { return BasicBlocks.empty(); }
-  const BasicBlock       &front() const { return BasicBlocks.front(); }
-        BasicBlock       &front()       { return BasicBlocks.front(); }
-  const BasicBlock        &back() const { return BasicBlocks.back();  }
-        BasicBlock        &back()       { return BasicBlocks.back();  }
-
-  //===--------------------------------------------------------------------===//
-  // Argument iterator forwarding functions
-  //
-  arg_iterator arg_begin() {
-    CheckLazyArguments();
-    return ArgumentList.begin();
-  }
-  const_arg_iterator arg_begin() const {
-    CheckLazyArguments();
-    return ArgumentList.begin();
-  }
-  arg_iterator arg_end() {
-    CheckLazyArguments();
-    return ArgumentList.end();
-  }
-  const_arg_iterator arg_end() const {
-    CheckLazyArguments();
-    return ArgumentList.end();
-  }
-
-  size_t arg_size() const;
-  bool arg_empty() const;
-
-  /// viewCFG - This function is meant for use from the debugger.  You can just
-  /// say 'call F->viewCFG()' and a ghostview window should pop up from the
-  /// program, displaying the CFG of the current function with the code for each
-  /// basic block inside.  This depends on there being a 'dot' and 'gv' program
-  /// in your path.
-  ///
-  void viewCFG() const;
-
-  /// viewCFGOnly - This function is meant for use from the debugger.  It works
-  /// just like viewCFG, but it does not include the contents of basic blocks
-  /// into the nodes, just the label.  If you are only interested in the CFG
-  /// this can make the graph smaller.
-  ///
-  void viewCFGOnly() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Value *V) {
-    return V->getValueID() == Value::FunctionVal;
-  }
-
-  /// dropAllReferences() - This method causes all the subinstructions to "let
-  /// go" of all references that they are maintaining.  This allows one to
-  /// 'delete' a whole module at a time, even though there may be circular
-  /// references... first all references are dropped, and all use counts go to
-  /// zero.  Then everything is deleted for real.  Note that no operations are
-  /// valid on an object that has "dropped all references", except operator
-  /// delete.
-  ///
-  /// Since no other object in the module can have references into the body of a
-  /// function, dropping all references deletes the entire body of the function,
-  /// including any contained basic blocks.
-  ///
-  void dropAllReferences();
-
-  /// hasAddressTaken - returns true if there are any uses of this function
-  /// other than direct calls or invokes to it, or blockaddress expressions.
-  /// Optionally passes back an offending user for diagnostic purposes.
-  ///
-  bool hasAddressTaken(const User** = 0) const;
-
-  /// isDefTriviallyDead - Return true if it is trivially safe to remove
-  /// this function definition from the module (because it isn't externally
-  /// visible, does not have its address taken, and has no callers).  To make
-  /// this more accurate, call removeDeadConstantUsers first.
-  bool isDefTriviallyDead() const;
-
-  /// callsFunctionThatReturnsTwice - Return true if the function has a call to
-  /// setjmp or other function that gcc recognizes as "returning twice".
-  bool callsFunctionThatReturnsTwice() const;
-
-private:
-  // Shadow Value::setValueSubclassData with a private forwarding method so that
-  // subclasses cannot accidentally use it.
-  void setValueSubclassData(unsigned short D) {
-    Value::setValueSubclassData(D);
-  }
-};
-
-inline ValueSymbolTable *
-ilist_traits<BasicBlock>::getSymTab(Function *F) {
-  return F ? &F->getValueSymbolTable() : 0;
-}
-
-inline ValueSymbolTable *
-ilist_traits<Argument>::getSymTab(Function *F) {
-  return F ? &F->getValueSymbolTable() : 0;
-}
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/GlobalAlias.h b/include/llvm/GlobalAlias.h
deleted file mode 100644 (file)
index ff0c1b1..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-//===-------- llvm/GlobalAlias.h - GlobalAlias class ------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the declaration of the GlobalAlias class, which
-// represents a single function or variable alias in the IR.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_GLOBAL_ALIAS_H
-#define LLVM_GLOBAL_ALIAS_H
-
-#include "llvm/ADT/Twine.h"
-#include "llvm/ADT/ilist_node.h"
-#include "llvm/GlobalValue.h"
-#include "llvm/OperandTraits.h"
-
-namespace llvm {
-
-class Module;
-template<typename ValueSubClass, typename ItemParentClass>
-  class SymbolTableListTraits;
-
-class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
-  friend class SymbolTableListTraits<GlobalAlias, Module>;
-  void operator=(const GlobalAlias &) LLVM_DELETED_FUNCTION;
-  GlobalAlias(const GlobalAlias &) LLVM_DELETED_FUNCTION;
-
-  void setParent(Module *parent);
-
-public:
-  // allocate space for exactly one operand
-  void *operator new(size_t s) {
-    return User::operator new(s, 1);
-  }
-  /// GlobalAlias ctor - If a parent module is specified, the alias is
-  /// automatically inserted into the end of the specified module's alias list.
-  GlobalAlias(Type *Ty, LinkageTypes Linkage, const Twine &Name = "",
-              Constant* Aliasee = 0, Module *Parent = 0);
-
-  /// Provide fast operand accessors
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
-
-  /// removeFromParent - This method unlinks 'this' from the containing module,
-  /// but does not delete it.
-  ///
-  virtual void removeFromParent();
-
-  /// eraseFromParent - This method unlinks 'this' from the containing module
-  /// and deletes it.
-  ///
-  virtual void eraseFromParent();
-
-  /// set/getAliasee - These methods retrive and set alias target.
-  void setAliasee(Constant *GV);
-  const Constant *getAliasee() const {
-    return getOperand(0);
-  }
-  Constant *getAliasee() {
-    return getOperand(0);
-  }
-  /// getAliasedGlobal() - Aliasee can be either global or bitcast of
-  /// global. This method retrives the global for both aliasee flavours.
-  const GlobalValue *getAliasedGlobal() const;
-
-  /// resolveAliasedGlobal() - This method tries to ultimately resolve the alias
-  /// by going through the aliasing chain and trying to find the very last
-  /// global. Returns NULL if a cycle was found. If stopOnWeak is false, then
-  /// the whole chain aliasing chain is traversed, otherwise - only strong
-  /// aliases.
-  const GlobalValue *resolveAliasedGlobal(bool stopOnWeak = true) const;
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Value *V) {
-    return V->getValueID() == Value::GlobalAliasVal;
-  }
-};
-
-template <>
-struct OperandTraits<GlobalAlias> :
-  public FixedNumOperandTraits<GlobalAlias, 1> {
-};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/GlobalValue.h b/include/llvm/GlobalValue.h
deleted file mode 100644 (file)
index 7f7f74b..0000000
+++ /dev/null
@@ -1,299 +0,0 @@
-//===-- llvm/GlobalValue.h - Class to represent a global value --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is a common base class of all globally definable objects.  As such,
-// it is subclassed by GlobalVariable, GlobalAlias and by Function.  This is
-// used because you can do certain things with these global objects that you
-// can't do to anything else.  For example, use the address of one as a
-// constant.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_GLOBALVALUE_H
-#define LLVM_GLOBALVALUE_H
-
-#include "llvm/Constant.h"
-
-namespace llvm {
-
-class PointerType;
-class Module;
-
-class GlobalValue : public Constant {
-  GlobalValue(const GlobalValue &) LLVM_DELETED_FUNCTION;
-public:
-  /// @brief An enumeration for the kinds of linkage for global values.
-  enum LinkageTypes {
-    ExternalLinkage = 0,///< Externally visible function
-    AvailableExternallyLinkage, ///< Available for inspection, not emission.
-    LinkOnceAnyLinkage, ///< Keep one copy of function when linking (inline)
-    LinkOnceODRLinkage, ///< Same, but only replaced by something equivalent.
-    LinkOnceODRAutoHideLinkage, ///< Like LinkOnceODRLinkage but addr not taken.
-    WeakAnyLinkage,     ///< Keep one copy of named function when linking (weak)
-    WeakODRLinkage,     ///< Same, but only replaced by something equivalent.
-    AppendingLinkage,   ///< Special purpose, only applies to global arrays
-    InternalLinkage,    ///< Rename collisions when linking (static functions).
-    PrivateLinkage,     ///< Like Internal, but omit from symbol table.
-    LinkerPrivateLinkage, ///< Like Private, but linker removes.
-    LinkerPrivateWeakLinkage, ///< Like LinkerPrivate, but weak.
-    DLLImportLinkage,   ///< Function to be imported from DLL
-    DLLExportLinkage,   ///< Function to be accessible from DLL.
-    ExternalWeakLinkage,///< ExternalWeak linkage description.
-    CommonLinkage       ///< Tentative definitions.
-  };
-
-  /// @brief An enumeration for the kinds of visibility of global values.
-  enum VisibilityTypes {
-    DefaultVisibility = 0,  ///< The GV is visible
-    HiddenVisibility,       ///< The GV is hidden
-    ProtectedVisibility     ///< The GV is protected
-  };
-
-protected:
-  GlobalValue(Type *ty, ValueTy vty, Use *Ops, unsigned NumOps,
-              LinkageTypes linkage, const Twine &Name)
-    : Constant(ty, vty, Ops, NumOps), Linkage(linkage),
-      Visibility(DefaultVisibility), Alignment(0), UnnamedAddr(0), Parent(0) {
-    setName(Name);
-  }
-
-  // Note: VC++ treats enums as signed, so an extra bit is required to prevent
-  // Linkage and Visibility from turning into negative values.
-  LinkageTypes Linkage : 5;   // The linkage of this global
-  unsigned Visibility : 2;    // The visibility style of this global
-  unsigned Alignment : 16;    // Alignment of this symbol, must be power of two
-  unsigned UnnamedAddr : 1;   // This value's address is not significant
-  Module *Parent;             // The containing module.
-  std::string Section;        // Section to emit this into, empty mean default
-public:
-  ~GlobalValue() {
-    removeDeadConstantUsers();   // remove any dead constants using this.
-  }
-
-  unsigned getAlignment() const {
-    return (1u << Alignment) >> 1;
-  }
-  void setAlignment(unsigned Align);
-
-  bool hasUnnamedAddr() const { return UnnamedAddr; }
-  void setUnnamedAddr(bool Val) { UnnamedAddr = Val; }
-
-  VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
-  bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
-  bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
-  bool hasProtectedVisibility() const {
-    return Visibility == ProtectedVisibility;
-  }
-  void setVisibility(VisibilityTypes V) { Visibility = V; }
-  
-  bool hasSection() const { return !Section.empty(); }
-  const std::string &getSection() const { return Section; }
-  void setSection(StringRef S) { Section = S; }
-  
-  /// If the usage is empty (except transitively dead constants), then this
-  /// global value can be safely deleted since the destructor will
-  /// delete the dead constants as well.
-  /// @brief Determine if the usage of this global value is empty except
-  /// for transitively dead constants.
-  bool use_empty_except_constants();
-
-  /// getType - Global values are always pointers.
-  inline PointerType *getType() const {
-    return reinterpret_cast<PointerType*>(User::getType());
-  }
-
-  static LinkageTypes getLinkOnceLinkage(bool ODR) {
-    return ODR ? LinkOnceODRLinkage : LinkOnceAnyLinkage;
-  }
-  static LinkageTypes getWeakLinkage(bool ODR) {
-    return ODR ? WeakODRLinkage : WeakAnyLinkage;
-  }
-
-  static bool isExternalLinkage(LinkageTypes Linkage) {
-    return Linkage == ExternalLinkage;
-  }
-  static bool isAvailableExternallyLinkage(LinkageTypes Linkage) {
-    return Linkage == AvailableExternallyLinkage;
-  }
-  static bool isLinkOnceLinkage(LinkageTypes Linkage) {
-    return Linkage == LinkOnceAnyLinkage ||
-           Linkage == LinkOnceODRLinkage ||
-           Linkage == LinkOnceODRAutoHideLinkage;
-  }
-  static bool isLinkOnceODRAutoHideLinkage(LinkageTypes Linkage) {
-    return Linkage == LinkOnceODRAutoHideLinkage;
-  }
-  static bool isWeakLinkage(LinkageTypes Linkage) {
-    return Linkage == WeakAnyLinkage || Linkage == WeakODRLinkage;
-  }
-  static bool isAppendingLinkage(LinkageTypes Linkage) {
-    return Linkage == AppendingLinkage;
-  }
-  static bool isInternalLinkage(LinkageTypes Linkage) {
-    return Linkage == InternalLinkage;
-  }
-  static bool isPrivateLinkage(LinkageTypes Linkage) {
-    return Linkage == PrivateLinkage;
-  }
-  static bool isLinkerPrivateLinkage(LinkageTypes Linkage) {
-    return Linkage == LinkerPrivateLinkage;
-  }
-  static bool isLinkerPrivateWeakLinkage(LinkageTypes Linkage) {
-    return Linkage == LinkerPrivateWeakLinkage;
-  }
-  static bool isLocalLinkage(LinkageTypes Linkage) {
-    return isInternalLinkage(Linkage) || isPrivateLinkage(Linkage) ||
-      isLinkerPrivateLinkage(Linkage) || isLinkerPrivateWeakLinkage(Linkage);
-  }
-  static bool isDLLImportLinkage(LinkageTypes Linkage) {
-    return Linkage == DLLImportLinkage;
-  }
-  static bool isDLLExportLinkage(LinkageTypes Linkage) {
-    return Linkage == DLLExportLinkage;
-  }
-  static bool isExternalWeakLinkage(LinkageTypes Linkage) {
-    return Linkage == ExternalWeakLinkage;
-  }
-  static bool isCommonLinkage(LinkageTypes Linkage) {
-    return Linkage == CommonLinkage;
-  }
-
-  /// isDiscardableIfUnused - Whether the definition of this global may be
-  /// discarded if it is not used in its compilation unit.
-  static bool isDiscardableIfUnused(LinkageTypes Linkage) {
-    return isLinkOnceLinkage(Linkage) || isLocalLinkage(Linkage);
-  }
-
-  /// mayBeOverridden - Whether the definition of this global may be replaced
-  /// by something non-equivalent at link time.  For example, if a function has
-  /// weak linkage then the code defining it may be replaced by different code.
-  static bool mayBeOverridden(LinkageTypes Linkage) {
-    return Linkage == WeakAnyLinkage ||
-           Linkage == LinkOnceAnyLinkage ||
-           Linkage == CommonLinkage ||
-           Linkage == ExternalWeakLinkage ||
-           Linkage == LinkerPrivateWeakLinkage;
-  }
-
-  /// isWeakForLinker - Whether the definition of this global may be replaced at
-  /// link time.  NB: Using this method outside of the code generators is almost
-  /// always a mistake: when working at the IR level use mayBeOverridden instead
-  /// as it knows about ODR semantics.
-  static bool isWeakForLinker(LinkageTypes Linkage)  {
-    return Linkage == AvailableExternallyLinkage ||
-           Linkage == WeakAnyLinkage ||
-           Linkage == WeakODRLinkage ||
-           Linkage == LinkOnceAnyLinkage ||
-           Linkage == LinkOnceODRLinkage ||
-           Linkage == LinkOnceODRAutoHideLinkage ||
-           Linkage == CommonLinkage ||
-           Linkage == ExternalWeakLinkage ||
-           Linkage == LinkerPrivateWeakLinkage;
-  }
-
-  bool hasExternalLinkage() const { return isExternalLinkage(Linkage); }
-  bool hasAvailableExternallyLinkage() const {
-    return isAvailableExternallyLinkage(Linkage);
-  }
-  bool hasLinkOnceLinkage() const {
-    return isLinkOnceLinkage(Linkage);
-  }
-  bool hasLinkOnceODRAutoHideLinkage() const {
-    return isLinkOnceODRAutoHideLinkage(Linkage);
-  }
-  bool hasWeakLinkage() const {
-    return isWeakLinkage(Linkage);
-  }
-  bool hasAppendingLinkage() const { return isAppendingLinkage(Linkage); }
-  bool hasInternalLinkage() const { return isInternalLinkage(Linkage); }
-  bool hasPrivateLinkage() const { return isPrivateLinkage(Linkage); }
-  bool hasLinkerPrivateLinkage() const { return isLinkerPrivateLinkage(Linkage); }
-  bool hasLinkerPrivateWeakLinkage() const {
-    return isLinkerPrivateWeakLinkage(Linkage);
-  }
-  bool hasLocalLinkage() const { return isLocalLinkage(Linkage); }
-  bool hasDLLImportLinkage() const { return isDLLImportLinkage(Linkage); }
-  bool hasDLLExportLinkage() const { return isDLLExportLinkage(Linkage); }
-  bool hasExternalWeakLinkage() const { return isExternalWeakLinkage(Linkage); }
-  bool hasCommonLinkage() const { return isCommonLinkage(Linkage); }
-
-  void setLinkage(LinkageTypes LT) { Linkage = LT; }
-  LinkageTypes getLinkage() const { return Linkage; }
-
-  bool isDiscardableIfUnused() const {
-    return isDiscardableIfUnused(Linkage);
-  }
-
-  bool mayBeOverridden() const { return mayBeOverridden(Linkage); }
-
-  bool isWeakForLinker() const { return isWeakForLinker(Linkage); }
-
-  /// copyAttributesFrom - copy all additional attributes (those not needed to
-  /// create a GlobalValue) from the GlobalValue Src to this one.
-  virtual void copyAttributesFrom(const GlobalValue *Src);
-
-/// @name Materialization
-/// Materialization is used to construct functions only as they're needed. This
-/// is useful to reduce memory usage in LLVM or parsing work done by the
-/// BitcodeReader to load the Module.
-/// @{
-
-  /// isMaterializable - If this function's Module is being lazily streamed in
-  /// functions from disk or some other source, this method can be used to check
-  /// to see if the function has been read in yet or not.
-  bool isMaterializable() const;
-
-  /// isDematerializable - Returns true if this function was loaded from a
-  /// GVMaterializer that's still attached to its Module and that knows how to
-  /// dematerialize the function.
-  bool isDematerializable() const;
-
-  /// Materialize - make sure this GlobalValue is fully read.  If the module is
-  /// corrupt, this returns true and fills in the optional string with
-  /// information about the problem.  If successful, this returns false.
-  bool Materialize(std::string *ErrInfo = 0);
-
-  /// Dematerialize - If this GlobalValue is read in, and if the GVMaterializer
-  /// supports it, release the memory for the function, and set it up to be
-  /// materialized lazily.  If !isDematerializable(), this method is a noop.
-  void Dematerialize();
-
-/// @}
-
-  /// Override from Constant class.
-  virtual void destroyConstant();
-
-  /// isDeclaration - Return true if the primary definition of this global 
-  /// value is outside of the current translation unit.
-  bool isDeclaration() const;
-
-  /// removeFromParent - This method unlinks 'this' from the containing module,
-  /// but does not delete it.
-  virtual void removeFromParent() = 0;
-
-  /// eraseFromParent - This method unlinks 'this' from the containing module
-  /// and deletes it.
-  virtual void eraseFromParent() = 0;
-
-  /// getParent - Get the module that this global value is contained inside
-  /// of...
-  inline Module *getParent() { return Parent; }
-  inline const Module *getParent() const { return Parent; }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Value *V) {
-    return V->getValueID() == Value::FunctionVal ||
-           V->getValueID() == Value::GlobalVariableVal ||
-           V->getValueID() == Value::GlobalAliasVal;
-  }
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/GlobalVariable.h b/include/llvm/GlobalVariable.h
deleted file mode 100644 (file)
index 79463fb..0000000
+++ /dev/null
@@ -1,191 +0,0 @@
-//===-- llvm/GlobalVariable.h - GlobalVariable class ------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the declaration of the GlobalVariable class, which
-// represents a single global variable (or constant) in the VM.
-//
-// Global variables are constant pointers that refer to hunks of space that are
-// allocated by either the VM, or by the linker in a static compiler.  A global
-// variable may have an initial value, which is copied into the executables .data
-// area.  Global Constants are required to have initializers.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_GLOBAL_VARIABLE_H
-#define LLVM_GLOBAL_VARIABLE_H
-
-#include "llvm/ADT/Twine.h"
-#include "llvm/ADT/ilist_node.h"
-#include "llvm/GlobalValue.h"
-#include "llvm/OperandTraits.h"
-
-namespace llvm {
-
-class Module;
-class Constant;
-template<typename ValueSubClass, typename ItemParentClass>
-  class SymbolTableListTraits;
-
-class GlobalVariable : public GlobalValue, public ilist_node<GlobalVariable> {
-  friend class SymbolTableListTraits<GlobalVariable, Module>;
-  void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
-  void operator=(const GlobalVariable &) LLVM_DELETED_FUNCTION;
-  GlobalVariable(const GlobalVariable &) LLVM_DELETED_FUNCTION;
-
-  void setParent(Module *parent);
-
-  bool isConstantGlobal : 1;           // Is this a global constant?
-  unsigned threadLocalMode : 3;        // Is this symbol "Thread Local",
-                                       // if so, what is the desired model?
-
-public:
-  // allocate space for exactly one operand
-  void *operator new(size_t s) {
-    return User::operator new(s, 1);
-  }
-
-  enum ThreadLocalMode {
-    NotThreadLocal = 0,
-    GeneralDynamicTLSModel,
-    LocalDynamicTLSModel,
-    InitialExecTLSModel,
-    LocalExecTLSModel
-  };
-
-  /// GlobalVariable ctor - If a parent module is specified, the global is
-  /// automatically inserted into the end of the specified modules global list.
-  GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,
-                 Constant *Initializer = 0, const Twine &Name = "",
-                 ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0);
-  /// GlobalVariable ctor - This creates a global and inserts it before the
-  /// specified other global.
-  GlobalVariable(Module &M, Type *Ty, bool isConstant,
-                 LinkageTypes Linkage, Constant *Initializer,
-                 const Twine &Name = "",
-                 GlobalVariable *InsertBefore = 0,
-                 ThreadLocalMode = NotThreadLocal,
-                 unsigned AddressSpace = 0);
-
-  ~GlobalVariable() {
-    NumOperands = 1; // FIXME: needed by operator delete
-  }
-
-  /// Provide fast operand accessors
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
-
-  /// hasInitializer - Unless a global variable isExternal(), it has an
-  /// initializer.  The initializer for the global variable/constant is held by
-  /// Initializer if an initializer is specified.
-  ///
-  inline bool hasInitializer() const { return !isDeclaration(); }
-
-  /// hasDefinitiveInitializer - Whether the global variable has an initializer,
-  /// and any other instances of the global (this can happen due to weak
-  /// linkage) are guaranteed to have the same initializer.
-  ///
-  /// Note that if you want to transform a global, you must use
-  /// hasUniqueInitializer() instead, because of the *_odr linkage type.
-  ///
-  /// Example:
-  ///
-  /// @a = global SomeType* null - Initializer is both definitive and unique.
-  ///
-  /// @b = global weak SomeType* null - Initializer is neither definitive nor
-  /// unique.
-  ///
-  /// @c = global weak_odr SomeType* null - Initializer is definitive, but not
-  /// unique.
-  inline bool hasDefinitiveInitializer() const {
-    return hasInitializer() &&
-      // The initializer of a global variable with weak linkage may change at
-      // link time.
-      !mayBeOverridden();
-  }
-
-  /// hasUniqueInitializer - Whether the global variable has an initializer, and
-  /// any changes made to the initializer will turn up in the final executable.
-  inline bool hasUniqueInitializer() const {
-    return hasInitializer() &&
-      // It's not safe to modify initializers of global variables with weak
-      // linkage, because the linker might choose to discard the initializer and
-      // use the initializer from another instance of the global variable
-      // instead. It is wrong to modify the initializer of a global variable
-      // with *_odr linkage because then different instances of the global may
-      // have different initializers, breaking the One Definition Rule.
-      !isWeakForLinker();
-  }
-
-  /// getInitializer - Return the initializer for this global variable.  It is
-  /// illegal to call this method if the global is external, because we cannot
-  /// tell what the value is initialized to!
-  ///
-  inline const Constant *getInitializer() const {
-    assert(hasInitializer() && "GV doesn't have initializer!");
-    return static_cast<Constant*>(Op<0>().get());
-  }
-  inline Constant *getInitializer() {
-    assert(hasInitializer() && "GV doesn't have initializer!");
-    return static_cast<Constant*>(Op<0>().get());
-  }
-  /// setInitializer - Sets the initializer for this global variable, removing
-  /// any existing initializer if InitVal==NULL.  If this GV has type T*, the
-  /// initializer must have type T.
-  void setInitializer(Constant *InitVal);
-
-  /// If the value is a global constant, its value is immutable throughout the
-  /// runtime execution of the program.  Assigning a value into the constant
-  /// leads to undefined behavior.
-  ///
-  bool isConstant() const { return isConstantGlobal; }
-  void setConstant(bool Val) { isConstantGlobal = Val; }
-
-  /// If the value is "Thread Local", its value isn't shared by the threads.
-  bool isThreadLocal() const { return threadLocalMode != NotThreadLocal; }
-  void setThreadLocal(bool Val) {
-    threadLocalMode = Val ? GeneralDynamicTLSModel : NotThreadLocal;
-  }
-  void setThreadLocalMode(ThreadLocalMode Val) { threadLocalMode = Val; }
-  ThreadLocalMode getThreadLocalMode() const {
-    return static_cast<ThreadLocalMode>(threadLocalMode);
-  }
-
-  /// copyAttributesFrom - copy all additional attributes (those not needed to
-  /// create a GlobalVariable) from the GlobalVariable Src to this one.
-  void copyAttributesFrom(const GlobalValue *Src);
-
-  /// removeFromParent - This method unlinks 'this' from the containing module,
-  /// but does not delete it.
-  ///
-  virtual void removeFromParent();
-
-  /// eraseFromParent - This method unlinks 'this' from the containing module
-  /// and deletes it.
-  ///
-  virtual void eraseFromParent();
-
-  /// Override Constant's implementation of this method so we can
-  /// replace constant initializers.
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Value *V) {
-    return V->getValueID() == Value::GlobalVariableVal;
-  }
-};
-
-template <>
-struct OperandTraits<GlobalVariable> :
-  public OptionalOperandTraits<GlobalVariable> {
-};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalVariable, Value)
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/IR/Argument.h b/include/llvm/IR/Argument.h
new file mode 100644 (file)
index 0000000..f737e40
--- /dev/null
@@ -0,0 +1,91 @@
+//===-- llvm/Argument.h - Definition of the Argument class ------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the Argument class. 
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ARGUMENT_H
+#define LLVM_ARGUMENT_H
+
+#include "llvm/ADT/Twine.h"
+#include "llvm/ADT/ilist_node.h"
+#include "llvm/IR/Attributes.h"
+#include "llvm/IR/Value.h"
+
+namespace llvm {
+
+template<typename ValueSubClass, typename ItemParentClass>
+  class SymbolTableListTraits;
+
+/// A class to represent an incoming formal argument to a Function. An argument
+/// is a very simple Value. It is essentially a named (optional) type. When used
+/// in the body of a function, it represents the value of the actual argument
+/// the function was called with.
+/// @brief LLVM Argument representation  
+class Argument : public Value, public ilist_node<Argument> {
+  virtual void anchor();
+  Function *Parent;
+
+  friend class SymbolTableListTraits<Argument, Function>;
+  void setParent(Function *parent);
+
+public:
+  /// Argument ctor - If Function argument is specified, this argument is
+  /// inserted at the end of the argument list for the function.
+  ///
+  explicit Argument(Type *Ty, const Twine &Name = "", Function *F = 0);
+
+  inline const Function *getParent() const { return Parent; }
+  inline       Function *getParent()       { return Parent; }
+
+  /// getArgNo - Return the index of this formal argument in its containing
+  /// function.  For example in "void foo(int a, float b)" a is 0 and b is 1. 
+  unsigned getArgNo() const;
+  
+  /// hasByValAttr - Return true if this argument has the byval attribute on it
+  /// in its containing function.
+  bool hasByValAttr() const;
+  
+  /// getParamAlignment - If this is a byval argument, return its alignment.
+  unsigned getParamAlignment() const;
+
+  /// hasNestAttr - Return true if this argument has the nest attribute on
+  /// it in its containing function.
+  bool hasNestAttr() const;
+
+  /// hasNoAliasAttr - Return true if this argument has the noalias attribute on
+  /// it in its containing function.
+  bool hasNoAliasAttr() const;
+  
+  /// hasNoCaptureAttr - Return true if this argument has the nocapture
+  /// attribute on it in its containing function.
+  bool hasNoCaptureAttr() const;
+  
+  /// hasStructRetAttr - Return true if this argument has the sret attribute on
+  /// it in its containing function.
+  bool hasStructRetAttr() const;
+
+  /// addAttr - Add a Attribute to an argument
+  void addAttr(Attribute);
+  
+  /// removeAttr - Remove a Attribute from an argument
+  void removeAttr(Attribute);
+
+  /// classof - Methods for support type inquiry through isa, cast, and
+  /// dyn_cast:
+  ///
+  static inline bool classof(const Value *V) {
+    return V->getValueID() == ArgumentVal;
+  }
+};
+
+} // End llvm namespace
+
+#endif
diff --git a/include/llvm/IR/Attributes.h b/include/llvm/IR/Attributes.h
new file mode 100644 (file)
index 0000000..c28f0bd
--- /dev/null
@@ -0,0 +1,399 @@
+//===-- llvm/Attributes.h - Container for Attributes ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file contains the simple types necessary to represent the
+/// attributes associated with functions and their calls.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ATTRIBUTES_H
+#define LLVM_ATTRIBUTES_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/MathExtras.h"
+#include <cassert>
+#include <string>
+
+namespace llvm {
+
+class AttrBuilder;
+class AttributeImpl;
+class LLVMContext;
+class Type;
+
+//===----------------------------------------------------------------------===//
+/// \class
+/// \brief Functions, function parameters, and return types can have attributes
+/// to indicate how they should be treated by optimizations and code
+/// generation. This class represents one of those attributes. It's light-weight
+/// and should be passed around by-value.
+class Attribute {
+public:
+  /// This enumeration lists the attributes that can be associated with
+  /// parameters, function results or the function itself.
+  ///
+  /// Note: uwtable is about the ABI or the user mandating an entry in the
+  /// unwind table. The nounwind attribute is about an exception passing by the
+  /// function.
+  ///
+  /// In a theoretical system that uses tables for profiling and sjlj for
+  /// exceptions, they would be fully independent. In a normal system that uses
+  /// tables for both, the semantics are:
+  ///
+  /// nil                = Needs an entry because an exception might pass by.
+  /// nounwind           = No need for an entry
+  /// uwtable            = Needs an entry because the ABI says so and because
+  ///                      an exception might pass by.
+  /// uwtable + nounwind = Needs an entry because the ABI says so.
+
+  enum AttrKind {
+    // IR-Level Attributes
+    None,                  ///< No attributes have been set
+    AddressSafety,         ///< Address safety checking is on.
+    Alignment,             ///< Alignment of parameter (5 bits)
+                           ///< stored as log2 of alignment with +1 bias
+                           ///< 0 means unaligned (different from align(1))
+    AlwaysInline,          ///< inline=always
+    ByVal,                 ///< Pass structure by value
+    InlineHint,            ///< Source said inlining was desirable
+    InReg,                 ///< Force argument to be passed in register
+    MinSize,               ///< Function must be optimized for size first
+    Naked,                 ///< Naked function
+    Nest,                  ///< Nested function static chain
+    NoAlias,               ///< Considered to not alias after call
+    NoCapture,             ///< Function creates no aliases of pointer
+    NoDuplicate,           ///< Call cannot be duplicated
+    NoImplicitFloat,       ///< Disable implicit floating point insts
+    NoInline,              ///< inline=never
+    NonLazyBind,           ///< Function is called early and/or
+                           ///< often, so lazy binding isn't worthwhile
+    NoRedZone,             ///< Disable redzone
+    NoReturn,              ///< Mark the function as not returning
+    NoUnwind,              ///< Function doesn't unwind stack
+    OptimizeForSize,       ///< opt_size
+    ReadNone,              ///< Function does not access memory
+    ReadOnly,              ///< Function only reads from memory
+    ReturnsTwice,          ///< Function can return twice
+    SExt,                  ///< Sign extended before/after call
+    StackAlignment,        ///< Alignment of stack for function (3 bits)
+                           ///< stored as log2 of alignment with +1 bias 0
+                           ///< means unaligned (different from
+                           ///< alignstack=(1))
+    StackProtect,          ///< Stack protection.
+    StackProtectReq,       ///< Stack protection required.
+    StructRet,             ///< Hidden pointer to structure to return
+    UWTable,               ///< Function must be in a unwind table
+    ZExt                   ///< Zero extended before/after call
+  };
+private:
+  AttributeImpl *pImpl;
+  Attribute(AttributeImpl *A) : pImpl(A) {}
+public:
+  Attribute() : pImpl(0) {}
+
+  /// \brief Return a uniquified Attribute object. This takes the uniquified
+  /// value from the Builder and wraps it in the Attribute class.
+  static Attribute get(LLVMContext &Context, ArrayRef<AttrKind> Vals);
+  static Attribute get(LLVMContext &Context, AttrBuilder &B);
+
+  /// \brief Return true if the attribute is present.
+  bool hasAttribute(AttrKind Val) const;
+
+  /// \brief Return true if attributes exist
+  bool hasAttributes() const;
+
+  /// \brief Return true if the attributes are a non-null intersection.
+  bool hasAttributes(const Attribute &A) const;
+
+  /// \brief Returns the alignment field of an attribute as a byte alignment
+  /// value.
+  unsigned getAlignment() const;
+
+  /// \brief Returns the stack alignment field of an attribute as a byte
+  /// alignment value.
+  unsigned getStackAlignment() const;
+
+  bool operator==(AttrKind K) const;
+  bool operator!=(AttrKind K) const;
+
+  // FIXME: Remove these 'operator' methods.
+  bool operator==(const Attribute &A) const {
+    return pImpl == A.pImpl;
+  }
+  bool operator!=(const Attribute &A) const {
+    return pImpl != A.pImpl;
+  }
+
+  uint64_t getBitMask() const;
+
+  /// \brief Which attributes cannot be applied to a type.
+  static Attribute typeIncompatible(Type *Ty);
+
+  /// \brief This returns an integer containing an encoding of all the LLVM
+  /// attributes found in the given attribute bitset.  Any change to this
+  /// encoding is a breaking change to bitcode compatibility.
+  static uint64_t encodeLLVMAttributesForBitcode(Attribute Attrs);
+
+  /// \brief This returns an attribute bitset containing the LLVM attributes
+  /// that have been decoded from the given integer.  This function must stay in
+  /// sync with 'encodeLLVMAttributesForBitcode'.
+  static Attribute decodeLLVMAttributesForBitcode(LLVMContext &C,
+                                                  uint64_t EncodedAttrs);
+
+  /// \brief The Attribute is converted to a string of equivalent mnemonic. This
+  /// is, presumably, for writing out the mnemonics for the assembly writer.
+  std::string getAsString() const;
+};
+
+//===----------------------------------------------------------------------===//
+/// \class
+/// \brief This class is used in conjunction with the Attribute::get method to
+/// create an Attribute object. The object itself is uniquified. The Builder's
+/// value, however, is not. So this can be used as a quick way to test for
+/// equality, presence of attributes, etc.
+class AttrBuilder {
+  uint64_t Bits;
+public:
+  AttrBuilder() : Bits(0) {}
+  explicit AttrBuilder(uint64_t B) : Bits(B) {}
+  AttrBuilder(const Attribute &A) : Bits(A.getBitMask()) {}
+
+  void clear() { Bits = 0; }
+
+  /// addAttribute - Add an attribute to the builder.
+  AttrBuilder &addAttribute(Attribute::AttrKind Val);
+
+  /// removeAttribute - Remove an attribute from the builder.
+  AttrBuilder &removeAttribute(Attribute::AttrKind Val);
+
+  /// addAttribute - Add the attributes from A to the builder.
+  AttrBuilder &addAttributes(const Attribute &A);
+
+  /// removeAttribute - Remove the attributes from A from the builder.
+  AttrBuilder &removeAttributes(const Attribute &A);
+
+  /// \brief Return true if the builder has the specified attribute.
+  bool contains(Attribute::AttrKind A) const;
+
+  /// hasAttributes - Return true if the builder has IR-level attributes.
+  bool hasAttributes() const;
+
+  /// hasAttributes - Return true if the builder has any attribute that's in the
+  /// specified attribute.
+  bool hasAttributes(const Attribute &A) const;
+
+  /// hasAlignmentAttr - Return true if the builder has an alignment attribute.
+  bool hasAlignmentAttr() const;
+
+  /// getAlignment - Retrieve the alignment attribute, if it exists.
+  uint64_t getAlignment() const;
+
+  /// getStackAlignment - Retrieve the stack alignment attribute, if it exists.
+  uint64_t getStackAlignment() const;
+
+  /// addAlignmentAttr - This turns an int alignment (which must be a power of
+  /// 2) into the form used internally in Attribute.
+  AttrBuilder &addAlignmentAttr(unsigned Align);
+
+  /// addStackAlignmentAttr - This turns an int stack alignment (which must be a
+  /// power of 2) into the form used internally in Attribute.
+  AttrBuilder &addStackAlignmentAttr(unsigned Align);
+
+  /// addRawValue - Add the raw value to the internal representation.
+  /// N.B. This should be used ONLY for decoding LLVM bitcode!
+  AttrBuilder &addRawValue(uint64_t Val);
+
+  /// @brief Remove attributes that are used on functions only.
+  void removeFunctionOnlyAttrs() {
+    removeAttribute(Attribute::NoReturn)
+      .removeAttribute(Attribute::NoUnwind)
+      .removeAttribute(Attribute::ReadNone)
+      .removeAttribute(Attribute::ReadOnly)
+      .removeAttribute(Attribute::NoInline)
+      .removeAttribute(Attribute::AlwaysInline)
+      .removeAttribute(Attribute::OptimizeForSize)
+      .removeAttribute(Attribute::StackProtect)
+      .removeAttribute(Attribute::StackProtectReq)
+      .removeAttribute(Attribute::NoRedZone)
+      .removeAttribute(Attribute::NoImplicitFloat)
+      .removeAttribute(Attribute::Naked)
+      .removeAttribute(Attribute::InlineHint)
+      .removeAttribute(Attribute::StackAlignment)
+      .removeAttribute(Attribute::UWTable)
+      .removeAttribute(Attribute::NonLazyBind)
+      .removeAttribute(Attribute::ReturnsTwice)
+      .removeAttribute(Attribute::AddressSafety)
+      .removeAttribute(Attribute::MinSize)
+      .removeAttribute(Attribute::NoDuplicate);
+  }
+
+  uint64_t getBitMask() const { return Bits; }
+
+  bool operator==(const AttrBuilder &B) {
+    return Bits == B.Bits;
+  }
+  bool operator!=(const AttrBuilder &B) {
+    return Bits != B.Bits;
+  }
+};
+
+//===----------------------------------------------------------------------===//
+/// \class
+/// \brief This is just a pair of values to associate a set of attributes with
+/// an index.
+struct AttributeWithIndex {
+  Attribute Attrs;  ///< The attributes that are set, or'd together.
+  unsigned Index;   ///< Index of the parameter for which the attributes apply.
+                    ///< Index 0 is used for return value attributes.
+                    ///< Index ~0U is used for function attributes.
+
+  static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
+                                ArrayRef<Attribute::AttrKind> Attrs) {
+    return get(Idx, Attribute::get(C, Attrs));
+  }
+  static AttributeWithIndex get(unsigned Idx, Attribute Attrs) {
+    AttributeWithIndex P;
+    P.Index = Idx;
+    P.Attrs = Attrs;
+    return P;
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// AttributeSet Smart Pointer
+//===----------------------------------------------------------------------===//
+
+class AttributeSetImpl;
+
+//===----------------------------------------------------------------------===//
+/// \class
+/// \brief This class manages the ref count for the opaque AttributeSetImpl
+/// object and provides accessors for it.
+class AttributeSet {
+public:
+  enum AttrIndex {
+    ReturnIndex = 0U,
+    FunctionIndex = ~0U
+  };
+private:
+  /// \brief The attributes that we are managing.  This can be null to represent
+  /// the empty attributes list.
+  AttributeSetImpl *AttrList;
+
+  /// \brief The attributes for the specified index are returned.  Attributes
+  /// for the result are denoted with Idx = 0.
+  Attribute getAttributes(unsigned Idx) const;
+
+  explicit AttributeSet(AttributeSetImpl *LI) : AttrList(LI) {}
+public:
+  AttributeSet() : AttrList(0) {}
+  AttributeSet(const AttributeSet &P) : AttrList(P.AttrList) {}
+  const AttributeSet &operator=(const AttributeSet &RHS);
+
+  //===--------------------------------------------------------------------===//
+  // Attribute List Construction and Mutation
+  //===--------------------------------------------------------------------===//
+
+  /// \brief Return an AttributeSet with the specified parameters in it.
+  static AttributeSet get(LLVMContext &C, ArrayRef<AttributeWithIndex> Attrs);
+
+  /// \brief Add the specified attribute at the specified index to this
+  /// attribute list.  Since attribute lists are immutable, this returns the new
+  /// list.
+  AttributeSet addAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const;
+
+  /// \brief Remove the specified attribute at the specified index from this
+  /// attribute list.  Since attribute lists are immutable, this returns the new
+  /// list.
+  AttributeSet removeAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const;
+
+  //===--------------------------------------------------------------------===//
+  // Attribute List Accessors
+  //===--------------------------------------------------------------------===//
+
+  /// \brief The attributes for the specified index are returned.
+  Attribute getParamAttributes(unsigned Idx) const {
+    return getAttributes(Idx);
+  }
+
+  /// \brief The attributes for the ret value are returned.
+  Attribute getRetAttributes() const {
+    return getAttributes(ReturnIndex);
+  }
+
+  /// \brief The function attributes are returned.
+  Attribute getFnAttributes() const {
+    return getAttributes(FunctionIndex);
+  }
+
+  /// \brief Return the alignment for the specified function parameter.
+  unsigned getParamAlignment(unsigned Idx) const {
+    return getAttributes(Idx).getAlignment();
+  }
+
+  /// \brief Return true if the attribute exists at the given index.
+  bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
+
+  /// \brief Return true if attribute exists at the given index.
+  bool hasAttributes(unsigned Index) const;
+
+  /// \brief Get the stack alignment.
+  unsigned getStackAlignment(unsigned Index) const;
+
+  /// \brief Return the attributes at the index as a string.
+  std::string getAsString(unsigned Index) const;
+
+  uint64_t getBitMask(unsigned Index) const;
+
+  /// \brief Return true if the specified attribute is set for at least one
+  /// parameter or for the return value.
+  bool hasAttrSomewhere(Attribute::AttrKind Attr) const;
+
+  /// operator==/!= - Provide equality predicates.
+  bool operator==(const AttributeSet &RHS) const {
+    return AttrList == RHS.AttrList;
+  }
+  bool operator!=(const AttributeSet &RHS) const {
+    return AttrList != RHS.AttrList;
+  }
+
+  //===--------------------------------------------------------------------===//
+  // Attribute List Introspection
+  //===--------------------------------------------------------------------===//
+
+  /// \brief Return a raw pointer that uniquely identifies this attribute list.
+  void *getRawPointer() const {
+    return AttrList;
+  }
+
+  // Attributes are stored as a dense set of slots, where there is one slot for
+  // each argument that has an attribute.  This allows walking over the dense
+  // set instead of walking the sparse list of attributes.
+
+  /// \brief Return true if there are no attributes.
+  bool isEmpty() const {
+    return AttrList == 0;
+  }
+
+  /// \brief Return the number of slots used in this attribute list.  This is
+  /// the number of arguments that have an attribute set on them (including the
+  /// function itself).
+  unsigned getNumSlots() const;
+
+  /// \brief Return the AttributeWithIndex at the specified slot.  This holds a
+  /// index number plus a set of attributes.
+  const AttributeWithIndex &getSlot(unsigned Slot) const;
+
+  void dump() const;
+};
+
+} // end llvm namespace
+
+#endif
diff --git a/include/llvm/IR/BasicBlock.h b/include/llvm/IR/BasicBlock.h
new file mode 100644 (file)
index 0000000..15f4aa7
--- /dev/null
@@ -0,0 +1,297 @@
+//===-- llvm/BasicBlock.h - Represent a basic block in the VM ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the declaration of the BasicBlock class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BASICBLOCK_H
+#define LLVM_BASICBLOCK_H
+
+#include "llvm/ADT/Twine.h"
+#include "llvm/ADT/ilist.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/SymbolTableListTraits.h"
+#include "llvm/Support/DataTypes.h"
+
+namespace llvm {
+
+class LandingPadInst;
+class TerminatorInst;
+class LLVMContext;
+class BlockAddress;
+
+template<> struct ilist_traits<Instruction>
+  : public SymbolTableListTraits<Instruction, BasicBlock> {
+  // createSentinel is used to get hold of a node that marks the end of
+  // the list...
+  // The sentinel is relative to this instance, so we use a non-static
+  // method.
+  Instruction *createSentinel() const {
+    // since i(p)lists always publicly derive from the corresponding
+    // traits, placing a data member in this class will augment i(p)list.
+    // But since the NodeTy is expected to publicly derive from
+    // ilist_node<NodeTy>, there is a legal viable downcast from it
+    // to NodeTy. We use this trick to superpose i(p)list with a "ghostly"
+    // NodeTy, which becomes the sentinel. Dereferencing the sentinel is
+    // forbidden (save the ilist_node<NodeTy>) so no one will ever notice
+    // the superposition.
+    return static_cast<Instruction*>(&Sentinel);
+  }
+  static void destroySentinel(Instruction*) {}
+
+  Instruction *provideInitialHead() const { return createSentinel(); }
+  Instruction *ensureHead(Instruction*) const { return createSentinel(); }
+  static void noteHead(Instruction*, Instruction*) {}
+private:
+  mutable ilist_half_node<Instruction> Sentinel;
+};
+
+/// This represents a single basic block in LLVM. A basic block is simply a
+/// container of instructions that execute sequentially. Basic blocks are Values
+/// because they are referenced by instructions such as branches and switch
+/// tables. The type of a BasicBlock is "Type::LabelTy" because the basic block
+/// represents a label to which a branch can jump.
+///
+/// A well formed basic block is formed of a list of non-terminating
+/// instructions followed by a single TerminatorInst instruction.
+/// TerminatorInst's may not occur in the middle of basic blocks, and must
+/// terminate the blocks. The BasicBlock class allows malformed basic blocks to
+/// occur because it may be useful in the intermediate stage of constructing or
+/// modifying a program. However, the verifier will ensure that basic blocks
+/// are "well formed".
+/// @brief LLVM Basic Block Representation
+class BasicBlock : public Value, // Basic blocks are data objects also
+                   public ilist_node<BasicBlock> {
+  friend class BlockAddress;
+public:
+  typedef iplist<Instruction> InstListType;
+private:
+  InstListType InstList;
+  Function *Parent;
+
+  void setParent(Function *parent);
+  friend class SymbolTableListTraits<BasicBlock, Function>;
+
+  BasicBlock(const BasicBlock &) LLVM_DELETED_FUNCTION;
+  void operator=(const BasicBlock &) LLVM_DELETED_FUNCTION;
+
+  /// BasicBlock ctor - If the function parameter is specified, the basic block
+  /// is automatically inserted at either the end of the function (if
+  /// InsertBefore is null)