LLVM API Documentation

llvm Namespace Reference

===---------------------------------------------------------------------===// More...


Classes

class  AbstractTypeUser
class  PATypeHandle
class  PATypeHolder
class  BitSetVector
struct  IdentityFunctor
class  DenseMap
class  df_iterator_storage
class  df_iterator_storage< SetType, true >
class  df_iterator
struct  df_ext_iterator
struct  idf_iterator
struct  idf_ext_iterator
class  EquivalenceClasses
struct  GraphTraits
struct  Inverse
class  po_iterator_storage
class  po_iterator_storage< SetType, true >
class  po_iterator
struct  po_ext_iterator
struct  ipo_iterator
struct  ipo_ext_iterator
class  ReversePostOrderTraversal
class  scc_iterator
class  SetVector
 A vector that has set insertion semantics. More...
class  StatisticBase
class  Statistic
struct  greater_ptr
class  mapped_iterator
class  Tree
class  UniqueVector
class  AliasAnalysis
class  AliasSet
class  AliasSetTracker
class  CallGraph
class  CallGraphNode
struct  GraphTraits< CallGraphNode * >
struct  GraphTraits< const CallGraphNode * >
struct  GraphTraits< CallGraph * >
struct  GraphTraits< const CallGraph * >
class  constant_iterator
class  LocalDataStructures
class  BUDataStructures
class  TDDataStructures
struct  CompleteBUDataStructures
struct  EquivClassGraphs
class  DSScalarMap
class  DSGraph
class  ReachabilityCloner
class  DSNodeIterator
struct  GraphTraits< DSNode * >
struct  GraphTraits< const DSNode * >
struct  GraphTraits< DSGraph * >
struct  GraphTraits< const DSGraph * >
class  DSNode
struct  ilist_traits< DSNode >
struct  ilist_traits< const DSNode >
class  DSNodeHandle
class  DSCallSite
class  DominatorBase
class  ImmediateDominatorsBase
struct  ImmediateDominators
struct  DominatorSetBase
struct  DominatorSet
struct  DominatorTreeBase
struct  ETForestBase
struct  ETForest
struct  DominatorTree
struct  GraphTraits< DominatorTree * >
struct  DominanceFrontierBase
struct  DominanceFrontier
class  ETOccurrence
class  ETNode
class  FindUsedTypes
class  Interval
struct  GraphTraits< Interval * >
struct  GraphTraits< Inverse< Interval * > >
class  IntervalIterator
class  IntervalPartition
class  Loop
class  LoopInfo
struct  GraphTraits< const Loop * >
struct  GraphTraits< Loop * >
struct  ImmediatePostDominators
struct  PostDominatorSet
struct  PostDominatorTree
struct  PostETForest
struct  PostDominanceFrontier
class  ProfileInfo
class  ProfileInfoLoader
class  SCEV
struct  SCEVCouldNotCompute
class  SCEVHandle
struct  simplify_type< const SCEVHandle >
struct  simplify_type< SCEVHandle >
class  ScalarEvolution
struct  SCEVExpander
class  SCEVConstant
class  SCEVTruncateExpr
class  SCEVZeroExtendExpr
class  SCEVCommutativeExpr
class  SCEVAddExpr
class  SCEVMulExpr
class  SCEVSDivExpr
class  SCEVAddRecExpr
class  SCEVUnknown
struct  SCEVVisitor
class  Trace
struct  ValueNumbering
class  Argument
struct  AssemblyAnnotationWriter
class  CachedWriter
class  ParseException
class  PrintModulePass
class  PrintFunctionPass
struct  ilist_traits< Instruction >
class  BasicBlock
struct  BytecodeAnalysis
 Bytecode Analysis results structure. More...
class  ArchiveMember
 This class represents a single archive member. More...
class  Archive
class  BytecodeHandler
 Handle Bytecode Parsing Events. More...
class  BytecodeFormat
class  WriteBytecodePass
struct  CallGraphSCCPass
class  AsmPrinter
class  DWLabel
class  DwarfWriter
class  ELFWriter
class  IntrinsicLowering
struct  DefaultIntrinsicLowering
struct  LiveRange
struct  LiveInterval
class  LiveIntervals
class  LiveVariables
struct  ilist_traits< MachineInstr >
class  MachineBasicBlock
struct  GraphTraits< MachineBasicBlock * >
struct  GraphTraits< const MachineBasicBlock * >
struct  GraphTraits< Inverse< MachineBasicBlock * > >
struct  GraphTraits< Inverse< const MachineBasicBlock * > >
class  MachineCodeEmitter
struct  MachineConstantPoolEntry
class  MachineConstantPool
class  DIVisitor
class  DebugInfoDesc
class  AnchorDesc
class  AnchoredDesc
class  CompileUnitDesc
class  TypeDesc
class  BasicTypeDesc
class  DerivedTypeDesc
class  CompositeTypeDesc
class  SubrangeDesc
class  EnumeratorDesc
class  VariableDesc
class  GlobalDesc
class  GlobalVariableDesc
class  SubprogramDesc
class  BlockDesc
class  DIDeserializer
class  DISerializer
class  DIVerifier
class  SourceLineInfo
class  SourceFileInfo
class  DebugVariable
class  DebugScope
class  MachineDebugInfo
class  MachineFrameInfo
struct  ilist_traits< MachineBasicBlock >
struct  MachineFunctionInfo
class  MachineFunction
struct  GraphTraits< MachineFunction * >
struct  GraphTraits< const MachineFunction * >
struct  GraphTraits< Inverse< MachineFunction * > >
struct  GraphTraits< Inverse< const MachineFunction * > >
struct  MachineFunctionPass
struct  MachineOperand
class  MachineInstr
class  MachineInstrBuilder
class  MachineLocation
class  MachineMove
class  MachineRelocation
class  SchedGraphNodeCommon
class  SchedGraphEdge
class  SchedGraphCommon
class  SGPredIterator
class  SGSuccIterator
class  HazardRecognizer
class  ScheduleDAG
class  SelectionDAG
struct  GraphTraits< SelectionDAG * >
class  SelectionDAGISel
class  SDOperand
struct  simplify_type< SDOperand >
struct  simplify_type< const SDOperand >
class  SDNode
class  HandleSDNode
class  StringSDNode
class  ConstantSDNode
class  ConstantFPSDNode
class  GlobalAddressSDNode
class  FrameIndexSDNode
class  ConstantPoolSDNode
class  BasicBlockSDNode
class  SrcValueSDNode
class  RegisterSDNode
class  ExternalSymbolSDNode
class  CondCodeSDNode
class  VTSDNode
class  SDNodeIterator
struct  GraphTraits< SDNode * >
struct  ilist_traits< SDNode >
class  SSARegMap
struct  RAV
class  Constant
class  ConstantIntegral
class  ConstantBool
class  ConstantInt
class  ConstantSInt
class  ConstantUInt
class  ConstantFP
class  ConstantAggregateZero
class  ConstantArray
class  ConstantStruct
class  ConstantPacked
class  ConstantPointerNull
class  ConstantExpr
class  UndefValue
class  Debugger
class  NonErrorException
class  InferiorProcessDead
class  InferiorProcess
struct  SourceLanguageCache
class  SourceFunctionInfo
class  ProgramInfo
class  StackFrame
class  RuntimeInfo
class  SourceFile
struct  SourceLanguage
class  DerivedType
class  FunctionType
class  CompositeType
class  StructType
class  SequentialType
class  ArrayType
class  PackedType
class  PointerType
class  OpaqueType
class  ExecutionEngineState
class  ExecutionEngine
union  GenericValue
struct  ilist_traits< BasicBlock >
struct  ilist_traits< Argument >
class  Function
class  GlobalValue
class  GlobalVariable
class  InlineAsm
class  TerminatorInst
class  UnaryInstruction
class  BinaryOperator
class  Instruction
class  AllocationInst
class  MallocInst
class  AllocaInst
class  FreeInst
class  LoadInst
class  StoreInst
class  GetElementPtrInst
class  SetCondInst
class  CastInst
class  CallInst
class  ShiftInst
class  SelectInst
class  VAArgInst
class  ExtractElementInst
class  InsertElementInst
class  ShuffleVectorInst
class  PHINode
class  ReturnInst
class  BranchInst
class  SwitchInst
class  InvokeInst
class  UnwindInst
class  UnreachableInst
class  IntrinsicInst
struct  DbgInfoIntrinsic
struct  DbgStopPointInst
struct  DbgFuncStartInst
struct  DbgRegionStartInst
struct  DbgRegionEndInst
struct  DbgDeclareInst
struct  MemIntrinsic
struct  MemCpyInst
struct  MemMoveInst
struct  MemSetInst
class  Linker
 The LLVM Linker. More...
struct  ilist_traits< Function >
struct  ilist_traits< GlobalVariable >
class  Module
class  ModuleProvider
struct  ExistingModuleProvider
class  Pass
class  ModulePass
class  ImmutablePass
class  FunctionPass
class  BasicBlockPass
class  AnalysisUsage
struct  AnalysisResolver
class  PassManager
class  FunctionPassManager
class  PassInfo
struct  RegisterPassBase
struct  RegisterPass
struct  RegisterOpt
struct  RegisterAnalysis
class  RegisterAGBase
struct  RegisterAnalysisGroup
struct  RegisterAnalysisGroup< Interface, void, false >
struct  PassRegistrationListener
struct  IncludeFile
class  AnnotationID
class  Annotation
class  Annotable
struct  AnnotationManager
class  CallSite
struct  simplify_type
struct  simplify_type< const From >
struct  isa_impl_wrap
struct  isa_impl_wrap< To, const FromTy, const FromTy >
struct  isa_impl_cl
struct  isa_impl_cl< const FromCl >
struct  isa_impl_cl< FromCl * >
struct  isa_impl_cl< FromCl & >
struct  cast_retty_impl
struct  cast_retty_impl< To, const From >
struct  cast_retty_impl< To, From * >
struct  cast_retty_impl< To, const From * >
struct  cast_retty_impl< To, const From *const >
struct  cast_retty_wrap
struct  cast_retty_wrap< To, FromTy, FromTy >
struct  cast_retty
struct  cast_convert_val
struct  cast_convert_val< To, FromTy, FromTy >
class  PredIterator
class  SuccIterator
struct  GraphTraits< BasicBlock * >
struct  GraphTraits< const BasicBlock * >
struct  GraphTraits< Inverse< BasicBlock * > >
struct  GraphTraits< Inverse< const BasicBlock * > >
struct  GraphTraits< Function * >
struct  GraphTraits< const Function * >
struct  GraphTraits< Inverse< Function * > >
struct  GraphTraits< Inverse< const Function * > >
class  Compressor
 An abstraction for memory to memory data (de)compression. More...
class  ConstantRange
struct  DefaultDOTGraphTraits
struct  DOTGraphTraits
class  FileRemover
class  generic_gep_type_iterator
class  GraphWriter
class  InstIterator
class  InstVisitor
struct  LeakDetector
class  Mangler
class  MutexGuard
 Guard a section of code with a Mutex. More...
class  PassNameParser
struct  FilteredPassNameParser
struct  PluginLoader
class  SlowOperationInformer
class  StableBasicBlockNumbering
class  Timer
class  TimeRegion
struct  NamedRegionTimer
class  TimerGroup
class  ToolExecutionError
class  GCC
class  AbstractInterpreter
class  CBE
class  LLC
struct  is_class
struct  TypeInfo
class  SymbolTable
class  SymbolTableListTraits
struct  TargetRegisterDesc
class  TargetRegisterClass
class  MRegisterInfo
struct  VirtReg2IndexFunctor
struct  SubtargetFeatureKV
struct  SubtargetInfoKV
class  SubtargetFeatures
class  TargetData
class  StructLayout
class  TargetFrameInfo
class  TargetOperandInfo
class  TargetInstrDescriptor
class  TargetInstrInfo
struct  InstrStage
struct  InstrItinerary
struct  InstrItineraryData
class  TargetJITInfo
class  TargetLowering
class  TargetMachine
struct  TargetMachineRegistry
struct  RegisterTarget
class  TargetRegistrationListener
class  TargetNameParser
struct  CPUResource
struct  InstrClassRUsage
struct  InstrRUsageDelta
struct  InstrIssueDelta
struct  InstrRUsage
class  TargetSchedInfo
class  TargetSubtarget
struct  RSProfilers
struct  ClonedCodeInfo
struct  UnifyFunctionExitNodes
class  Type
struct  GraphTraits< Type * >
struct  GraphTraits< const Type * >
class  TypeSymbolTable
class  Use
struct  simplify_type< Use >
struct  simplify_type< const Use >
class  value_use_iterator
struct  simplify_type< value_use_iterator< User > >
struct  simplify_type< const value_use_iterator< User > >
struct  simplify_type< value_use_iterator< const User > >
struct  simplify_type< const value_use_iterator< const User > >
class  User
class  Value
class  ValueSymbolTable
struct  DOTGraphTraits< const Function * >
struct  DOTGraphTraits< const DSGraph * >
struct  InlineAsmDescriptor
struct  ValID
class  ArchiveMemberHeader
 Archive File Member Header. More...
class  BytecodeReader
 Forward declare the handler interface Bytecode Reader interface. More...
class  SlotCalculator
class  SlotTable
 Abstract data type for slot numbers. More...
class  BytecodeWriter
class  BytecodeBlock
class  CompileUnit
class  DIEAbbrevData
class  DIEAbbrev
class  DIEValue
class  DIEInteger
struct  DIEString
struct  DIEDwarfLabel
struct  DIEObjectLabel
struct  DIEDelta
struct  DIEntry
struct  DIEBlock
class  DIE
class  ELFCodeEmitter
struct  DOTGraphTraits< const MachineFunction * >
class  PhysRegTracker
class  FunctionLoweringInfo
class  SelectionDAGLowering
struct  DOTGraphTraits< SelectionDAG * >
class  VirtRegMap
struct  Spiller
class  AllocaHolder
class  AllocaHolderHandle
struct  ExecutionContext
class  Interpreter
class  JITState
class  JIT
class  AlphaInstrInfo
class  AlphaTargetLowering
class  AlphaJITInfo
struct  AlphaRegisterInfo
class  AlphaSubtarget
class  AlphaTargetMachine
struct  CTargetMachine
class  IA64InstrInfo
class  IA64TargetLowering
class  IA64FunctionInfo
struct  IA64RegisterInfo
class  IA64TargetMachine
class  PPCFrameInfo
class  PPCHazardRecognizer970
class  PPCInstrInfo
class  PPCTargetLowering
class  PPCJITInfo
class  PPCRegisterInfo
class  PPCSubtarget
class  PPCTargetMachine
class  SparcInstrInfo
struct  SparcRegisterInfo
class  SparcSubtarget
class  SparcTargetMachine
class  InstrGroup
class  ScheduleIterator
class  InstrSchedule
class  DelaySlotInfo
class  SchedulingManager
struct  RefVec
struct  RegToRefVecMap
struct  ValueToDefVecMap
class  SchedGraphNode
class  SchedGraph
class  SchedGraphSet
struct  GraphTraits< SchedGraph * >
struct  GraphTraits< const SchedGraph * >
struct  NodeDelayPair
class  NodeHeap
class  SchedPriorities
class  BBLiveVar
class  FunctionLiveVarInfo
class  MachineCodeForInstruction
class  SparcV9FunctionInfo
class  CallArgInfo
class  CallArgsDescriptor
class  MappingInfo
struct  Dependence
struct  DependenceResult
class  DependenceAnalyzer
struct  DOTGraphTraits< MSchedGraph * >
struct  MSNodeAttributes
class  ModuloSchedulingPass
struct  DOTGraphTraits< MSchedGraphSB * >
struct  MSNodeSBAttributes
class  ModuloSchedulingSBPass
struct  MSchedGraphEdge
class  MSchedGraphNode
class  MSchedGraphNodeIterator
struct  GraphTraits< MSchedGraphNode * >
class  MSchedGraph
struct  GraphTraits< MSchedGraph * >
struct  GraphTraits< const MSchedGraph * >
struct  GraphTraits< Inverse< MSchedGraph * > >
struct  GraphTraits< Inverse< const MSchedGraph * > >
struct  MSchedGraphSBEdge
class  MSchedGraphSBNode
class  MSchedGraphSBNodeIterator
struct  GraphTraits< MSchedGraphSBNode * >
class  MSchedGraphSB
struct  GraphTraits< MSchedGraphSB * >
struct  GraphTraits< const MSchedGraphSB * >
struct  GraphTraits< Inverse< MSchedGraphSB * > >
struct  GraphTraits< Inverse< const MSchedGraphSB * > >
class  MSSchedule
class  MSScheduleSB
struct  AllocInfo
class  IGNode
class  InterferenceGraph
class  V9LiveRange
class  LiveRangeInfo
struct  AddedInstrns
class  PhyRegAlloc
class  RegClass
class  InstructionNode
class  VRegListNode
class  VRegNode
class  ConstantNode
class  LabelNode
class  InstrForest
struct  MaxConstantsTableTy
class  SparcV9CodeEmitter
class  SparcV9FrameInfo
class  InstrTreeNode
struct  SparcV9InstrInfo
class  SparcV9SchedInfo
class  SparcV9JITInfo
class  PeepholeOpts
struct  SparcV9IntRegClass
class  SparcV9FloatRegClass
struct  SparcV9IntCCRegClass
struct  SparcV9FloatCCRegClass
struct  SparcV9SpecialRegClass
class  TargetRegClassInfo
class  SparcV9RegInfo
struct  SparcV9RegisterInfo
class  SparcV9TargetMachine
class  TmpInstruction
struct  X86DwarfWriter
struct  X86SharedAsmPrinter
struct  X86ATTAsmPrinter
struct  X86AddressMode
class  X86InstrInfo
struct  X86IntelAsmPrinter
class  X86TargetLowering
class  X86JITInfo
struct  X86RegisterInfo
class  X86Subtarget
class  X86TargetMachine
struct  RSProfilers_std
struct  Inliner
class  ValueHandle
class  ValueMapCache
class  SlotMachine
 LLVM Assembly Writing Slot Computation. More...
class  AssemblyWriter
struct  ConstantCreator
struct  ConvertConstantType
struct  ConstantCreator< ConstantFP, Type, uint64_t >
struct  ConstantCreator< ConstantFP, Type, uint32_t >
struct  ConstantCreator< ConstantAggregateZero, Type, ValType >
struct  ConvertConstantType< ConstantAggregateZero, Type >
struct  ConvertConstantType< ConstantArray, ArrayType >
struct  ConvertConstantType< ConstantStruct, StructType >
struct  ConvertConstantType< ConstantPacked, PackedType >
struct  ConstantCreator< ConstantPointerNull, PointerType, ValType >
struct  ConvertConstantType< ConstantPointerNull, PointerType >
struct  ConstantCreator< UndefValue, Type, ValType >
struct  ConvertConstantType< UndefValue, Type >
struct  ConstantCreator< ConstantExpr, Type, ExprMapKeyType >
struct  ConvertConstantType< ConstantExpr, Type >
struct  PMDebug
class  TimingInfo
struct  BBTraits
struct  FTraits
struct  MTraits
class  PassManagerT
class  BasicBlockPassManager
class  FunctionPassManagerT
class  ModulePassManager
struct  GraphTraits< TypePromotionGraph >
class  TypeMapBase
class  TypeMap
class  FunctionValType
class  ArrayValType
class  PackedValType
class  StructValType
class  PointerValType
struct  GraphTraits< DominatorTree::Node * >
struct  simplify_type< User::op_iterator >
struct  simplify_type< const User::op_iterator >
struct  simplify_type< User::const_op_iterator >
struct  simplify_type< const User::const_op_iterator >

Namespaces

namespace  Alpha
namespace  AlphaISD
namespace  CallingConv
namespace  cl
namespace  DataStructureAnalysis
namespace  dont_use
namespace  DOT
namespace  DS
namespace  dwarf
namespace  ELF
namespace  IA64ISD
namespace  Intrinsic
namespace  ISD
namespace  MVT
namespace  PatternMatch
namespace  PPC
 Define some predicates that are used for node matching.
namespace  PPCII
namespace  PPCISD
namespace  Reloc
namespace  SparcV9
namespace  SPCC
namespace  SPII
namespace  sys
namespace  V9
namespace  X86
 Define some predicates that are used for node matching.
namespace  X86II
namespace  X86ISD

Typedefs

typedef IntervalIterator<
BasicBlock, Function
function_interval_iterator
typedef IntervalIterator<
Interval, IntervalPartition
interval_part_interval_iterator
typedef short MachineOpCode
typedef int ResourceId
typedef std::set< const Value * > ValueSet
typedef uintptr_t PointerTy
typedef const PassInfoAnalysisID
typedef PredIterator< BasicBlock,
Value::use_iterator
pred_iterator
typedef PredIterator< const
BasicBlock, Value::use_const_iterator
pred_const_iterator
typedef SuccIterator< TerminatorInst *,
BasicBlock
succ_iterator
typedef SuccIterator< const
TerminatorInst *, const BasicBlock
succ_const_iterator
typedef generic_gep_type_iterator gep_type_iterator
typedef InstIterator< iplist<
BasicBlock >, Function::iterator,
BasicBlock::iterator, Instruction
inst_iterator
typedef InstIterator< const
iplist< BasicBlock >, Function::const_iterator,
BasicBlock::const_iterator,
const Instruction
const_inst_iterator
typedef short MachineOpCode
typedef unsigned InstrSchedClass
typedef long long CycleCount_t
typedef unsigned resourceId_t
typedef generic_gep_type_iterator<
User::const_op_iterator
gep_type_iterator
typedef std::vector< GenericValueValuePlaneTy
typedef SGPredIterator< SchedGraphNode,
SchedGraphEdge, SchedGraphNode::iterator
sg_pred_iterator
typedef SGPredIterator< const
SchedGraphNode, const SchedGraphEdge,
SchedGraphNode::const_iterator
sg_pred_const_iterator
typedef SGSuccIterator< SchedGraphNode,
SchedGraphEdge, SchedGraphNode::iterator
sg_succ_iterator
typedef SGSuccIterator< const
SchedGraphNode, const SchedGraphEdge,
SchedGraphNode::const_iterator
sg_succ_const_iterator
typedef std::vector< const
MachineBasicBlock * > 
SuperBlock
typedef hash_map< const Value *,
V9LiveRange * > 
LiveRangeMapType
typedef std::map< const Value *,
const Type * > 
ValueTypeCache
typedef std::map< const Value *,
Value * > 
ValueMapTy

Enumerations

enum  SCEVTypes {
  scConstant, scTruncate, scZeroExtend, scAddExpr,
  scMulExpr, scSDivExpr, scAddRecExpr, scUnknown,
  scCouldNotCompute
}
enum  VerifierFailureAction { AbortProcessAction, ThrowExceptionAction, PrintMessageAction, ReturnStatusAction }
 An enumeration to specify the action to be taken if errors found. More...
enum  { LLVMDebugVersion = 3 }
enum  PPCTargetEnum { TargetDefault, TargetAIX, TargetDarwin }
enum  SchedDebugLevel_t {
  Sched_NoDebugInfo, Sched_Disable, Sched_PrintMachineCode, Sched_PrintSchedTrace,
  Sched_PrintSchedGraphs
}
enum  LiveVarDebugLevel_t { LV_DEBUG_None, LV_DEBUG_Normal, LV_DEBUG_Instr, LV_DEBUG_Verbose }
enum  RegAllocDebugLevel_t {
  RA_DEBUG_None = 0, RA_DEBUG_Results = 1, RA_DEBUG_Coloring = 2, RA_DEBUG_Interference = 3,
  RA_DEBUG_LiveRanges = 4, RA_DEBUG_Verbose = 5
}
enum  SparcV9InstrSchedClass {
  SPARC_NONE, SPARC_IEUN, SPARC_IEU0, SPARC_IEU1,
  SPARC_FPM, SPARC_FPA, SPARC_CTI, SPARC_LD,
  SPARC_ST, SPARC_SINGLE, SPARC_INV, SPARC_NUM_SCHED_CLASSES = SPARC_INV
}
enum  { BadRegClass = ~0 }
enum  PassDebugLevel {
  None, Arguments, Structure, Executions,
  Details
}

Functions

std::ostream & operator<< (std::ostream &O, const BitSetVector &bset)
bool Disjoint (const BitSetVector &set1, const BitSetVector &set2)
template<class T>
df_iterator< Tdf_begin (T G)
template<class T>
df_iterator< Tdf_end (T G)
template<class T, class SetTy>
df_ext_iterator< T, SetTydf_ext_begin (T G, SetTy &S)
template<class T, class SetTy>
df_ext_iterator< T, SetTydf_ext_end (T G, SetTy &S)
template<class T>
idf_iterator< Tidf_begin (T G)
template<class T>
idf_iterator< Tidf_end (T G)
template<class T, class SetTy>
idf_ext_iterator< T, SetTyidf_ext_begin (T G, SetTy &S)
template<class T, class SetTy>
idf_ext_iterator< T, SetTyidf_ext_end (T G, SetTy &S)
template<class T>
po_iterator< Tpo_begin (T G)
template<class T>
po_iterator< Tpo_end (T G)
template<class T, class SetType>
po_ext_iterator< T, SetType > po_ext_begin (T G, SetType &S)
template<class T, class SetType>
po_ext_iterator< T, SetType > po_ext_end (T G, SetType &S)
template<class T>
ipo_iterator< Tipo_begin (T G, bool Reverse=false)
template<class T>
ipo_iterator< Tipo_end (T G)
template<class T, class SetType>
ipo_ext_iterator< T, SetType > ipo_ext_begin (T G, SetType &S)
template<class T, class SetType>
ipo_ext_iterator< T, SetType > ipo_ext_end (T G, SetType &S)
template<class T>
scc_iterator< Tscc_begin (T G)
template<class T>
scc_iterator< Tscc_end (T G)
template<class S1Ty, class S2Ty>
bool set_union (S1Ty &S1, const S2Ty &S2)
template<class S1Ty, class S2Ty>
void set_intersect (S1Ty &S1, const S2Ty &S2)
template<class S1Ty, class S2Ty>
S1Ty set_difference (const S1Ty &S1, const S2Ty &S2)
template<class S1Ty, class S2Ty>
void set_subtract (S1Ty &S1, const S2Ty &S2)
template<class T>
static void deleter (T *Ptr)
template<class _Iterator, class Func>
mapped_iterator< _Iterator,
Func
operator+ (typename mapped_iterator< _Iterator, Func >::difference_type N, const mapped_iterator< _Iterator, Func > &X)
template<class ItTy, class FuncTy>
mapped_iterator< ItTy, FuncTy > map_iterator (const ItTy &I, FuncTy F)
template<typename ItTy, typename Dist>
ItTy next (ItTy it, Dist n)
template<typename ItTy>
ItTy next (ItTy it)
template<typename ItTy, typename Dist>
ItTy prior (ItTy it, Dist n)
template<typename ItTy>
ItTy prior (ItTy it)
template<typename T1, typename T2>
tier< T1, T2 > tie (T1 &f, T2 &s)
static std::string utohexstr (uint64_t X)
static std::string utostr (unsigned long long X, bool isNeg=false)
static std::string utostr (unsigned long X, bool isNeg=false)
static std::string utostr (unsigned X, bool isNeg=false)
static std::string itostr (long long X)
static std::string itostr (long X)
static std::string itostr (int X)
static std::string ftostr (double V)
static std::string LowercaseString (const std::string &S)
static bool StringsEqualNoCase (const std::string &LHS, const std::string &RHS)
static bool StringsEqualNoCase (const std::string &LHS, const char *RHS)
std::string getToken (std::string &Source, const char *Delimiters=" \t\n\v\f\r")
template<typename T>
std::vector< Tmake_vector (T A,...)
void BasicAAStub ()
static IncludeFile HDR_INCLUDE_BASICAA_CPP ((void *)&BasicAAStub)
std::ostream & operator<< (std::ostream &OS, const AliasSet &AS)
std::ostream & operator<< (std::ostream &OS, const AliasSetTracker &AST)
void BasicCallGraphStub ()
static IncludeFile HDR_INCLUDE_CALLGRAPH_CPP ((void *)&BasicCallGraphStub)
FunctionPasscreateCFGPrinterPass ()
FunctionPasscreateCFGOnlyPrinterPass ()
bool canConstantFoldCallTo (Function *F)
ConstantConstantFoldFP (double(*NativeFP)(double), double V, const Type *Ty)
ConstantConstantFoldCall (Function *F, const std::vector< Constant * > &Operands)
constant_iterator constant_begin (const Function *F)
constant_iterator constant_end (const Function *F)
FunctionPasscreateDataStructureStatsPass ()
FunctionPasscreateDataStructureGraphCheckerPass ()
static DSNodedereference (DSNode *N)
static const DSNodedereferenceC (const DSNode *N)
Interval::succ_iterator succ_begin (Interval *I)
Interval::succ_iterator succ_end (Interval *I)
Interval::pred_iterator pred_begin (Interval *I)
Interval::pred_iterator pred_end (Interval *I)
BasicBlockgetNodeHeader (BasicBlock *BB)
BasicBlockgetNodeHeader (Interval *I)
BasicBlockgetSourceGraphNode (Function *, BasicBlock *BB)
IntervalgetSourceGraphNode (IntervalPartition *IP, BasicBlock *BB)
void addNodeToInterval (Interval *Int, BasicBlock *BB)
void addNodeToInterval (Interval *Int, Interval *I)
function_interval_iterator intervals_begin (Function *F, bool DeleteInts=true)
function_interval_iterator intervals_end (Function *)
interval_part_interval_iterator intervals_begin (IntervalPartition &IP, bool DeleteIntervals=true)
interval_part_interval_iterator intervals_end (IntervalPartition &IP)
FunctionPasscreateLoadValueNumberingPass ()
PasscreateGlobalsModRefPass ()
ModulePasscreateAliasAnalysisCounterPass ()
FunctionPasscreateAAEvalPass ()
ImmutablePasscreateNoAAPass ()
ImmutablePasscreateBasicAliasAnalysisPass ()
ModulePasscreateAndersensPass ()
ImmutablePasscreateBasicVNPass ()
ModulePasscreateProfileLoaderPass ()
ImmutablePasscreateNoProfileInfoPass ()
ModulePasscreateDSAAPass ()
ModulePasscreateDSOptPass ()
ModulePasscreateSteensgaardPass ()
FunctionPasscreateInstCountPass ()
PasscreateProfileLoaderPass (const std::string &Filename)
std::ostream & operator<< (std::ostream &OS, const SCEV &S)
void BasicValueNumberingStub ()
static IncludeFile HDR_INCLUDE_VALUENUMBERING_CPP ((void *)&BasicValueNumberingStub)
FunctionPasscreateVerifierPass (VerifierFailureAction action=AbortProcessAction)
 Create a verifier pass.
bool verifyModule (const Module &M, VerifierFailureAction action=AbortProcessAction)
 Check a module for errors.
bool verifyFunction (const Function &F, VerifierFailureAction action=AbortProcessAction)
FunctionUpgradeIntrinsicFunction (Function *F)
 Remove overloaded intrinsic function names.
void UpgradeIntrinsicCall (CallInst *CI, Function *newF=0)
 Get replacement instruction for overloaded intrinsic function call.
bool UpgradeCallsToIntrinsic (Function *F)
ModuleParseAssemblyFile (const std::string &Filename)
ModuleParseAssemblyString (const char *AsmString, Module *M)
std::ostream & WriteTypeSymbolic (std::ostream &, const Type *, const Module *M)
std::ostream & WriteAsOperand (std::ostream &, const Value *, bool PrintTy=true, bool PrintName=true, const Module *Context=0)
std::ostream & WriteAsOperand (std::ostream &, const Type *, bool PrintTy=true, bool PrintName=true, const Module *Context=0)
ModuleAnalyzeBytecodeFile (const std::string &Filename, BytecodeAnalysis &Results, std::string *ErrorStr=0, std::ostream *output=0)
 Analyze contents of a bytecode File.
ModuleAnalyzeBytecodeBuffer (const unsigned char *Buffer, unsigned BufferSize, const std::string &ModuleID, BytecodeAnalysis &Results, std::string *ErrorStr=0, std::ostream *output=0)
 Analyze contents of a bytecode buffer.
void PrintBytecodeAnalysis (BytecodeAnalysis &bca, std::ostream &Out)
 Print BytecodeAnalysis structure to an ostream.
std::ostream & operator<< (std::ostream &Out, BytecodeAnalysis &bca)
 std::ostream inserter for BytecodeAnalysis structure
ModuleProvidergetBytecodeModuleProvider (const std::string &Filename, BytecodeHandler *H=0)
ModuleProvidergetBytecodeBufferModuleProvider (const unsigned char *Buffer, unsigned BufferSize, const std::string &ModuleID="", BytecodeHandler *H=0)
ModuleParseBytecodeFile (const std::string &Filename, std::string *ErrorStr=0)
 Parse the given bytecode file.
ModuleParseBytecodeBuffer (const unsigned char *Buffer, unsigned BufferSize, const std::string &ModuleID="", std::string *ErrorStr=0)
 Parse a given bytecode buffer.
bool GetBytecodeDependentLibraries (const std::string &fileName, Module::LibraryListType &deplibs)
 Get the list of dependent libraries from a bytecode file.
bool GetBytecodeSymbols (const sys::Path &fileName, std::vector< std::string > &syms)
 Get a bytecode file's externally visibile defined global symbols.
ModuleProviderGetBytecodeSymbols (const unsigned char *Buffer, unsigned Length, const std::string &ModuleID, std::vector< std::string > &symbols)
 Get a bytecode file's externally visibile defined global symbols.
void WriteBytecodeToFile (const Module *M, std::ostream &Out, bool compress=true)
FunctionPasscreateInstructionSchedulingWithSSAPass (const TargetMachine &TM)
std::ostream & operator<< (std::ostream &os, const LiveRange &LR)
bool operator< (unsigned V, const LiveRange &LR)
bool operator< (const LiveRange &LR, unsigned V)
std::ostream & operator<< (std::ostream &OS, const LiveInterval &LI)
std::ostream & operator<< (std::ostream &OS, const MachineInstr &MI)
std::ostream & operator<< (std::ostream &OS, const MachineOperand &MO)
void PrintMachineInstructions (const Function *F)
MachineInstrBuilder BuildMI (int Opcode, unsigned NumOperands)
MachineInstrBuilder BuildMI (int Opcode, unsigned NumOperands, unsigned DestReg, MachineOperand::UseType useType=MachineOperand::Def)
MachineInstrBuilder BuildMI (MachineBasicBlock &BB, MachineBasicBlock::iterator I, int Opcode, unsigned NumOperands, unsigned DestReg)
MachineInstrBuilder BuildMI (MachineBasicBlock &BB, MachineBasicBlock::iterator I, int Opcode, unsigned NumOperands)
MachineInstrBuilder BuildMI (MachineBasicBlock *BB, int Opcode, unsigned NumOperands)
MachineInstrBuilder BuildMI (MachineBasicBlock *BB, int Opcode, unsigned NumOperands, unsigned DestReg)
FunctionPasscreateUnreachableBlockEliminationPass ()
FunctionPasscreateMachineFunctionPrinterPass (std::ostream *OS, const std::string &Banner="")
FunctionPasscreateRegisterAllocator ()
FunctionPasscreateSimpleRegisterAllocator ()
FunctionPasscreateLocalRegisterAllocator ()
FunctionPasscreateLinearScanRegisterAllocator ()
FunctionPasscreatePrologEpilogCodeInserter ()
FunctionPasscreateBranchFoldingPass ()
FunctionPasscreateMachineCodeDeleter ()
FunctionPassgetRegisterAllocator (TargetMachine &T)
FunctionPasscreateModuloSchedulingPass (TargetMachine &targ)
FunctionPasscreateModuloSchedulingSBPass (TargetMachine &targ)
std::ostream & operator<< (std::ostream &os, const SchedGraphNodeCommon &node)
std::ostream & operator<< (std::ostream &os, const SchedGraphEdge &edge)
ScheduleDAGcreateBFS_DAGScheduler (SelectionDAG &DAG, MachineBasicBlock *BB)
ScheduleDAGcreateSimpleDAGScheduler (bool NoItins, SelectionDAG &DAG, MachineBasicBlock *BB)
ScheduleDAGcreateBURRListDAGScheduler (SelectionDAG &DAG, MachineBasicBlock *BB)
ScheduleDAGcreateTDListDAGScheduler (SelectionDAG &DAG, MachineBasicBlock *BB, HazardRecognizer *HR)
std::ostream & operator<< (std::ostream &out, RAV Val)
void printSet (const ValueSet &S)
GenericValue PTOGV (void *P)
void * GVTOP (const GenericValue &GV)
void LinkInInterpreter ()
void LinkInJIT ()
std::ostream & operator<< (std::ostream &O, const Module &M)
std::ostream & operator<< (std::ostream &OS, const Pass &P)
template<typename PassName>
PasscallDefaultCtor ()
template<typename To, typename From>
bool isa_impl (const From &Val)
template<class X, class Y>
bool isa (const Y &Val)
template<class X, class Y>
cast_retty< X, Y >::ret_type cast (const Y &Val)
template<class X, class Y>
cast_retty< X, Y * >::ret_type cast_or_null (Y *Val)
template<class X, class Y>
cast_retty< X, Y >::ret_type dyn_cast (Y Val)
template<class X, class Y>
cast_retty< X, Y >::ret_type dyn_cast_or_null (Y Val)
pred_iterator pred_begin (BasicBlock *BB)
pred_const_iterator pred_begin (const BasicBlock *BB)
pred_iterator pred_end (BasicBlock *BB)
pred_const_iterator pred_end (const BasicBlock *BB)
succ_iterator succ_begin (BasicBlock *BB)
succ_const_iterator succ_begin (const BasicBlock *BB)
succ_iterator succ_end (BasicBlock *BB)
succ_const_iterator succ_end (const BasicBlock *BB)
std::ostream & operator<< (std::ostream &OS, const ConstantRange &CR)
bool isCurrentDebugType (const char *Type)
bool LinkDynamicObject (const char *filename, std::string *ErrorMessage)
void * GetAddressOfSymbol (const char *symbolName)
void * GetAddressOfSymbol (const std::string &symbolName)
int DiffFilesWithTolerance (const sys::Path &FileA, const sys::Path &FileB, double AbsTol, double RelTol, std::string *Error=0)
gep_type_iterator gep_type_begin (const User *GEP)
gep_type_iterator gep_type_end (const User *GEP)
gep_type_iterator gep_type_begin (const User &GEP)
gep_type_iterator gep_type_end (const User &GEP)
template<typename ItTy>
generic_gep_type_iterator<
ItTy > 
gep_type_begin (const Type *Op0, ItTy I, ItTy E)
template<typename ItTy>
generic_gep_type_iterator<
ItTy > 
gep_type_end (const Type *Op0, ItTy I, ItTy E)
template<typename GraphType>
std::ostream & WriteGraph (std::ostream &O, const GraphType &G, const std::string &Name="")
inst_iterator inst_begin (Function *F)
inst_iterator inst_end (Function *F)
const_inst_iterator inst_begin (const Function *F)
const_inst_iterator inst_end (const Function *F)
inst_iterator inst_begin (Function &F)
inst_iterator inst_end (Function &F)
const_inst_iterator inst_begin (const Function &F)
const_inst_iterator inst_end (const Function &F)
 HANDLE_MEMORY_INST (21, Malloc, MallocInst) HANDLE_MEMORY_INST(23
AllocaInst PHINode HANDLE_OTHER_INST (28, Cast, CastInst) HANDLE_OTHER_INST(29
AllocaInst PHINode CallInst HANDLE_OTHER_INST (30, Shl, ShiftInst) HANDLE_OTHER_INST(34
AllocaInst PHINode CallInst
SelectInst 
HANDLE_OTHER_INST (35, UserOp1, Instruction) HANDLE_OTHER_INST(37
AllocaInst PHINode CallInst
SelectInst VAArgInst 
HANDLE_OTHER_INST (38, ExtractElement, ExtractElementInst) HANDLE_OTHER_INST(39
AllocaInst PHINode CallInst
SelectInst VAArgInst InsertElementInst 
HANDLE_OTHER_INST (40, ShuffleVector, ShuffleVectorInst) class TerminatorInst
unsigned Hi_32 (uint64_t Value)
unsigned Lo_32 (uint64_t Value)
bool isInt8 (int Value)
bool isUInt8 (int Value)
bool isInt16 (int Value)
bool isUInt16 (int Value)
bool isInt32 (int64_t Value)
bool isUInt32 (int64_t Value)
const bool isMask_32 (unsigned Value)
const bool isMask_64 (uint64_t Value)
const bool isShiftedMask_32 (unsigned Value)
const bool isShiftedMask_64 (uint64_t Value)
bool isPowerOf2_32 (unsigned Value)
bool isPowerOf2_64 (uint64_t Value)
unsigned short ByteSwap_16 (unsigned short Value)
unsigned ByteSwap_32 (unsigned Value)
uint64_t ByteSwap_64 (uint64_t Value)
unsigned CountLeadingZeros_32 (unsigned Value)
unsigned CountLeadingZeros_64 (uint64_t Value)
unsigned CountTrailingZeros_32 (unsigned Value)
unsigned CountTrailingZeros_64 (uint64_t Value)
unsigned CountPopulation_32 (unsigned Value)
unsigned CountPopulation_64 (uint64_t Value)
unsigned Log2_32 (unsigned Value)
unsigned Log2_64 (uint64_t Value)
double BitsToDouble (uint64_t Bits)
float BitsToFloat (uint32_t Bits)
uint64_t DoubleToBits (double Double)
uint32_t FloatToBits (float Float)
int IsNAN (float f)
int IsNAN (double d)
int IsInf (float f)
int IsInf (double d)
bool CheckBytecodeOutputToConsole (std::ostream *stream_to_check, bool print_warning=true)
 Check for output written to a console.
sys::Path FindExecutable (const std::string &ExeName, const std::string &ProgramPath)
 Find a named executable.
bool operator== (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator< (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator!= (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator> (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator<= (const TypeInfo &lhs, const TypeInfo &rhs)
bool operator>= (const TypeInfo &lhs, const TypeInfo &rhs)
std::ostream & operator<< (std::ostream &strm, const sys::Path &aPath)
FunctionPasscreateLoopInstrumentationPass ()
FunctionPasscreateCombineBranchesPass ()
ModulePasscreateEmitFunctionTablePass ()
ModulePasscreateFunctionProfilerPass ()
ModulePasscreateBlockProfilerPass ()
ModulePasscreateEdgeProfilerPass ()
ModulePasscreateTraceBasicBlockPass ()
FunctionPasscreateProfilePathsPass ()
ModulePasscreateNullProfilerRSPass ()
FunctionPasscreateRSProfilingPass ()
FunctionPasscreateTraceValuesPassForBasicBlocks ()
 Trace BB's and functions.
FunctionPasscreateTraceValuesPassForFunction ()
 Just trace functions.
ModulePasscreateStripSymbolsPass (bool OnlyDebugInfo=false)
ModulePasscreateLowerSetJmpPass ()
ModulePasscreateConstantMergePass ()
ModulePasscreateGlobalOptimizerPass ()
ModulePasscreateRaiseAllocationsPass ()
ModulePasscreateDeadTypeEliminationPass ()
ModulePasscreateGlobalDCEPass ()
ModulePasscreateFunctionExtractionPass (Function *F, bool deleteFn=false)
ModulePasscreateFunctionResolvingPass ()
ModulePasscreateFunctionInliningPass ()
ModulePasscreatePruneEHPass ()
ModulePasscreateInternalizePass (bool InternalizeEverything)
ModulePasscreateDeadArgEliminationPass ()
ModulePasscreateDeadArgHackingPass ()
ModulePasscreateArgumentPromotionPass ()
ModulePasscreateIPConstantPropagationPass ()
ModulePasscreateIPSCCPPass ()
FunctionPasscreateLoopExtractorPass ()
FunctionPasscreateSingleLoopExtractorPass ()
ModulePasscreateBlockExtractorPass (std::vector< BasicBlock * > &BTNE)
ModulePasscreateSimplifyLibCallsPass ()
ModulePasscreateIndMemRemPass ()
FunctionPasscreateRaisePointerReferencesPass ()
FunctionPasscreateConstantPropagationPass ()
FunctionPasscreateSCCPPass ()
FunctionPasscreateDeadInstEliminationPass ()
FunctionPasscreateDeadCodeEliminationPass ()
FunctionPasscreateDeadStoreEliminationPass ()
FunctionPasscreateAggressiveDCEPass ()
FunctionPasscreateScalarReplAggregatesPass ()
FunctionPasscreateGCSEPass ()
FunctionPasscreateIndVarSimplifyPass ()
FunctionPasscreateInstructionCombiningPass ()
FunctionPasscreateLICMPass ()
FunctionPasscreateLoopStrengthReducePass (const TargetLowering *TLI=NULL)
FunctionPasscreateLoopUnswitchPass ()
FunctionPasscreateLoopUnrollPass ()
FunctionPasscreatePromoteMemoryToRegisterPass ()
FunctionPasscreateDemoteRegisterToMemoryPass ()
FunctionPasscreateReassociatePass ()
FunctionPasscreateCorrelatedExpressionEliminationPass ()
FunctionPasscreateCondPropagationPass ()
FunctionPasscreateTailDuplicationPass ()
FunctionPasscreateCFGSimplificationPass ()
FunctionPasscreateBreakCriticalEdgesPass ()
FunctionPasscreateLoopSimplifyPass ()
FunctionPasscreateTailCallEliminationPass ()
FunctionPasscreateLowerAllocationsPass (bool LowerMallocArgToInteger=false)
FunctionPasscreateLowerSwitchPass ()
FunctionPasscreateLowerSelectPass (bool OnlyFP=false)
FunctionPasscreateLowerPackedPass ()
FunctionPasscreateLowerInvokePass (unsigned JumBufSize=200, unsigned JumpBufAlign=0)
FunctionPasscreateLowerGCPass ()
FunctionPasscreateBlockPlacementPass ()
FunctionPasscreatePREPass ()
void ReplaceInstWithValue (BasicBlock::InstListType &BIL, BasicBlock::iterator &BI, Value *V)
void ReplaceInstWithInst (BasicBlock::InstListType &BIL, BasicBlock::iterator &BI, Instruction *I)
void ReplaceInstWithInst (Instruction *From, Instruction *To)
void RemoveSuccessor (TerminatorInst *TI, unsigned SuccNum)
bool isCriticalEdge (const TerminatorInst *TI, unsigned SuccNum)
bool SplitCriticalEdge (TerminatorInst *TI, unsigned SuccNum, Pass *P=0)
bool SplitCriticalEdge (BasicBlock *BB, succ_iterator SI, Pass *P=0)
bool SplitCriticalEdge (BasicBlock *Succ, pred_iterator PI, Pass *P=0)
bool SplitCriticalEdge (BasicBlock *Src, BasicBlock *Dst, Pass *P=0)
ModuleCloneModule (const Module *M)
BasicBlockCloneBasicBlock (const BasicBlock *BB, std::map< const Value *, Value * > &ValueMap, const char *NameSuffix="", Function *F=0, ClonedCodeInfo *CodeInfo=0)
FunctionCloneFunction (const Function *F, std::map< const Value *, Value * > &ValueMap, ClonedCodeInfo *CodeInfo=0)
FunctionCloneFunction (const Function *F, ClonedCodeInfo *CodeInfo=0)
void CloneFunctionInto (Function *NewFunc, const Function *OldFunc, std::map< const Value *, Value * > &ValueMap, std::vector< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=0)
void CloneTraceInto (Function *NewFunc, Trace &T, std::map< const Value *, Value * > &ValueMap, const char *NameSuffix)
std::vector< BasicBlock * > CloneTrace (const std::vector< BasicBlock * > &origTrace)
bool InlineFunction (CallInst *C, CallGraph *CG=0)
bool InlineFunction (InvokeInst *II, CallGraph *CG=0)
bool InlineFunction (CallSite CS, CallGraph *CG=0)
FunctionExtractCodeRegion (DominatorSet &DS, const std::vector< BasicBlock * > &code, bool AggregateArgs=false)
FunctionExtractLoop (DominatorSet &DS, Loop *L, bool AggregateArgs=false)
FunctionExtractBasicBlock (BasicBlock *BB, bool AggregateArgs=false)
bool doConstantPropagation (BasicBlock::iterator &I)
bool ConstantFoldTerminator (BasicBlock *BB)
ConstantConstantFoldInstruction (Instruction *I)
ConstantConstantFoldLoadThroughGEPConstantExpr (Constant *C, ConstantExpr *CE)
bool isInstructionTriviallyDead (Instruction *I)
bool dceInstruction (BasicBlock::iterator &BBI)
bool SimplifyCFG (BasicBlock *BB)
AllocaInstDemoteRegToStack (Instruction &X, bool VolatileLoads=false)
bool isAllocaPromotable (const AllocaInst *AI, const TargetData &TD)
void PromoteMemToReg (const std::vector< AllocaInst * > &Allocas, DominatorTree &DT, DominanceFrontier &DF, const TargetData &TD, AliasSetTracker *AST=0)
PasscreateUnifyFunctionExitNodesPass ()
template<>
bool isa_impl< PointerType, Type > (const Type &Ty)
std::ostream & operator<< (std::ostream &OS, const Type &T)
std::ostream & operator<< (std::ostream &OS, const Value &V)
template<>
bool isa_impl< Constant, Value > (const Value &Val)
template<>
bool isa_impl< Argument, Value > (const Value &Val)
template<>
bool isa_impl< InlineAsm, Value > (const Value &Val)
template<>
bool isa_impl< Instruction, Value > (const Value &Val)
template<>
bool isa_impl< BasicBlock, Value > (const Value &Val)
template<>
bool isa_impl< Function, Value > (const Value &Val)
template<>
bool isa_impl< GlobalVariable, Value > (const Value &Val)
template<>
bool isa_impl< GlobalValue, Value > (const Value &Val)
ModulePasscreateAliasAnalysisCounterPass ()
FunctionPasscreateAAEvalPass ()
void BasicAAStub ()
ImmutablePasscreateNoAAPass ()
ImmutablePasscreateBasicAliasAnalysisPass ()
FunctionPasscreateCFGPrinterPass ()
FunctionPasscreateCFGOnlyPrinterPass ()
bool canConstantFoldCallTo (Function *F)
ConstantConstantFoldFP (double(*NativeFP)(double), double V, const Type *Ty)
ConstantConstantFoldCall (Function *F, const std::vector< Constant * > &Operands)
ModulePasscreateDSAAPass ()
ModulePasscreateDSOptPass ()
FunctionPasscreateDataStructureStatsPass ()
FunctionPasscreateDataStructureGraphCheckerPass ()
ModulePasscreateSteensgaardPass ()
FunctionPasscreateInstCountPass ()
ModulePasscreateAndersensPass ()
void BasicCallGraphStub ()
PasscreateGlobalsModRefPass ()
FunctionPasscreateLoadValueNumberingPass ()
ImmutablePasscreateNoProfileInfoPass ()
ModulePasscreateProfileLoaderPass ()
PasscreateProfileLoaderPass (const std::string &Filename)
ImmutablePasscreateBasicVNPass ()
void BasicValueNumberingStub ()
static uint64_t atoull (const char *Buffer)
static uint64_t HexIntToVal (const char *Buffer)
static double HexToFP (const char *Buffer)
char * UnEscapeLexed (char *Buffer, bool AllowNull)
ModuleRunVMAsmParser (const std::string &Filename, FILE *F)
ModuleRunVMAsmParser (const char *AsmString, Module *M)
ModuleParseAssemblyFile (const std::string &Filename)
ModuleParseAssemblyString (const char *AsmString, Module *M)
static void ThrowException (const std::string &message, int LineNo=-1)
BytecodeHandlercreateBytecodeAnalyzerHandler (BytecodeAnalysis &bca, std::ostream *output)
 A function for creating a BytecodeAnalzer as a handler for the Bytecode reader.
ModuleProvidergetBytecodeBufferModuleProvider (const unsigned char *Buffer, unsigned Length, const std::string &ModuleID, BytecodeHandler *H)
ModuleParseBytecodeBuffer (const unsigned char *Buffer, unsigned Length, const std::string &ModuleID, std::string *ErrorStr)
 Parse a given bytecode buffer.
ModuleProvidergetBytecodeModuleProvider (const std::string &Filename, BytecodeHandler *H)
ModuleParseBytecodeFile (const std::string &Filename, std::string *ErrorStr)
 Parse the given bytecode file.
ModuleAnalyzeBytecodeFile (const std::string &Filename, BytecodeAnalysis &bca, std::string *ErrorStr, std::ostream *output)
 Analyze contents of a bytecode File.
ModuleAnalyzeBytecodeBuffer (const unsigned char *Buffer, unsigned Length, const std::string &ModuleID, BytecodeAnalysis &bca, std::string *ErrorStr, std::ostream *output)
 Analyze contents of a bytecode buffer.
bool GetBytecodeDependentLibraries (const std::string &fname, Module::LibraryListType &deplibs)
 Get the list of dependent libraries from a bytecode file.
bool GetBytecodeSymbols (const sys::Path &fName, std::vector< std::string > &symbols)
 Get a bytecode file's externally visibile defined global symbols.
ModuleProviderGetBytecodeSymbols (const unsigned char *Buffer, unsigned Length, const std::string &ModuleID, std::vector< std::string > &symbols)
 Get a bytecode file's externally visibile defined global symbols.
void WriteBytecodeToFile (const Module *M, std::ostream &Out, bool compress)
FunctionPasscreateBranchFoldingPass ()
std::ostream & operator<< (std::ostream &os, const LiveRange &LR)
FunctionPasscreateMachineFunctionPrinterPass (std::ostream *OS, const std::string &Banner)
FunctionPasscreateMachineCodeDeleter ()
FunctionPasscreateRegisterAllocator ()
FunctionPasscreatePrologEpilogCodeInserter ()
FunctionPasscreateLinearScanRegisterAllocator ()
FunctionPasscreateLocalRegisterAllocator ()
FunctionPasscreateSimpleRegisterAllocator ()
llvm::ScheduleDAGcreateBURRListDAGScheduler (SelectionDAG &DAG, MachineBasicBlock *BB)
ScheduleDAGcreateTDListDAGScheduler (SelectionDAG &DAG, MachineBasicBlock *BB, HazardRecognizer *HR)
llvm::ScheduleDAGcreateSimpleDAGScheduler (bool NoItins, SelectionDAG &DAG, MachineBasicBlock *BB)
llvm::ScheduleDAGcreateBFS_DAGScheduler (SelectionDAG &DAG, MachineBasicBlock *BB)
FunctionPasscreateUnreachableBlockEliminationPass ()
llvm::SpillercreateSpiller ()
std::ostream & operator<< (std::ostream &OS, const VirtRegMap &VRM)
bool isCurrentDebugType (const char *DebugType)
int DiffFilesWithTolerance (const sys::Path &FileA, const sys::Path &FileB, double AbsTol, double RelTol, std::string *Error)
std::ostream * GetLibSupportInfoOutputFile ()
std::string getToken (std::string &Source, const char *Delimiters)
bool CheckBytecodeOutputToConsole (std::ostream *stream_to_check, bool print_warning)
 Check for output written to a console.
sys::Path FindExecutable (const std::string &ExeName, const std::string &ProgramPath)
 Find a named executable.
std::ostream * GetLibSupportInfoOutputFile ()
FunctionPasscreateAlphaSimpleInstructionSelector (TargetMachine &TM)
FunctionPasscreateAlphaISelDag (TargetMachine &TM)
FunctionPasscreateAlphaCodePrinterPass (std::ostream &OS, TargetMachine &TM)
FunctionPasscreateAlphaPatternInstructionSelector (TargetMachine &TM)
FunctionPasscreateAlphaCodeEmitterPass (MachineCodeEmitter &MCE)
FunctionPasscreateAlphaCodePrinterPass (std::ostream &o, TargetMachine &tm)
FunctionPasscreateAlphaCodeEmitterPass (MachineCodeEmitter &MCE)
FunctionPasscreateAlphaISelDag (TargetMachine &TM)
FunctionPasscreateIA64DAGToDAGInstructionSelector (IA64TargetMachine &TM)
FunctionPasscreateIA64BundlingPass (IA64TargetMachine &TM)
FunctionPasscreateIA64CodePrinterPass (std::ostream &o, IA64TargetMachine &tm)
FunctionPasscreateIA64CodePrinterPass (std::ostream &o, IA64TargetMachine &tm)
FunctionPasscreateIA64BundlingPass (IA64TargetMachine &tm)
const MachineInstrBuilderaddFrameReference (const MachineInstrBuilder &MIB, int FI, int Offset=0, bool mem=true)
const MachineInstrBuilderaddConstantPoolReference (const MachineInstrBuilder &MIB, unsigned CPI, int Offset=0)
FunctionPasscreateIA64DAGToDAGInstructionSelector (IA64TargetMachine &TM)
FunctionPasscreatePPCBranchSelectionPass ()
FunctionPasscreatePPCISelDag (PPCTargetMachine &TM)
FunctionPasscreateDarwinAsmPrinter (std::ostream &OS, PPCTargetMachine &TM)
FunctionPasscreateAIXAsmPrinter (std::ostream &OS, PPCTargetMachine &TM)
FunctionPasscreateDarwinAsmPrinter (std::ostream &o, PPCTargetMachine &tm)
FunctionPasscreateAIXAsmPrinter (std::ostream &o, PPCTargetMachine &tm)
FunctionPasscreatePPCBranchSelectionPass ()
FunctionPasscreatePPCISelDag (PPCTargetMachine &TM)
cl::opt< PPCTargetEnum, true > PPCTargetArg (cl::desc("Force generation of code for a specific PPC target:"), cl::values(clEnumValN(TargetAIX,"aix"," Enable AIX codegen"), clEnumValN(TargetDarwin,"darwin"," Enable Darwin codegen"), clEnumValEnd), cl::location(PPCTarget), cl::init(TargetDefault))
FunctionPasscreateSparcDelaySlotFillerPass (TargetMachine &tm)
FunctionPasscreateSparcFPMoverPass (TargetMachine &tm)
FunctionPasscreateSparcISelDag (TargetMachine &TM)
FunctionPasscreateSparcCodePrinterPass (std::ostream &OS, TargetMachine &TM)
static const char * SPARCCondCodeToString (SPCC::CondCodes CC)
FunctionPasscreateSparcCodePrinterPass (std::ostream &o, TargetMachine &tm)
FunctionPasscreateSparcISelDag (TargetMachine &TM)
FunctionPasscreateDecomposeMultiDimRefsPass ()
bool DecomposeArrayRef (GetElementPtrInst *GEP)
ModulePasscreateBytecodeAsmPrinterPass (std::ostream &Out)
static void AssignInstructionsToSlots (class SchedulingManager &S, unsigned maxIssue)
static void RecordSchedule (MachineBasicBlock &MBB, const SchedulingManager &S)
static void MarkSuccessorsReady (SchedulingManager &S, const SchedGraphNode *node)
static unsigned FindSlotChoices (SchedulingManager &S, DelaySlotInfo *&getDelaySlotInfo)
static unsigned ChooseOneGroup (SchedulingManager &S)
static void ForwardListSchedule (SchedulingManager &S)
static bool NodeCanFillDelaySlot (const SchedulingManager &S, const SchedGraphNode *node, const SchedGraphNode *brNode, bool nodeIsPredecessor)
static void MarkNodeForDelaySlot (SchedulingManager &S, SchedGraph *graph, SchedGraphNode *node, const SchedGraphNode *brNode, bool nodeIsPredecessor)
void FindUsefulInstructionsForDelaySlots (SchedulingManager &S, SchedGraphNode *brNode, std::vector< SchedGraphNode * > &sdelayNodeVec)
static void ReplaceNopsWithUsefulInstr (SchedulingManager &S, SchedGraphNode *node, std::vector< SchedGraphNode * > sdelayNodeVec, SchedGraph *graph)
static void ChooseInstructionsForDelaySlots (SchedulingManager &S, MachineBasicBlock &MBB, SchedGraph *graph)
static bool ConflictsWithChoices (const SchedulingManager &S, MachineOpCode opCode)
static bool ViolatesMinimumGap (const SchedulingManager &S, MachineOpCode opCode, const CycleCount_t inCycle)
bool instrIsFeasible (const SchedulingManager &S, MachineOpCode opCode)
sg_pred_iterator pred_begin (SchedGraphNode *N)
sg_pred_iterator pred_end (SchedGraphNode *N)
sg_pred_const_iterator pred_begin (const SchedGraphNode *N)
sg_pred_const_iterator pred_end (const SchedGraphNode *N)
sg_succ_iterator succ_begin (SchedGraphNode *N)
sg_succ_iterator succ_end (SchedGraphNode *N)
sg_succ_const_iterator succ_begin (const SchedGraphNode *N)
sg_succ_const_iterator succ_end (const SchedGraphNode *N)
std::ostream & operator<< (std::ostream &os, const NodeDelayPair *nd)
bool NDPLessThan (const NodeDelayPair *np1, const NodeDelayPair *np2)
ModulePasscreateInternalGlobalMapperPass ()
static void applyTranferFuncForMInst (ValueSet &LVS, const MachineInstr *MInst)
ModulePassgetMappingInfoAsmPrinterPass (std::ostream &out)
static void writePrologue (std::ostream &Out, const std::string &comment, const std::string &symName)
static void writeEpilogue (std::ostream &Out, const std::string &symName)
FunctionPasscreateDependenceAnalyzer ()
 Create ModuloSchedulingPass.
FunctionPasscreateModuloSchedulingPass (TargetMachine &targ)
FunctionPasscreateModuloSchedulingSBPass (TargetMachine &targ)
std::ostream & operator<< (std::ostream &os, const MSchedGraphNode &node)
static MSchedGraphNodegetSecond (std::pair< const MachineInstr *const, MSchedGraphNode * > &Pair)
std::ostream & operator<< (std::ostream &os, const MSchedGraphSBNode &node)
static MSchedGraphSBNodegetSecond (std::pair< const MachineInstr *const, MSchedGraphSBNode * > &Pair)
static std::ostream & operator<< (std::ostream &OS, AllocInfo &S)
static void assertIGNode (const InterferenceGraph *IG, const IGNode *Node)
static std::ostream & operator<< (std::ostream &os, const V9LiveRange &lr)
bool InterferesWithColor (const V9LiveRange &LR, unsigned color)
bool InterfsPreventCoalescing (const V9LiveRange &LROfDef, const V9LiveRange &LROfUse)
void InsertBefore (MachineInstr *newMI, MachineBasicBlock &MBB, MachineBasicBlock::iterator &MII)
void InsertAfter (MachineInstr *newMI, MachineBasicBlock &MBB, MachineBasicBlock::iterator &MII)
void PrependInstructions (std::vector< MachineInstr * > &IBef, MachineBasicBlock &MBB, MachineBasicBlock::iterator &MII, const std::string &msg)
void AppendInstructions (std::vector< MachineInstr * > &IAft, MachineBasicBlock &MBB, MachineBasicBlock::iterator &MII, const std::string &msg)
static void markRegisterUsed (int RegNo, RegClass *RC, int RegType, const SparcV9RegInfo &TRI)
FunctionPasscreateAsmPrinterPass (std::ostream &Out, TargetMachine &TM)
uint64_t ConvertConstantToIntType (const TargetMachine &target, const Value *V, const Type *destType, bool &isValidConstant)
static void CreateSETUWConst (uint32_t C, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi, Value *val, bool isSigned=false)
static void CreateSETSWConst (int32_t C, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi, Value *val)
static void CreateSETXConst (uint64_t C, Instruction *tmpReg, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi, Value *val)
static void CreateSETUWLabel (Value *val, Instruction *dest, std::vector< MachineInstr * > &mvec)
static void CreateSETXLabel (Value *val, Instruction *tmpReg, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
static void CreateUIntSetInstruction (uint64_t C, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi, Value *val)
static void CreateIntSetInstruction (int64_t C, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi, Value *val)
bool ConstantMayNotFitInImmedField (const Constant *CV, const Instruction *I)
static MachineOpCode ChooseLoadInstruction (const Type *DestTy)
static MachineOpCode ChooseStoreInstruction (const Type *DestTy)
static MachineOpCode ChooseAddInstructionByType (const Type *resultType)
static unsigned convertOpcodeFromRegToImm (unsigned Opcode)
void CreateCodeToLoadConst (const TargetMachine &target, Function *F, Value *val, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
void CreateCodeToCopyFloatToInt (const TargetMachine &target, Function *F, Value *val, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
void CreateBitExtensionInstructions (bool signExtend, const TargetMachine &target, Function *F, Value *srcVal, Value *destVal, unsigned int numLowBits, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
void CreateSignExtensionInstructions (const TargetMachine &target, Function *F, Value *srcVal, Value *destVal, unsigned int numLowBits, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
void CreateZeroExtensionInstructions (const TargetMachine &target, Function *F, Value *srcVal, Value *destVal, unsigned int numLowBits, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
void CreateCodeToCopyIntToFloat (const TargetMachine &target, Function *F, Value *val, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
static TmpInstructionInsertCodeToLoadConstant (Function *F, Value *opValue, Instruction *vmInstr, std::vector< MachineInstr * > &loadConstVec, TargetMachine &target)
MachineOperand::MachineOperandType ChooseRegOrImmed (int64_t intValue, bool isSigned, MachineOpCode opCode, const TargetMachine &target, bool canUseImmed, unsigned int &getMachineRegNum, int64_t &getImmedValue)
MachineOperand::MachineOperandType ChooseRegOrImmed (Value *val, MachineOpCode opCode, const TargetMachine &target, bool canUseImmed, unsigned int &getMachineRegNum, int64_t &getImmedValue)
void CreateCopyInstructionsByType (const TargetMachine &target, Function *F, Value *src, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
std::vector< MachineInstr * > FixConstantOperandsForInstr (Instruction *vmInstr, MachineInstr *minstr, TargetMachine &target)
static void Add3OperandInstr (unsigned Opcode, InstructionNode *Node, std::vector< MachineInstr * > &mvec)
static bool IsZero (Value *idx)
static ValueFoldGetElemChain (InstrTreeNode *ptrNode, std::vector< Value * > &chainIdxVec, bool lastInstHasLeadingNonZero)
static ValueGetGEPInstArgs (InstructionNode *gepNode, std::vector< Value * > &idxVec, bool &allConstantIndices)
static ValueGetMemInstArgs (InstructionNode *memInstrNode, std::vector< Value * > &idxVec, bool &allConstantIndices)
static MachineOpCode ChooseBprInstruction (const InstructionNode *instrNode)
static MachineOpCode ChooseBpccInstruction (const InstructionNode *instrNode, const BinaryOperator *setCCInstr)
static MachineOpCode ChooseBFpccInstruction (const InstructionNode *instrNode, const BinaryOperator *setCCInstr)
static TmpInstructionGetTmpForCC (Value *boolVal, const Function *F, const Type *ccType, MachineCodeForInstruction &mcfi)
static MachineOpCode ChooseBccInstruction (const InstructionNode *instrNode, const Type *&setCCType)
static MachineOpCode ChooseMovFpcciInstruction (const InstructionNode *instrNode)
static MachineOpCode ChooseMovpcciForSetCC (const InstructionNode *instrNode)
static MachineOpCode ChooseMovpregiForSetCC (const InstructionNode *instrNode)
static MachineOpCode ChooseConvertToFloatInstr (const TargetMachine &target, OpLabel vopCode, const Type *opType)
static MachineOpCode ChooseConvertFPToIntInstr (const TargetMachine &target, const Type *destType, const Type *opType)
static MachineInstrCreateConvertFPToIntInstr (const TargetMachine &target, Value *srcVal, Value *destVal, const Type *destType)
static void CreateCodeToConvertFloatToInt (const TargetMachine &target, Value *opVal, Instruction *destI, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
static MachineOpCode ChooseAddInstruction (const InstructionNode *instrNode)
static MachineInstrCreateMovFloatInstruction (const InstructionNode *instrNode, const Type *resultType)
static MachineInstrCreateAddConstInstruction (const InstructionNode *instrNode)
static MachineOpCode ChooseSubInstructionByType (const Type *resultType)
static MachineInstrCreateSubConstInstruction (const InstructionNode *instrNode)
static MachineOpCode ChooseFcmpInstruction (const InstructionNode *instrNode)
static bool BothFloatToDouble (const InstructionNode *instrNode)
static MachineOpCode ChooseMulInstructionByType (const Type *resultType)
static MachineInstrCreateIntNegInstruction (const TargetMachine &target, Value *vreg)
static MachineInstrCreateIntNegInstruction (const TargetMachine &target, Value *vreg, Value *destreg)
static void CreateShiftInstructions (const TargetMachine &target, Function *F, MachineOpCode shiftOpCode, Value *argVal1, Value *optArgVal2, unsigned optShiftNum, Instruction *destVal, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
static unsigned CreateMulConstInstruction (const TargetMachine &target, Function *F, Value *lval, Value *rval, Instruction *destVal, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
static void CreateCheapestMulConstInstruction (const TargetMachine &target, Function *F, Value *lval, Value *rval, Instruction *destVal, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
static void CreateMulInstruction (const TargetMachine &target, Function *F, Value *lval, Value *rval, Instruction *destVal, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi, MachineOpCode forceMulOp=-1)
static MachineOpCode ChooseDivInstruction (TargetMachine &target, const InstructionNode *instrNode)
static void CreateDivConstInstruction (TargetMachine &target, const InstructionNode *instrNode, std::vector< MachineInstr * > &mvec)
static void CreateCodeForVariableSizeAlloca (const TargetMachine &target, Instruction *result, unsigned tsize, Value *numElementsVal, std::vector< MachineInstr * > &getMvec)
static void CreateCodeForFixedSizeAlloca (const TargetMachine &target, Instruction *result, unsigned tsize, unsigned numElements, std::vector< MachineInstr * > &getMvec)
static void SetOperandsForMemInstr (unsigned Opcode, std::vector< MachineInstr * > &mvec, InstructionNode *vmInstrNode, const TargetMachine &target)
static void ForwardOperand (InstructionNode *treeNode, InstrTreeNode *parent, int operandNum)
bool AllUsesAreBranches (const Instruction *I)
static bool CodeGenIntrinsic (Intrinsic::ID iid, CallInst &callInstr, TargetMachine &target, std::vector< MachineInstr * > &mvec)
bool ThisIsAChainRule (int eruleno)
void GetInstructionsByRule (InstructionNode *subtreeRoot, int ruleForNode, short *nts, TargetMachine &target, std::vector< MachineInstr * > &mvec)
FunctionPasscreateSparcV9BurgInstSelector (TargetMachine &TM)
FunctionPasscreateStackSlotsPass (const TargetMachine &TM)
FunctionPasscreatePreSelectionPass (const TargetMachine &TM)
FunctionPasscreatePeepholeOptsPass (const TargetMachine &TM)
FunctionPasscreatePrologEpilogInsertionPass ()
FunctionPasscreateSparcV9MachineCodeDestructionPass ()
static void DeleteInstruction (MachineBasicBlock &mvec, MachineBasicBlock::iterator &BBI, const TargetMachine &target)
static bool IsUselessCopy (const TargetMachine &target, const MachineInstr *MI)
bool RemoveUselessCopies (MachineBasicBlock &mvec, MachineBasicBlock::iterator &BBI, const TargetMachine &target)
FunctionPasscreatePreSelectionPass (const TargetMachine &TM)
static unsigned getStaticStackSize (MachineFunction &MF)
bool isVarArgsFunction (const Type *funcType)
bool isVarArgsCall (const MachineInstr *CallMI)
FunctionPasscreateStackSlotsPass (const TargetMachine &Target)
FunctionPasscreateSparcV9MachineCodeDestructionPass ()
FunctionPasscreateX86ISelDag (X86TargetMachine &TM)
FunctionPasscreateX86FloatingPointStackifierPass ()
FunctionPasscreateX86CodePrinterPass (std::ostream &o, X86TargetMachine &tm)
FunctionPasscreateX86CodeEmitterPass (MachineCodeEmitter &MCE)
void addX86ELFObjectWriterPass (PassManager &FPM, std::ostream &o, X86TargetMachine &tm)
FunctionPasscreateEmitX86CodeToMemory ()
Statistic EmittedInsts ("asm-printer","Number of machine instrs printed")
FunctionPasscreateX86CodePrinterPass (std::ostream &o, X86TargetMachine &tm)
FunctionPasscreateX86CodeEmitterPass (MachineCodeEmitter &MCE)
void addX86ELFObjectWriterPass (PassManager &FPM, std::ostream &O, X86TargetMachine &TM)
FunctionPasscreateX86FloatingPointStackifierPass ()
const MachineInstrBuilderaddDirectMem (const MachineInstrBuilder &MIB, unsigned Reg)
const MachineInstrBuilderaddRegOffset (const MachineInstrBuilder &MIB, unsigned Reg, int Offset)
const MachineInstrBuilderaddRegReg (const MachineInstrBuilder &MIB, unsigned Reg1, unsigned Reg2)
const MachineInstrBuilderaddFullAddress (const MachineInstrBuilder &MIB, const X86AddressMode &AM)
const MachineInstrBuilderaddFrameReference (const MachineInstrBuilder &MIB, int FI, int Offset=0)
FunctionPasscreateX86ISelDag (X86TargetMachine &TM)
bool ExpressionConvertibleToType (Value *V, const Type *Ty, ValueTypeCache &CTMap, const TargetData &TD)
ValueConvertExpressionToType (Value *V, const Type *Ty, ValueMapCache &VMC, const TargetData &TD)
bool ValueConvertibleToType (Value *V, const Type *Ty, ValueTypeCache &ConvertedTypes, const TargetData &TD)
void ConvertValueToNewType (Value *V, Value *NewVal, ValueMapCache &VMC, const TargetData &TD)
ModulePasscreateFunctionProfilerPass ()
ModulePasscreateBlockProfilerPass ()
ModulePasscreateEdgeProfilerPass ()
static char doDFS (BasicBlock *node, std::map< BasicBlock *, Color > &color)
static char hasBackEdge (Function *F)
void InsertProfilingInitCall (Function *MainFn, const char *FnName, GlobalValue *Array)
void IncrementCounterInBlock (BasicBlock *BB, unsigned CounterNum, GlobalValue *CounterArray)
ModulePasscreateNullProfilerRSPass ()
FunctionPasscreateRSProfilingPass ()
ModulePasscreateTraceBasicBlockPass ()
FunctionPasscreateTraceValuesPassForFunction ()
 Just trace functions.
FunctionPasscreateTraceValuesPassForBasicBlocks ()
 Trace BB's and functions.
ModulePasscreateArgumentPromotionPass ()
ModulePasscreateConstantMergePass ()
ModulePasscreateDeadArgEliminationPass ()
ModulePasscreateDeadArgHackingPass ()
ModulePasscreateDeadTypeEliminationPass ()
ModulePasscreateFunctionExtractionPass (Function *F, bool deleteFn)
ModulePasscreateFunctionResolvingPass ()
ModulePasscreateGlobalDCEPass ()
ModulePasscreateGlobalOptimizerPass ()
ModulePasscreateIndMemRemPass ()
ModulePasscreateFunctionInliningPass ()
ModulePasscreateInternalizePass (bool InternalizeEverything)
ModulePasscreateIPConstantPropagationPass ()
FunctionPasscreateLoopExtractorPass ()
FunctionPasscreateSingleLoopExtractorPass ()
ModulePasscreateBlockExtractorPass (std::vector< BasicBlock * > &BTNE)
ModulePasscreateLowerSetJmpPass ()
ModulePasscreatePruneEHPass ()
ModulePasscreateRaiseAllocationsPass ()
ModulePasscreateSimplifyLibCallsPass ()
ModulePasscreateStripSymbolsPass (bool OnlyDebugInfo)
FunctionPasscreateRaisePointerReferencesPass ()
FunctionPasscreateAggressiveDCEPass ()
FunctionPasscreateBlockPlacementPass ()
FunctionPasscreateCondPropagationPass ()
FunctionPasscreateConstantPropagationPass ()
FunctionPasscreateCorrelatedExpressionEliminationPass ()
FunctionPasscreateDeadInstEliminationPass ()
FunctionPasscreateDeadCodeEliminationPass ()
FunctionPasscreateDeadStoreEliminationPass ()
FunctionPasscreateGCSEPass ()
FunctionPasscreateIndVarSimplifyPass ()
FunctionPasscreateInstructionCombiningPass ()
FunctionPasscreateLICMPass ()
FunctionPasscreateLoopStrengthReducePass (const TargetLowering *TLI)
FunctionPasscreateLoopUnrollPass ()
FunctionPasscreateLoopUnswitchPass ()
FunctionPasscreateLowerAllocationsPass (bool LowerMallocArgToInteger)
FunctionPasscreateLowerGCPass ()
FunctionPasscreateLowerInvokePass (unsigned JumpBufSize, unsigned JumpBufAlign)
FunctionPasscreateLowerPackedPass ()
FunctionPasscreateLowerSelectPass (bool OnlyFP)
FunctionPasscreateLowerSwitchPass ()
FunctionPasscreatePromoteMemoryToRegisterPass ()
FunctionPasscreateReassociatePass ()
FunctionPasscreateDemoteRegisterToMemoryPass ()
FunctionPasscreateScalarReplAggregatesPass ()
FunctionPasscreateSCCPPass ()
ModulePasscreateIPSCCPPass ()
FunctionPasscreateCFGSimplificationPass ()
FunctionPasscreateTailDuplicationPass ()
FunctionPasscreateTailCallEliminationPass ()
const TypegetStructOffsetType (const Type *Ty, unsigned &Offset, std::vector< Value * > &Indices, const TargetData &TD, bool StopEarly)
static int64_t getConstantValue (const ConstantInt *CPI)
static const CompositeTypegetPointedToComposite (const Type *Ty)
void ReplaceInstWithValue (BasicBlock::InstListType &BIL, BasicBlock::iterator &BI, Value *V)
void ReplaceInstWithInst (BasicBlock::InstListType &BIL, BasicBlock::iterator &BI, Instruction *I)
void ReplaceInstWithInst (Instruction *From, Instruction *To)
void RemoveSuccessor (TerminatorInst *TI, unsigned SuccNum)
FunctionPasscreateBreakCriticalEdgesPass ()
bool isCriticalEdge (const TerminatorInst *TI, unsigned SuccNum)
bool SplitCriticalEdge (TerminatorInst *TI, unsigned SuccNum, Pass *P)
BasicBlockCloneBasicBlock (const BasicBlock *BB, std::map< const Value *, Value * > &ValueMap, const char *NameSuffix, Function *F, ClonedCodeInfo *CodeInfo)
void CloneFunctionInto (Function *NewFunc, const Function *OldFunc, std::map< const Value *, Value * > &ValueMap, std::vector< ReturnInst * > &Returns, const char *NameSuffix, ClonedCodeInfo *CodeInfo)
FunctionCloneFunction (const Function *F, std::map< const Value *, Value * > &ValueMap, ClonedCodeInfo *CodeInfo)
ModuleCloneModule (const Module *M)
std::vector< BasicBlock * > CloneTrace (const std::vector< BasicBlock * > &origTrace)
void CloneTraceInto (Function *NewFunc, Trace &T, std::map< const Value *, Value * > &ValueMap, const char *NameSuffix)
FunctionExtractCodeRegion (DominatorSet &DS, const std::vector< BasicBlock * > &code, bool AggregateArgs)
FunctionExtractLoop (DominatorSet &DS, Loop *L, bool AggregateArgs)
FunctionExtractBasicBlock (BasicBlock *BB, bool AggregateArgs)
AllocaInstDemoteRegToStack (Instruction &I, bool VolatileLoads)
bool InlineFunction (CallInst *CI, CallGraph *CG)
bool InlineFunction (InvokeInst *II, CallGraph *CG)
bool InlineFunction (CallSite CS, CallGraph *CG)
bool doConstantPropagation (BasicBlock::iterator &II)
ConstantConstantFoldInstruction (Instruction *I)
bool ConstantFoldTerminator (BasicBlock *BB)
ConstantConstantFoldLoadThroughGEPConstantExpr (Constant *C, ConstantExpr *CE)
bool isInstructionTriviallyDead (Instruction *I)
bool dceInstruction (BasicBlock::iterator &BBI)
FunctionPasscreateLoopSimplifyPass ()
bool isAllocaPromotable (const AllocaInst *AI, const TargetData &TD)
void PromoteMemToReg (const std::vector< AllocaInst * > &Allocas, DominatorTree &DT, DominanceFrontier &DF, const TargetData &TD, AliasSetTracker *AST)
bool SimplifyCFG (BasicBlock *BB)
PasscreateUnifyFunctionExitNodesPass ()
ValueMapValue (const Value *V, std::map< const Value *, Value * > &VM)
void RemapInstruction (Instruction *I, std::map< const Value *, Value * > &ValueMap)
ValueMapValue (const Value *V, ValueMapTy &VM)
void RemapInstruction (Instruction *I, ValueMapTy &VM)
std::ostream & WriteTypeSymbolic (std::ostream &Out, const Type *Ty, const Module *M)
std::ostream & WriteAsOperand (std::ostream &Out, const Value *V, bool PrintType, bool PrintName, const Module *Context)
std::ostream & WriteAsOperand (std::ostream &Out, const Type *Ty, bool PrintType, bool PrintName, const Module *Context)
FunctionUpgradeIntrinsicFunction (Function *F)
 Remove overloaded intrinsic function names.
void UpgradeIntrinsicCall (CallInst *CI, Function *NewFn)
 Get replacement instruction for overloaded intrinsic function call.
bool UpgradeCallsToIntrinsic (Function *F)
ConstantConstantFoldCastInstruction (const Constant *V, const Type *DestTy)
ConstantConstantFoldSelectInstruction (const Constant *Cond, const Constant *V1, const Constant *V2)
ConstantConstantFoldExtractElementInstruction (const Constant *Val, const Constant *Idx)
ConstantConstantFoldInsertElementInstruction (const Constant *Val, const Constant *Elt, const Constant *Idx)
ConstantConstantFoldShuffleVectorInstruction (const Constant *V1, const Constant *V2, const Constant *Mask)
ConstantConstantFoldBinaryInstruction (unsigned Opcode, const Constant *V1, const Constant *V2)
ConstantConstantFoldGetElementPtr (const Constant *C, const std::vector< Value * > &IdxList)
static std::ostream & operator<< (std::ostream &o, const std::set< BasicBlock * > &BBs)
std::ostream & operator<< (std::ostream &OS, const Type *T)
FunctionPasscreateVerifierPass (VerifierFailureAction action)
bool verifyFunction (const Function &f, VerifierFailureAction action)
bool verifyModule (const Module &M, VerifierFailureAction action)

Variables

static IncludeFile CALLGRAPH_INCLUDE_FILE ((void *)&CallGraph::stub)
static IncludeFile DOMINATORS_INCLUDE_FILE ((void *)&DominatorSet::stub)
static IncludeFile FIND_USED_TYPES_INCLUDE_FILE ((void *)(&FindUsedTypes::stub))
static IncludeFile LOOP_INFO_INCLUDE_FILE ((void *)(&LoopInfo::stub))
static IncludeFile POST_DOMINATOR_INCLUDE_FILE ((void *)&PostDominanceFrontier::stub)
const PassInfoPHIEliminationID = X.getPassInfo()
const PassInfoTwoAddressInstructionPassID = X.getPassInfo()
const ResourceId InvalidRID = -1
const ResourceId MachineCCRegsRID = -2
const ResourceId MachineIntRegsRID = -3
const ResourceId MachineFPRegsRID = -4
bool TimePassesIsEnabled = false
 This is the storage for the -time-passes option.
bool DebugFlag
 Alloca
AllocaInst HANDLE_MEMORY_INST (24, Load, LoadInst) HANDLE_OTHER_INST(27
AllocaInst PHI
AllocaInst PHINode Call
AllocaInst PHINode CallInst Select
AllocaInst PHINode CallInst
SelectInst 
VAArg
AllocaInst PHINode CallInst
SelectInst VAArgInst 
InsertElement
static cl::opt< PluginLoader,
false, cl::parser< std::string > > 
LoadOpt ("load", cl::ZeroOrMore, cl::value_desc("pluginfilename"), cl::desc("Load the specified plugin"))
const unsigned M_NOP_FLAG = 1 << 0
const unsigned M_BRANCH_FLAG = 1 << 1
const unsigned M_CALL_FLAG = 1 << 2
const unsigned M_RET_FLAG = 1 << 3
const unsigned M_BARRIER_FLAG = 1 << 4
const unsigned M_DELAY_SLOT_FLAG = 1 << 5
const unsigned M_CC_FLAG = 1 << 6
const unsigned M_LOAD_FLAG = 1 << 7
const unsigned M_STORE_FLAG = 1 << 8
const unsigned M_2_ADDR_FLAG = 1 << 9
const unsigned M_CONVERTIBLE_TO_3_ADDR = 1 << 10
const unsigned M_COMMUTABLE = 1 << 11
const unsigned M_TERMINATOR_FLAG = 1 << 12
const unsigned M_USES_CUSTOM_DAG_SCHED_INSERTION = 1 << 13
bool PrintMachineCode
bool NoFramePointerElim
bool NoExcessFPPrecision
bool UnsafeFPMath
static const CycleCount_t HUGE_LATENCY = ~((long long) 1 << (sizeof(CycleCount_t)-2))
static const CycleCount_t INVALID_LATENCY = -HUGE_LATENCY
const int MAX_NUM_SLOTS = 32
const int MAX_NUM_CYCLES = 32
const PassInfoDemoteRegisterToMemoryID = X.getPassInfo()
const PassInfoBreakCriticalEdgesID = X.getPassInfo()
const PassInfoLoopSimplifyID = X.getPassInfo()
const PassInfoLowerInvokePassID = X.getPassInfo()
std::string CurFilename
std::string CurFilename
const TargetInstrDescriptorTargetInstrDescriptors
static const bool pthread_enabled = static_cast<bool>(pthread_mutex_init)
PPCTargetEnum PPCTarget = TargetDefault
SchedDebugLevel_t SchedDebugLevel
static cl::opt< bool > EnableFillingDelaySlots ("sched-fill-delay-slots", cl::Hidden, cl::desc("Fill branch delay slots during local scheduling"))
static cl::opt< SchedDebugLevel_t,
true > 
SDL_opt ("dsched", cl::Hidden, cl::location(SchedDebugLevel), cl::desc("enable instruction scheduling debugging information"), cl::values(clEnumValN(Sched_NoDebugInfo,"n","disable debug output"), clEnumValN(Sched_PrintMachineCode,"y","print machine code after scheduling"), clEnumValN(Sched_PrintSchedTrace,"t","print trace of scheduling actions"), clEnumValN(Sched_PrintSchedGraphs,"g","print scheduling graphs"), clEnumValEnd))
static const int SG_LOAD_REF = 0
static const int SG_STORE_REF = 1
static const int SG_CALL_REF = 2
static const unsigned int SG_DepOrderArray [][3]
SchedDebugLevel_t SchedDebugLevel
LiveVarDebugLevel_t DEBUG_LV
static RegisterAnalysis< FunctionLiveVarInfoX ("livevar","Live Variable Analysis")
LiveVarDebugLevel_t DEBUG_LV
static cl::opt< LiveVarDebugLevel_t,
true > 
DEBUG_LV_opt ("dlivevar", cl::Hidden, cl::location(DEBUG_LV), cl::desc("enable live-variable debugging information"), cl::values(clEnumValN(LV_DEBUG_None,"n","disable debug output"), clEnumValN(LV_DEBUG_Normal,"y","enable debug output"), clEnumValN(LV_DEBUG_Instr,"i","print live-var sets before/after ""every machine instrn"), clEnumValN(LV_DEBUG_Verbose,"v","print def, use sets for every instrn also"), clEnumValEnd))
Statistic ValidLoops ("modulosched-validLoops","Number of candidate loops modulo-scheduled")
Statistic JumboBB ("modulosched-jumboBB","Basic Blocks with more then 100 instructions")
Statistic LoopsWithCalls ("modulosched-loopCalls","Loops with calls")
Statistic LoopsWithCondMov ("modulosched-loopCondMov","Loops with conditional moves")
Statistic InvalidLoops ("modulosched-invalidLoops","Loops with unknown trip counts or loop invariant trip counts")
Statistic SingleBBLoops ("modulosched-singeBBLoops","Number of single basic block loops")
Statistic MSLoops ("modulosched-schedLoops","Number of loops successfully modulo-scheduled")
Statistic NoSched ("modulosched-noSched","No schedule")
Statistic SameStage ("modulosched-sameStage","Max stage is 0")
Statistic ResourceConstraint ("modulosched-resourceConstraint","Loops constrained by resources")
Statistic RecurrenceConstraint ("modulosched-recurrenceConstraint","Loops constrained by recurrences")
Statistic FinalIISum ("modulosched-finalIISum","Sum of all final II")
Statistic IISum ("modulosched-IISum","Sum of all theoretical II")
Statistic NumLoops ("moduloschedSB-numLoops","Total Number of Loops")
Statistic NumSB ("moduloschedSB-numSuperBlocks","Total Number of SuperBlocks")
Statistic BBWithCalls ("modulosched-BBCalls","Basic Blocks rejected due to calls")
Statistic BBWithCondMov ("modulosched-loopCondMov","Basic Blocks rejected due to conditional moves")
Statistic SBResourceConstraint ("modulosched-resourceConstraint","Loops constrained by resources")
Statistic SBRecurrenceConstraint ("modulosched-recurrenceConstraint","Loops constrained by recurrences")
Statistic SBFinalIISum ("modulosched-finalIISum","Sum of all final II")
Statistic SBIISum ("modulosched-IISum","Sum of all theoretical II")
Statistic SBMSLoops ("modulosched-schedLoops","Number of loops successfully modulo-scheduled")
Statistic SBNoSched ("modulosched-noSched","No schedule")
Statistic SBSameStage ("modulosched-sameStage","Max stage is 0")
Statistic SBBLoops ("modulosched-SBBLoops","Number single basic block loops")
Statistic SBInvalid ("modulosched-SBInvalid","Number invalid superblock loops")
Statistic SBValid ("modulosched-SBValid","Number valid superblock loops")
Statistic SBSize ("modulosched-SBSize","Total size of all valid superblocks")
Statistic RASpills ("regalloc-spills","Number of registers spilled")
RegAllocDebugLevel_t DEBUG_RA
static cl::opt< RegAllocDebugLevel_t,
true > 
DRA_opt ("dregalloc", cl::Hidden, cl::location(DEBUG_RA), cl::desc("enable register allocation debugging information"), cl::values(clEnumValN(RA_DEBUG_None,"n","disable debug output"), clEnumValN(RA_DEBUG_Results,"y","debug output for allocation results"), clEnumValN(RA_DEBUG_Coloring,"c","debug output for graph coloring step"), clEnumValN(RA_DEBUG_Interference,"ig","debug output for interference graphs"), clEnumValN(RA_DEBUG_LiveRanges,"lr","debug output for live ranges"), clEnumValN(RA_DEBUG_Verbose,"v","extra debug output"), clEnumValEnd))
PhyRegAlloc::SavedStateMapTy ExportedFnAllocState
bool SaveRegAllocState = false
bool SaveStateToModule = true
static cl::opt< bool, true > SaveRegAllocStateOpt ("save-ra-state", cl::Hidden, cl::location(SaveRegAllocState), cl::init(false), cl::desc("write reg. allocator state into module"))
RegAllocDebugLevel_t DEBUG_RA
cl::opt< SelectDebugLevel_t > SelectDebugLevel ("dselect", cl::Hidden, cl::desc("enable instruction selection debug information"), cl::values(clEnumValN(Select_NoDebugInfo,"n","disable debug output"), clEnumValN(Select_PrintMachineCode,"y","print generated machine code"), clEnumValN(Select_DebugInstTrees,"i","print debugging info for instruction selection"), clEnumValN(Select_DebugBurgTrees,"b","print burg trees"), clEnumValEnd))
static const uint32_t MAXLO = (1 << 10) - 1
static const uint32_t MAXSIMM = (1 << 12) - 1
const TargetInstrDescriptor SparcV9MachineInstrDesc []
static const char *const IntRegNames []
static const char *const FloatRegNames []
static const char *const IntCCRegNames []
static const char *const FloatCCRegNames []
static const char *const SpecialRegNames []
const unsigned IR []
const MVT::ValueType IRVTs [] = { MVT::i64, MVT::Other }
llvm:: { ... } ::IRClass IRInstance
const unsigned FR []
const MVT::ValueType FRVTs [] = { MVT::f32, MVT::Other }
llvm:: { ... } ::FRClass FRInstance
const unsigned ICCR []
const MVT::ValueType ICCRVTs [] = { MVT::i1, MVT::Other }
llvm:: { ... } ::ICCRClass ICCRInstance
const unsigned FCCR []
const MVT::ValueType FCCRVTs [] = { MVT::i1, MVT::Other }
llvm:: { ... } ::FCCRClass FCCRInstance
const unsigned SR []
const MVT::ValueType SRVTs [] = { MVT::i64, MVT::Other }
llvm:: { ... } ::SRClass SRInstance
const TargetRegisterClass
*const 
RegisterClasses []
const unsigned Empty_AliasSet [] = { 0 }
const unsigned fcc3_AliasSet [] = { SparcV9::fsr, 0 }
const unsigned fcc2_AliasSet [] = { SparcV9::fsr, 0 }
const unsigned fcc1_AliasSet [] = { SparcV9::fsr, 0 }
const unsigned fcc0_AliasSet [] = { SparcV9::fsr, 0 }
const unsigned fsr_AliasSet []
const unsigned xcc_AliasSet [] = { SparcV9::ccr, 0 }
const unsigned icc_AliasSet [] = { SparcV9::ccr, 0 }
const unsigned ccr_AliasSet [] = { SparcV9::xcc, SparcV9::icc, 0 }
const TargetRegisterDesc RegisterDescriptors []
bool EmitMappingInfo = false
const TargetInstrDescriptorTargetInstrDescriptors = 0
bool PrintMachineCode
bool NoFramePointerElim
bool NoExcessFPPrecision
bool UnsafeFPMath
Reloc::Model RelocationModel
Statistic EmittedInsts
RegisterOpt< EmitFunctionTable > X ("emitfuncs","Emit a function table for the reoptimizer")
static cl::opt< enum PassDebugLevelPassDebugging ("debug-pass", cl::Hidden, cl::desc("Print PassManager debugging information"), cl::values(clEnumVal(None,"disable debug output"), clEnumVal(Arguments,"print pass arguments to pass to 'opt'"), clEnumVal(Structure,"print pass structure before run()"), clEnumVal(Executions,"print pass name before it is executed"), clEnumVal(Details,"print pass details when it is executed"), clEnumValEnd))
static TimingInfoTheTimeInfo


Detailed Description

===---------------------------------------------------------------------===//

SelectionDAGLowering - This is the common target-independent lowering implementation that is parameterized by a TargetLowering object. Also, targets can overload any lowering method.


Typedef Documentation

typedef IntervalIterator<BasicBlock, Function> llvm::function_interval_iterator

Definition at line 235 of file IntervalIterator.h.

typedef IntervalIterator<Interval, IntervalPartition> llvm::interval_part_interval_iterator

Definition at line 236 of file IntervalIterator.h.

typedef short llvm::MachineOpCode

Definition at line 33 of file MachineInstr.h.

typedef int llvm::ResourceId

Definition at line 25 of file SchedGraphCommon.h.

typedef std::set<const Value*> llvm::ValueSet

Definition at line 34 of file ValueSet.h.

typedef uintptr_t llvm::PointerTy

Definition at line 22 of file GenericValue.h.

typedef const PassInfo* llvm::AnalysisID

Definition at line 51 of file Pass.h.

typedef PredIterator<BasicBlock, Value::use_iterator> llvm::pred_iterator

Definition at line 69 of file CFG.h.

typedef PredIterator<const BasicBlock, Value::use_const_iterator> llvm::pred_const_iterator

Definition at line 71 of file CFG.h.

typedef SuccIterator<TerminatorInst*, BasicBlock> llvm::succ_iterator

Definition at line 133 of file CFG.h.

typedef SuccIterator<const TerminatorInst*, const BasicBlock> llvm::succ_const_iterator

Definition at line 135 of file CFG.h.

typedef generic_gep_type_iterator llvm::gep_type_iterator

Definition at line 82 of file GetElementPtrTypeIterator.h.

typedef InstIterator<iplist<BasicBlock>, Function::iterator, BasicBlock::iterator, Instruction> llvm::inst_iterator

Definition at line 122 of file InstIterator.h.

typedef InstIterator<const iplist<BasicBlock>, Function::const_iterator, BasicBlock::const_iterator, const Instruction> llvm::const_inst_iterator

Definition at line 126 of file InstIterator.h.

typedef short llvm::MachineOpCode

Definition at line 32 of file TargetInstrInfo.h.

typedef unsigned llvm::InstrSchedClass

Definition at line 39 of file TargetInstrInfo.h.

typedef long long llvm::CycleCount_t

Definition at line 25 of file TargetSchedInfo.h.

typedef unsigned llvm::resourceId_t

Definition at line 39 of file TargetSchedInfo.h.

typedef generic_gep_type_iterator<User::const_op_iterator> llvm::gep_type_iterator

Definition at line 31 of file lib/ExecutionEngine/Interpreter/Interpreter.h.

typedef std::vector<GenericValue> llvm::ValuePlaneTy

Definition at line 65 of file lib/ExecutionEngine/Interpreter/Interpreter.h.

typedef SGPredIterator<SchedGraphNode, SchedGraphEdge, SchedGraphNode::iterator> llvm::sg_pred_iterator

Definition at line 189 of file SchedGraph.h.

typedef SGPredIterator<const SchedGraphNode, const SchedGraphEdge,SchedGraphNode::const_iterator> llvm::sg_pred_const_iterator

Definition at line 191 of file SchedGraph.h.

typedef SGSuccIterator<SchedGraphNode, SchedGraphEdge, SchedGraphNode::iterator> llvm::sg_succ_iterator

Definition at line 212 of file SchedGraph.h.

typedef SGSuccIterator<const SchedGraphNode, const SchedGraphEdge,SchedGraphNode::const_iterator> llvm::sg_succ_const_iterator

Definition at line 214 of file SchedGraph.h.

typedef std::vector<const MachineBasicBlock*> llvm::SuperBlock

Definition at line 42 of file ModuloSchedulingSuperBlock.h.

typedef hash_map<const Value*, V9LiveRange*> llvm::LiveRangeMapType

Definition at line 41 of file LiveRangeInfo.h.

typedef std::map<const Value*, const Type*> llvm::ValueTypeCache

Definition at line 78 of file TransformInternals.h.

typedef std::map<const Value *, Value *> llvm::ValueMapTy

Definition at line 22 of file ValueMapper.h.


Enumeration Type Documentation

enum llvm::SCEVTypes

Enumerator:
scConstant 
scTruncate 
scZeroExtend 
scAddExpr 
scMulExpr 
scSDivExpr 
scAddRecExpr 
scUnknown 
scCouldNotCompute 

Definition at line 23 of file ScalarEvolutionExpressions.h.

enum llvm::VerifierFailureAction

An enumeration to specify the action to be taken if errors found.

This enumeration is used in the functions below to indicate what should happen if the verifier finds errors. Each of the functions that uses this enumeration as an argument provides a default value for it. The actions are listed below.

Enumerator:
AbortProcessAction  verifyModule will print to stderr and abort()
ThrowExceptionAction  verifyModule will throw errors as std::string
PrintMessageAction  verifyModule will print to stderr and return true
ReturnStatusAction  verifyModule will just return true

Definition at line 36 of file Verifier.h.

anonymous enum

Enumerator:
LLVMDebugVersion 

Definition at line 59 of file MachineDebugInfo.h.

enum llvm::PPCTargetEnum

Enumerator:
TargetDefault 
TargetAIX 
TargetDarwin 

Definition at line 25 of file PPC.h.

enum llvm::SchedDebugLevel_t

Enumerator:
Sched_NoDebugInfo 
Sched_Disable 
Sched_PrintMachineCode 
Sched_PrintSchedTrace 
Sched_PrintSchedGraphs 

Definition at line 39 of file SchedPriorities.h.

enum llvm::LiveVarDebugLevel_t

Enumerator:
LV_DEBUG_None 
LV_DEBUG_Normal 
LV_DEBUG_Instr 
LV_DEBUG_Verbose 

Definition at line 27 of file BBLiveVar.h.

enum llvm::RegAllocDebugLevel_t

Enumerator:
RA_DEBUG_None 
RA_DEBUG_Results 
RA_DEBUG_Coloring 
RA_DEBUG_Interference 
RA_DEBUG_LiveRanges 
RA_DEBUG_Verbose 

Definition at line 19 of file RegAllocCommon.h.

enum llvm::SparcV9InstrSchedClass

Enumerator:
SPARC_NONE 
SPARC_IEUN 
SPARC_IEU0 
SPARC_IEU1 
SPARC_FPM 
SPARC_FPA 
SPARC_CTI 
SPARC_LD 
SPARC_ST 
SPARC_SINGLE 
SPARC_INV 
SPARC_NUM_SCHED_CLASSES 

Definition at line 33 of file SparcV9Internals.h.

anonymous enum

Enumerator:
BadRegClass 

Definition at line 35 of file SparcV9RegInfo.cpp.

enum llvm::PassDebugLevel

Enumerator:
None 
Arguments 
Structure 
Executions 
Details 

Definition at line 42 of file PassManagerT.h.


Function Documentation

std::ostream& llvm::operator<< ( std::ostream &  O,
const BitSetVector &  bset 
) [inline]

Definition at line 251 of file BitSetVector.h.

References llvm::BitSetVector::print().

bool llvm::Disjoint ( const BitSetVector &  set1,
const BitSetVector &  set2 
) [inline]

Optimized versions of fundamental comparison operations

Definition at line 261 of file BitSetVector.h.

References llvm::BitSetVector::bitsetVec, llvm::BitSetVector::getWord(), and llvm::BitSetVector::size().

template<class T>
df_iterator<T> llvm::df_begin ( T  G  ) 

Definition at line 164 of file DepthFirstIterator.h.

Referenced by llvm::ETForestBase::updateDFSNumbers().

template<class T>
df_iterator<T> llvm::df_end ( T  G  ) 

Definition at line 169 of file DepthFirstIterator.h.

Referenced by llvm::ETForestBase::updateDFSNumbers().

template<class T, class SetTy>
df_ext_iterator<T, SetTy> llvm::df_ext_begin ( T  G,
SetTy S 
)

Definition at line 181 of file DepthFirstIterator.h.

Referenced by llvm::LiveVariables::runOnMachineFunction().

template<class T, class SetTy>
df_ext_iterator<T, SetTy> llvm::df_ext_end ( T  G,
SetTy S 
)

Definition at line 186 of file DepthFirstIterator.h.

Referenced by llvm::LiveVariables::runOnMachineFunction().

template<class T>
idf_iterator<T> llvm::idf_begin ( T  G  ) 

Definition at line 200 of file DepthFirstIterator.h.

Referenced by llvm::PostETForest::calculate().

template<class T>
idf_iterator<T> llvm::idf_end ( T  G  ) 

Definition at line 205 of file DepthFirstIterator.h.

Referenced by llvm::PostETForest::calculate().

template<class T, class SetTy>
idf_ext_iterator<T, SetTy> llvm::idf_ext_begin ( T  G,
SetTy S 
)

Definition at line 219 of file DepthFirstIterator.h.

template<class T, class SetTy>
idf_ext_iterator<T, SetTy> llvm::idf_ext_end ( T  G,
SetTy S 
)

Definition at line 224 of file DepthFirstIterator.h.

template<class T>
po_iterator<T> llvm::po_begin ( T  G  ) 

Definition at line 127 of file PostOrderIterator.h.

template<class T>
po_iterator<T> llvm::po_end ( T  G  ) 

Definition at line 129 of file PostOrderIterator.h.

template<class T, class SetType>
po_ext_iterator<T, SetType> llvm::po_ext_begin ( T  G,
SetType &  S 
)

Definition at line 139 of file PostOrderIterator.h.

template<class T, class SetType>
po_ext_iterator<T, SetType> llvm::po_ext_end ( T  G,
SetType &  S 
)

Definition at line 144 of file PostOrderIterator.h.

template<class T>
ipo_iterator<T> llvm::ipo_begin ( T  G,
bool  Reverse = false 
)

Definition at line 158 of file PostOrderIterator.h.

template<class T>
ipo_iterator<T> llvm::ipo_end ( T  G  ) 

Definition at line 163 of file PostOrderIterator.h.

template<class T, class SetType>
ipo_ext_iterator<T, SetType> llvm::ipo_ext_begin ( T  G,
SetType &  S 
)

Definition at line 177 of file PostOrderIterator.h.

template<class T, class SetType>
ipo_ext_iterator<T, SetType> llvm::ipo_ext_end ( T  G,
SetType &  S 
)

Definition at line 182 of file PostOrderIterator.h.

template<class T>
scc_iterator<T> llvm::scc_begin ( T  G  ) 

Definition at line 188 of file SCCIterator.h.

Referenced by llvm::Type::PromoteAbstractToConcrete(), and llvm::CallGraphSCCPass::runOnModule().

template<class T>
scc_iterator<T> llvm::scc_end ( T  G  ) 

Definition at line 193 of file SCCIterator.h.

Referenced by llvm::Type::PromoteAbstractToConcrete(), and llvm::CallGraphSCCPass::runOnModule().

template<class S1Ty, class S2Ty>
bool llvm::set_union ( S1Ty &  S1,
const S2Ty &  S2 
)

set_union(A, B) - Compute A := A u B, return whether A changed.

Definition at line 23 of file SetOperations.h.

References Changed, and SE.

Referenced by llvm::BBLiveVar::applyTransferFunc().

template<class S1Ty, class S2Ty>
void llvm::set_intersect ( S1Ty &  S1,
const S2Ty &  S2 
)

set_intersect(A, B) - Compute A := A ^ B Identical to set_intersection, except that it works on set<>'s and is nicer to use. Functionally, this iterates through S1, removing elements that are not contained in S2.

Definition at line 40 of file SetOperations.h.

References E, and I.

template<class S1Ty, class S2Ty>
S1Ty llvm::set_difference ( const S1Ty &  S1,
const S2Ty &  S2 
)

set_difference(A, B) - Return A - B

Definition at line 51 of file SetOperations.h.

References SE.

Referenced by llvm::BBLiveVar::applyTransferFunc().

template<class S1Ty, class S2Ty>
void llvm::set_subtract ( S1Ty &  S1,
const S2Ty &  S2 
)

set_subtract(A, B) - Compute A := A - B

Definition at line 63 of file SetOperations.h.

References SE.

Referenced by llvm::Linker::LinkInArchive().

template<class T>
static void llvm::deleter ( T Ptr  )  [inline, static]

Definition at line 43 of file STLExtras.h.

template<class _Iterator, class Func>
mapped_iterator<_Iterator, Func> llvm::operator+ ( typename mapped_iterator< _Iterator, Func >::difference_type  N,
const mapped_iterator< _Iterator, Func > &  X 
) [inline]

Definition at line 106 of file STLExtras.h.

References X.

template<class ItTy, class FuncTy>
mapped_iterator<ItTy, FuncTy> llvm::map_iterator ( const ItTy &  I,
FuncTy  F 
) [inline]

Definition at line 116 of file STLExtras.h.

Referenced by llvm::GraphTraits< Inverse< const MSchedGraphSB * > >::nodes_begin(), llvm::GraphTraits< Inverse< MSchedGraphSB * > >::nodes_begin(), llvm::GraphTraits< const MSchedGraphSB * >::nodes_begin(), llvm::GraphTraits< MSchedGraphSB * >::nodes_begin(), llvm::GraphTraits< Inverse< const MSchedGraph * > >::nodes_begin(), llvm::GraphTraits< Inverse< MSchedGraph * > >::nodes_begin(), llvm::GraphTraits< const MSchedGraph * >::nodes_begin(), llvm::GraphTraits< MSchedGraph * >::nodes_begin(), llvm::GraphTraits< DSGraph * >::nodes_begin(), llvm::GraphTraits< CallGraph * >::nodes_begin(), llvm::GraphTraits< Inverse< const MSchedGraphSB * > >::nodes_end(), llvm::GraphTraits< Inverse< MSchedGraphSB * > >::nodes_end(), llvm::GraphTraits< const MSchedGraphSB * >::nodes_end(), llvm::GraphTraits< MSchedGraphSB * >::nodes_end(), llvm::GraphTraits< Inverse< const MSchedGraph * > >::nodes_end(), llvm::GraphTraits< Inverse< MSchedGraph * > >::nodes_end(), llvm::GraphTraits< const MSchedGraph * >::nodes_end(), llvm::GraphTraits< MSchedGraph * >::nodes_end(), llvm::GraphTraits< DSGraph * >::nodes_end(), and llvm::GraphTraits< CallGraph * >::nodes_end().

template<typename ItTy, typename Dist>
ItTy llvm::next ( ItTy  it,
Dist  n 
) [inline]

Definition at line 130 of file STLExtras.h.

Referenced by lt_dlexit(), lt_dlloader_next(), llvm::LiveInterval::removeRange(), llvm::ilist_traits< MachineBasicBlock >::setNext(), and llvm::ilist_traits< MachineInstr >::setNext().

template<typename ItTy>
ItTy llvm::next ( ItTy  it  )  [inline]

Definition at line 137 of file STLExtras.h.

template<typename ItTy, typename Dist>
ItTy llvm::prior ( ItTy  it,
Dist  n 
) [inline]

Definition at line 144 of file STLExtras.h.

Referenced by DeleteInstruction(), llvm::X86RegisterInfo::emitEpilogue(), llvm::SparcRegisterInfo::emitEpilogue(), llvm::PPCRegisterInfo::emitEpilogue(), llvm::IA64RegisterInfo::emitEpilogue(), llvm::AlphaRegisterInfo::emitEpilogue(), and llvm::LiveInterval::getLiveRangeContaining().

template<typename ItTy>
ItTy llvm::prior ( ItTy  it  )  [inline]

Definition at line 151 of file STLExtras.h.

template<typename T1, typename T2>
tier<T1, T2> llvm::tie ( T1 &  f,
T2 &  s 
) [inline]

Definition at line 198 of file STLExtras.h.

Referenced by llvm::ProgramInfo::getSourceFile(), llvm::LiveVariables::instructionChanged(), and llvm::TypeMap< ValType, TypeClass >::RefineAbstractType().

static std::string llvm::utohexstr ( uint64_t  X  )  [inline, static]

Definition at line 24 of file StringExtras.h.

References Buffer, and Mod.

Referenced by WriteConstantInt().

static std::string llvm::utostr ( unsigned long long  X,
bool  isNeg = false 
) [inline, static]

Definition at line 42 of file StringExtras.h.

References Buffer.

Referenced by calcTypeName(), llvm::Compressor::compress(), llvm::MappingInfo::dumpAssembly(), llvm::Archive::fillHeader(), getTypeDescription(), llvm::ValueSymbolTable::getUniqueName(), llvm::TypeSymbolTable::getUniqueName(), llvm::SymbolTable::getUniqueName(), getValNonImprovising(), llvm::Mangler::getValueName(), InsertCodeToShowFunctionEntry(), itostr(), llvm::BytecodeReader::ParseConstantPool(), llvm::BytecodeReader::ParseModule(), llvm::BytecodeReader::ParseModuleGlobalInfo(), llvm::BytecodeReader::ParseType(), llvm::Function::renameLocalSymbols(), SRAGlobal(), utostr(), and yyerror().

static std::string llvm::utostr ( unsigned long  X,
bool  isNeg = false 
) [inline, static]

Definition at line 58 of file StringExtras.h.

References utostr().

static std::string llvm::utostr ( unsigned  X,
bool  isNeg = false 
) [inline, static]

Definition at line 62 of file StringExtras.h.

References Buffer.

static std::string llvm::itostr ( long long  X  )  [inline, static]

Definition at line 79 of file StringExtras.h.

References utostr().

Referenced by llvm::Debugger::contProgram(), llvm::Debugger::finishProgram(), llvm::DOTGraphTraits< MSchedGraphSB * >::getEdgeSourceLabel(), llvm::DOTGraphTraits< MSchedGraph * >::getEdgeSourceLabel(), llvm::ValID::getName(), getTypeVal(), getValNonImprovising(), llvm::Debugger::nextProgram(), llvm::BytecodeReader::ParseVersionInfo(), ResolveDefinitions(), and llvm::Debugger::stepProgram().

static std::string llvm::itostr ( long  X  )  [inline, static]

Definition at line 86 of file StringExtras.h.

References utostr().

static std::string llvm::itostr ( int  X  )  [inline, static]

Definition at line 93 of file StringExtras.h.

References utostr().

static std::string llvm::ftostr ( double  V  )  [inline, static]

Definition at line 100 of file StringExtras.h.

References B, and Buffer.

Referenced by CompareNumbers(), llvm::ValID::getName(), isFPCSafeToPrint(), and WriteConstantInt().

static std::string llvm::LowercaseString ( const std::string &  S  )  [inline, static]

Definition at line 108 of file StringExtras.h.

Referenced by llvm::SubtargetFeatures::AddFeature(), llvm::SubtargetFeatures::setCPU(), and llvm::SubtargetFeatures::setString().

static bool llvm::StringsEqualNoCase ( const std::string &  LHS,
const std::string &  RHS 
) [inline, static]

StringsEqualNoCase - Return true if the two strings are equal, ignoring case.

Definition at line 118 of file StringExtras.h.

static bool llvm::StringsEqualNoCase ( const std::string &  LHS,
const char *  RHS 
) [inline, static]

StringsEqualNoCase - Return true if the two strings are equal, ignoring case.

Definition at line 128 of file StringExtras.h.

std::string llvm::getToken ( std::string &  Source,
const char *  Delimiters 
)

getToken - This function extracts one token from source, ignoring any leading characters that appear in the Delimiters string, and ending the token at any of the characters that appear in the Delimiters string. If there are no tokens in the source string, an empty string is returned. The Source source string is updated in place to remove the returned string and any delimiter prefix from it.

Definition at line 23 of file StringExtras.cpp.

Referenced by llvm::Debugger::loadProgram().

template<typename T>
std::vector<T> llvm::make_vector ( T  A,
  ... 
) [inline]

make_vector - Helper function which is useful for building temporary vectors to pass into type construction of CallInst ctors. This turns a null terminated list of pointers (or other value types) into a real live vector.

Definition at line 28 of file VectorExtras.h.

References T, and Val.

void llvm::BasicAAStub (  ) 

Definition at line 30 of file BasicAliasAnalysis.cpp.

static IncludeFile llvm::HDR_INCLUDE_BASICAA_CPP ( (void *)&  BasicAAStub  )  [static]

std::ostream& llvm::operator<< ( std::ostream &  OS,
const AliasSet &  AS 
) [inline]

Definition at line 240 of file AliasSetTracker.h.

References llvm::AliasSet::print().

std::ostream& llvm::operator<< ( std::ostream &  OS,
const AliasSetTracker &  AST 
) [inline]

Definition at line 375 of file AliasSetTracker.h.

References AST, and llvm::AliasSetTracker::print().

void llvm::BasicCallGraphStub (  ) 

Definition at line 22 of file CallGraph.cpp.

static IncludeFile llvm::HDR_INCLUDE_CALLGRAPH_CPP ( (void *)&  BasicCallGraphStub  )  [static]

FunctionPass* llvm::createCFGPrinterPass (  ) 

Definition at line 197 of file CFGPrinter.cpp.

FunctionPass* llvm::createCFGOnlyPrinterPass (  ) 

Definition at line 201 of file CFGPrinter.cpp.

bool llvm::canConstantFoldCallTo ( Function F  ) 

canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function.

Definition at line 34 of file Analysis/ConstantFolding.cpp.

References llvm::Intrinsic::bswap_i16, llvm::Intrinsic::bswap_i32, llvm::Intrinsic::bswap_i64, F, llvm::Intrinsic::isunordered_f32, llvm::Intrinsic::isunordered_f64, Name, llvm::Intrinsic::sqrt_f32, and llvm::Intrinsic::sqrt_f64.

Referenced by CanConstantFold(), and ConstantFoldInstruction().

Constant* llvm::ConstantFoldFP ( double(*)(double)  NativeFP,
double  V,
const Type Ty 
)

ConstantFoldFP - Given a function that evaluates the constant, return an LLVM Constant that represents the evaluated constant

Definition at line 88 of file Analysis/ConstantFolding.cpp.

References llvm::ConstantFP::get(), and Ty.

Referenced by ConstantFoldCall().

Constant* llvm::ConstantFoldCall ( Function F,
const std::vector< Constant * > &  Operands 
)

ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified arguments, returning null if unsuccessful.

Definition at line 99 of file Analysis/ConstantFolding.cpp.

References ByteSwap_16(), ByteSwap_32(), ByteSwap_64(), ConstantFoldFP(), F, llvm::ConstantFP::get(), llvm::ConstantUInt::get(), llvm::ConstantBool::get(), IsNAN(), Name, Op, Ty, and V.

Referenced by ConstantFold(), ConstantFoldInstruction(), and EvaluateFunction().

constant_iterator llvm::constant_begin ( const Function *  F  )  [inline]

Definition at line 84 of file ConstantsScanner.h.

References F.

Referenced by llvm::SlotCalculator::incorporateFunction().

constant_iterator llvm::constant_end ( const Function *  F  )  [inline]

Definition at line 88 of file ConstantsScanner.h.

References F.

Referenced by llvm::SlotCalculator::incorporateFunction().

FunctionPass* llvm::createDataStructureStatsPass (  ) 

Definition at line 66 of file DataStructureStats.cpp.

FunctionPass* llvm::createDataStructureGraphCheckerPass (  ) 

Definition at line 80 of file GraphChecker.cpp.

static DSNode& llvm::dereference ( DSNode *  N  )  [static]

Definition at line 112 of file DSGraphTraits.h.

Referenced by llvm::GraphTraits< DSGraph * >::nodes_begin(), and llvm::GraphTraits< DSGraph * >::nodes_end().

static const DSNode& llvm::dereferenceC ( const DSNode *  N  )  [static]

Definition at line 113 of file DSGraphTraits.h.

Interval::succ_iterator llvm::succ_begin ( Interval *  I  )  [inline]

succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the succ_* functions, and *succ_iterator.

Definition at line 107 of file Interval.h.

References llvm::Interval::Successors.

Referenced by AddPredecessorToBlock(), CalcRegionExitBlocks(), CanPropagatePredecessorsForPHIs(), llvm::GraphTraits< const SchedGraph * >::child_begin(), llvm::GraphTraits< SchedGraph * >::child_begin(), llvm::GraphTraits< Interval * >::child_begin(), llvm::GraphTraits< const BasicBlock * >::child_begin(), llvm::GraphTraits< BasicBlock * >::child_begin(), doDFS(), llvm::DOTGraphTraits< const Function * >::getEdgeSourceLabel(), llvm::Loop::getExitBlocks(), llvm::Loop::getLoopPreheader(), HoistThenElseCodeToIf(), llvm::Loop::isLoopExit(), isTrivialLoopExitBlockHelper(), MarkAliveBlocks(), MarkSuccessorsReady(), llvm::PostDominatorSet::runOnFunction(), llvm::ImmediatePostDominators::runOnFunction(), SafeToMergeTerminators(), SimplifyCFG(), SimplifyEqualityComparisonWithOnlyPredecessor(), and llvm::BasicBlock::splitBasicBlock().

Interval::succ_iterator llvm::succ_end ( Interval *  I  )  [inline]

Definition at line 110 of file Interval.h.

References llvm::Interval::Successors.

Referenced by AddPredecessorToBlock(), CalcRegionExitBlocks(), llvm::GraphTraits< const SchedGraph * >::child_end(), llvm::GraphTraits< SchedGraph * >::child_end(), llvm::GraphTraits< Interval * >::child_end(), llvm::GraphTraits< const BasicBlock * >::child_end(), llvm::GraphTraits< BasicBlock * >::child_end(), doDFS(), llvm::Loop::getExitBlocks(), llvm::Loop::getLoopPreheader(), HoistThenElseCodeToIf(), llvm::Loop::isLoopExit(), isTrivialLoopExitBlockHelper(), MarkAliveBlocks(), MarkSuccessorsReady(), llvm::IntervalIterator< NodeTy, OrigContainer_t, GT, IGT >::operator++(), llvm::PostDominatorSet::runOnFunction(), llvm::ImmediatePostDominators::runOnFunction(), SafeToMergeTerminators(), SimplifyCFG(), SimplifyEqualityComparisonWithOnlyPredecessor(), and llvm::BasicBlock::splitBasicBlock().

Interval::pred_iterator llvm::pred_begin ( Interval *  I  )  [inline]

pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the pred_* functions, and *pred_iterator.

Definition at line 117 of file Interval.h.

References llvm::Interval::Predecessors.

Referenced by AddBlockAndPredsToSet(), llvm::BBLiveVar::applyFlowFunc(), CanPropagatePredecessorsForPHIs(), llvm::GraphTraits< Inverse< Interval * > >::child_begin(), llvm::GraphTraits< Inverse< const BasicBlock * > >::child_begin(), llvm::GraphTraits< Inverse< BasicBlock * > >::child_begin(), FindObviousSharedDomOf(), FindUsefulInstructionsForDelaySlots(), FoldTwoEntryPHINode(), FoldValueComparisonIntoPredecessors(), llvm::Loop::getCanonicalInductionVariable(), llvm::ProfileInfo::getExecutionCount(), GetIfCondition(), llvm::Loop::getLoopLatch(), llvm::Loop::getLoopPreheader(), llvm::Loop::getNumBackEdges(), llvm::BasicBlock::getSinglePredecessor(), isCriticalEdge(), llvm::Interval::isLoop(), isPathTransparentTo(), isValueEqualityComparison(), MarkBlocksLiveIn(), MarkSuccessorsReady(), llvm::BasicBlock::removePredecessor(), llvm::DominatorSet::runOnFunction(), llvm::ImmediateDominators::runOnFunction(), SimplifyCFG(), TryToSimplifyUncondBranchFromEmptyBlock(), and llvm::SCEVExpander::visitAddRecExpr().

Interval::pred_iterator llvm::pred_end ( Interval *  I  )  [inline]

Definition at line 120 of file Interval.h.

References llvm::Interval::Predecessors.

Referenced by AddBlockAndPredsToSet(), llvm::BBLiveVar::applyFlowFunc(), CanPropagatePredecessorsForPHIs(), llvm::GraphTraits< Inverse< Interval * > >::child_end(), llvm::GraphTraits< Inverse< const BasicBlock * > >::child_end(), llvm::GraphTraits< Inverse< BasicBlock * > >::child_end(), FindObviousSharedDomOf(), FindUsefulInstructionsForDelaySlots(), FoldValueComparisonIntoPredecessors(), llvm::Loop::getCanonicalInductionVariable(), llvm::ProfileInfo::getExecutionCount(), GetIfCondition(), llvm::Loop::getLoopLatch(), llvm::Loop::getLoopPreheader(), llvm::Loop::getNumBackEdges(), llvm::BasicBlock::getSinglePredecessor(), isCriticalEdge(), llvm::Interval::isLoop(), isPathTransparentTo(), isValueEqualityComparison(), MarkBlocksLiveIn(), MarkSuccessorsReady(), llvm::BasicBlock::removePredecessor(), llvm::DominatorSet::runOnFunction(), llvm::ImmediateDominators::runOnFunction(), SimplifyCFG(), TryToSimplifyUncondBranchFromEmptyBlock(), and llvm::SCEVExpander::visitAddRecExpr().

BasicBlock* llvm::getNodeHeader ( BasicBlock *  BB  )  [inline]

Definition at line 49 of file IntervalIterator.h.

References BB.

BasicBlock* llvm::getNodeHeader ( Interval *  I  )  [inline]

Definition at line 50 of file IntervalIterator.h.

References llvm::Interval::getHeaderNode().

BasicBlock* llvm::getSourceGraphNode ( Function *  ,
BasicBlock *  BB 
) [inline]

Definition at line 56 of file IntervalIterator.h.

References BB.

Referenced by llvm::IntervalIterator< NodeTy, OrigContainer_t, GT, IGT >::operator++().

Interval* llvm::getSourceGraphNode ( IntervalPartition *  IP,
BasicBlock *  BB 
) [inline]

Definition at line 59 of file IntervalIterator.h.

References BB, and llvm::IntervalPartition::getBlockInterval().

void llvm::addNodeToInterval ( Interval *  Int,
BasicBlock *  BB 
) [inline]

Definition at line 68 of file IntervalIterator.h.

References BB, and llvm::Interval::Nodes.

void llvm::addNodeToInterval ( Interval *  Int,
Interval *  I 
) [inline]

Definition at line 79 of file IntervalIterator.h.

References llvm::Interval::Nodes.

function_interval_iterator llvm::intervals_begin ( Function *  F,
bool  DeleteInts = true 
) [inline]

Definition at line 239 of file IntervalIterator.h.

References F.

Referenced by llvm::IntervalPartition::IntervalPartition(), and llvm::IntervalPartition::runOnFunction().

function_interval_iterator llvm::intervals_end ( Function *   )  [inline]

Definition at line 243 of file IntervalIterator.h.

Referenced by llvm::IntervalPartition::IntervalPartition(), and llvm::IntervalPartition::runOnFunction().

interval_part_interval_iterator llvm::intervals_begin ( IntervalPartition &  IP,
bool  DeleteIntervals = true 
) [inline]

Definition at line 248 of file IntervalIterator.h.

interval_part_interval_iterator llvm::intervals_end ( IntervalPartition &  IP  )  [inline]

Definition at line 252 of file IntervalIterator.h.

FunctionPass* llvm::createLoadValueNumberingPass (  ) 

createLoadValueNumberingPass - Create and return a new pass that implements the ValueNumbering interface.

Definition at line 90 of file LoadValueNumbering.cpp.

Pass* llvm::createGlobalsModRefPass (  ) 

Definition at line 143 of file GlobalsModRef.cpp.

ModulePass* llvm::createAliasAnalysisCounterPass (  ) 

Definition at line 117 of file AliasAnalysisCounter.cpp.

FunctionPass* llvm::createAAEvalPass (  ) 

Definition at line 77 of file AliasAnalysisEvaluator.cpp.

ImmutablePass* llvm::createNoAAPass (  ) 

Definition at line 84 of file BasicAliasAnalysis.cpp.

ImmutablePass* llvm::createBasicAliasAnalysisPass (  ) 

Definition at line 129 of file BasicAliasAnalysis.cpp.

ModulePass* llvm::createAndersensPass (  ) 

Definition at line 343 of file Andersens.cpp.

ImmutablePass* llvm::createBasicVNPass (  ) 

Definition at line 90 of file ValueNumbering.cpp.

ModulePass* llvm::createProfileLoaderPass (  ) 

Definition at line 59 of file ProfileInfoLoaderPass.cpp.

ImmutablePass* llvm::createNoProfileInfoPass (  ) 

Definition at line 95 of file ProfileInfo.cpp.

ModulePass* llvm::createDSAAPass (  ) 

Definition at line 105 of file DataStructureAA.cpp.

ModulePass* llvm::createDSOptPass (  ) 

Definition at line 53 of file DataStructureOpt.cpp.

ModulePass* llvm::createSteensgaardPass (  ) 

Definition at line 83 of file Steensgaard.cpp.

FunctionPass* llvm::createInstCountPass (  ) 

Definition at line 62 of file InstCount.cpp.

Pass* llvm::createProfileLoaderPass ( const std::string &  Filename  ) 

createProfileLoaderPass - This function returns a Pass that loads the profiling information for the module from the specified filename, making it available to the optimizers.

Definition at line 64 of file ProfileInfoLoaderPass.cpp.

std::ostream& llvm::operator<< ( std::ostream &  OS,
const SCEV &  S 
) [inline]

Definition at line 106 of file ScalarEvolution.h.

References llvm::SCEV::print().

void llvm::BasicValueNumberingStub (  ) 

Definition at line 236 of file ValueNumbering.cpp.

static IncludeFile llvm::HDR_INCLUDE_VALUENUMBERING_CPP ( (void *)&  BasicValueNumberingStub  )  [static]

FunctionPass* llvm::createVerifierPass ( VerifierFailureAction  action = AbortProcessAction  ) 

Create a verifier pass.

Check a module or function for validity. When the pass is used, the action indicated by the action argument will be used if errors are found.

Parameters:
action  Action to take

bool llvm::verifyModule ( const Module &  M,
VerifierFailureAction  action = AbortProcessAction 
)

Check a module for errors.

If there are no errors, the function returns false. If an error is found, the action taken depends on the action parameter. This should only be used for debugging, because it plays games with PassManagers and stuff.

Parameters:
M  The module to be verified
action  Action to take

bool llvm::verifyFunction ( const Function &  F,
VerifierFailureAction  action = AbortProcessAction 
)

Parameters:
F  The function to be verified
action  Action to take

Function* llvm::UpgradeIntrinsicFunction ( Function F  ) 

Remove overloaded intrinsic function names.

This function inspects the Function F to see if it is an old overloaded intrinsic. If it is, the Function's name is changed to add a suffix that indicates the kind of arguments or result that it accepts. In LLVM release 1.7, the overloading of intrinsic functions was replaced with separate functions for each of the various argument sizes. This function implements the auto-upgrade feature from the old overloaded names to the new non-overloaded names.

Parameters:
F The Function to potentially auto-upgrade.
Returns:
A corrected version of F, or 0 if no change necessary

Definition at line 192 of file AutoUpgrade.cpp.

References F, getUpgradedIntrinsic(), and R.

Referenced by UpgradeCallsToIntrinsic().

void llvm::UpgradeIntrinsicCall ( CallInst CI,
Function newF = 0 
)

Get replacement instruction for overloaded intrinsic function call.

In LLVM 1.7, the overloading of intrinsic functions was replaced with separate functions for each of the various argument sizes. This function implements the auto-upgrade feature from old overloaded names to the new non-overloaded names. This function inspects the CallInst CI to see if it is a call to an old overloaded intrinsic. If it is, a new CallInst is created that uses the correct Function and possibly casts the argument and result to an unsigned type.

Parameters:
CI The CallInst to potentially auto-upgrade.

Definition at line 217 of file AutoUpgrade.cpp.

References CastArg(), llvm::Instruction::eraseFromParent(), F, llvm::UndefValue::get(), getArgumentPermutation(), llvm::CallInst::getCalledFunction(), llvm::CallInst::getCallingConv(), llvm::Function::getFunctionType(), llvm::Value::getName(), llvm::User::getNumOperands(), llvm::FunctionType::getNumParams(), llvm::User::getOperand(), llvm::FunctionType::getParamType(), llvm::Function::getReturnType(), llvm::Value::getType(), llvm::CallInst::isTailCall(), llvm::Instruction::moveBefore(), llvm::Value::replaceAllUsesWith(), llvm::CallInst::setCallingConv(), llvm::CallInst::setTailCall(), llvm::Value::use_empty(), V, and llvm::Type::VoidTy.

Referenced by llvm::BytecodeReader::ParseFunctionBody(), and UpgradeCallsToIntrinsic().

bool llvm::UpgradeCallsToIntrinsic ( Function F  ) 

Upgrade both the function and all the calls made to it, if that function needs to be upgraded. This is like a combination of the above two functions, UpgradeIntrinsicFunction and UpgradeIntrinsicCall. Note that the calls are replaced so this should only be used in a post-processing manner (i.e. after all assembly/bytecode has been read).

Definition at line 275 of file AutoUpgrade.cpp.

References F, UpgradeIntrinsicCall(), and UpgradeIntrinsicFunction().

Referenced by PerModuleInfo::ModuleDone().

Module* llvm::ParseAssemblyFile ( const std::string &  Filename  ) 

Definition at line 21 of file Parser.cpp.

References F, and RunVMAsmParser().

Module* llvm::ParseAssemblyString ( const char *  AsmString,
Module M 
)

Definition at line 45 of file Parser.cpp.

References M, and RunVMAsmParser().

std::ostream& llvm::WriteTypeSymbolic ( std::ostream &  Out,
const Type Ty,
const Module M 
)

WriteTypeSymbolic - This attempts to write the specified type as a symbolic type, iff there is an entry in the modules symbol table for the specified type or one of it's component types. This is slower than a simple x << Type

Definition at line 385 of file AsmWriter.cpp.

References fillTypeNameTable(), llvm::Type::getDescription(), M, printTypeInt(), Ty, and TypeNames.

Referenced by llvm::AsmPrinter::EmitConstantPool(), getCaption(), llvm::DSNode::mergeTypeInfo(), llvm::CachedWriter::operator<<(), ProcessGlobalsWithSameName(), ResolveFunctions(), and ToStr().

std::ostream& llvm::WriteAsOperand ( std::ostream &  Out,
const Value V,
bool  PrintType,
bool  PrintName,
const Module Context 
)

WriteAsOperand - Write the name of the specified value out to the specified ostream. This can be useful when you just want to print int reg126, not the whole instruction that generated it.

Definition at line 603 of file AsmWriter.cpp.

Referenced by llvm::DOTGraphTraits< const DSGraph * >::addCustomGraphFeatures(), llvm::SDNode::dump(), getCaption(), llvm::DOTGraphTraits< const Function * >::getNodeLabel(), InsertCodeToShowFunctionEntry(), InsertCodeToShowFunctionExit(), InsertVerbosePrintInst(), operator<<(), operator<<(), llvm::Trace::print(), llvm::SCEVUnknown::print(), llvm::SCEVConstant::print(), llvm::Loop::print(), llvm::ETForestBase::print(), llvm::DominanceFrontierBase::print(), llvm::DominatorSetBase::print(), llvm::ImmediateDominatorsBase::print(), llvm::Argument::print(), llvm::InlineAsm::print(), llvm::AliasSet::print(), PrintModRefResults(), PrintOps(), PrintResults(), ResolveFunctions(), and TraceValuesAtBBExit().

std::ostream& llvm::WriteAsOperand ( std::ostream &  Out,
const Type Ty,
bool  PrintType,
bool  PrintName,
const Module Context 
)

WriteAsOperand - Write the name of the specified value out to the specified ostream. This can be useful when you just want to print int reg126, not the whole instruction that generated it.

Definition at line 644 of file AsmWriter.cpp.

References fillTypeNameTable(), printTypeInt(), Ty, TypeNames, and WriteAsOperandInternal().

Module* llvm::AnalyzeBytecodeFile ( const std::string &  Filename,
BytecodeAnalysis Results,
std::string *  ErrorStr = 0,
std::ostream *  output = 0 
)

Analyze contents of a bytecode File.

This function is the main entry point into the bytecode analysis library. It allows you to simply provide a filename and storage for the Results that will be filled in with the analysis results.

Parameters:
Filename  The name of the bytecode file to read
Results  The results of the analysis
ErrorStr  Errors, if any.
output  Stream for dump output, if wanted

Definition at line 306 of file ReaderWrappers.cpp.

References bca, createBytecodeAnalyzerHandler(), and getBytecodeModuleProvider().

Module* llvm::AnalyzeBytecodeBuffer ( const unsigned char *  Buffer,
unsigned  BufferSize,
const std::string &  ModuleID,
BytecodeAnalysis Results,
std::string *  ErrorStr = 0,
std::ostream *  output = 0 
)

Analyze contents of a bytecode buffer.

This function is an alternate entry point into the bytecode analysis library. It allows you to provide an arbitrary memory buffer which is assumed to contain a complete bytecode file. The Buffer is analyzed and the Results are filled in.

Parameters:
Buffer  Pointer to start of bytecode buffer
BufferSize  Size of the bytecode buffer
ModuleID  Identifier for the module
Results  The results of the analysis
ErrorStr  Errors, if any.
output  Stream for dump output, if wanted

Definition at line 325 of file ReaderWrappers.cpp.

References bca, createBytecodeAnalyzerHandler(), and getBytecodeBufferModuleProvider().

void llvm::PrintBytecodeAnalysis ( BytecodeAnalysis bca,
std::ostream &  Out 
)

Print BytecodeAnalysis structure to an ostream.

This function prints the contents of rhe BytecodeAnalysis structure in a human legible form.

Definition at line 621 of file Analyzer.cpp.

References bca, llvm::BytecodeAnalysis::BlockSizes, llvm::BytecodeAnalysis::byteSize, llvm::BytecodeFormat::CompactionTableBlockID, llvm::BytecodeFormat::ConstantPoolBlockID, llvm::BytecodeAnalysis::detailedResults, E, llvm::BytecodeAnalysis::fileDensity, llvm::BytecodeFormat::FunctionBlockID, llvm::BytecodeAnalysis::functionDensity, llvm::BytecodeAnalysis::FunctionInfo, llvm::BytecodeAnalysis::globalsDensity, llvm::BytecodeFormat::GlobalTypePlaneBlockID, I, llvm::BytecodeFormat::InstructionListBlockID, llvm::BytecodeAnalysis::instructionSize, llvm::BytecodeAnalysis::libSize, llvm::BytecodeAnalysis::longInstructions, llvm::BytecodeAnalysis::maxTypeSlot, llvm::BytecodeAnalysis::maxValueSlot, llvm::BytecodeFormat::ModuleBlockID, llvm::BytecodeFormat::ModuleGlobalInfoBlockID, llvm::BytecodeAnalysis::ModuleId, llvm::BytecodeAnalysis::numAlignment, llvm::BytecodeAnalysis::numBasicBlocks, llvm::BytecodeAnalysis::numBlocks, llvm::BytecodeAnalysis::numCmpctnTables, llvm::BytecodeAnalysis::numConstants, llvm::BytecodeAnalysis::numFunctions, llvm::BytecodeAnalysis::numGlobalVars, llvm::BytecodeAnalysis::numInstructions, llvm::BytecodeAnalysis::numLibraries, llvm::BytecodeAnalysis::numOperands, llvm::BytecodeAnalysis::numSymTab, llvm::BytecodeAnalysis::numTypes, llvm::BytecodeAnalysis::numValues, print(), llvm::BytecodeAnalysis::progressiveVerify, llvm::BytecodeFormat::Reserved_DoNotUse, llvm::BytecodeFormat::SymbolTableBlockID, llvm::BytecodeAnalysis::vbrCompBytes, llvm::BytecodeAnalysis::vbrCount32, llvm::BytecodeAnalysis::vbrCount64, llvm::BytecodeAnalysis::vbrExpdBytes, llvm::BytecodeAnalysis::VerifyInfo, and llvm::BytecodeAnalysis::version.

Referenced by operator<<().

std::ostream& llvm::operator<< ( std::ostream &  Out,
BytecodeAnalysis &  bca 
) [inline]

std::ostream inserter for BytecodeAnalysis structure

Definition at line 137 of file Analyzer.h.

References bca, and PrintBytecodeAnalysis().

ModuleProvider* llvm::getBytecodeModuleProvider ( const std::string &  Filename,
BytecodeHandler H 
)

getBytecodeModuleProvider - lazy function-at-a-time loading from a file

Parameters:
Filename  Name of file to be read
H  Optional handler for reader events

Definition at line 284 of file ReaderWrappers.cpp.

References CheckVarargs(), and H.

Referenced by AnalyzeBytecodeFile(), GetBytecodeDependentLibraries(), GetBytecodeSymbols(), getMaterializedModuleProvider(), and ParseBytecodeFile().

ModuleProvider* llvm::getBytecodeBufferModuleProvider ( const unsigned char *  Buffer,
unsigned  Length,
const std::string &  ModuleID,
BytecodeHandler H 
)

getBytecodeBufferModuleProvider - lazy function-at-a-time loading from a buffer

Definition at line 259 of file ReaderWrappers.cpp.

References CheckVarargs(), and H.

Referenced by AnalyzeBytecodeBuffer(), llvm::Archive::findModuleDefiningSymbol(), GetBytecodeSymbols(), and ParseBytecodeBuffer().

Module* llvm::ParseBytecodeFile ( const std::string &  Filename,
std::string *  ErrorStr 
)

Parse the given bytecode file.

ParseBytecodeFile - Parse the given bytecode file

Definition at line 294 of file ReaderWrappers.cpp.

References getBytecodeModuleProvider().

Module* llvm::ParseBytecodeBuffer ( const unsigned char *  Buffer,
unsigned  Length,
const std::string &  ModuleID,
std::string *  ErrorStr 
)

Parse a given bytecode buffer.

ParseBytecodeBuffer - Parse a given bytecode buffer

Definition at line 269 of file ReaderWrappers.cpp.

References getBytecodeBufferModuleProvider().

Referenced by llvm::Archive::getAllModules(), and llvm::Archive::isBytecodeArchive().

bool llvm::GetBytecodeDependentLibraries ( const std::string &  fileName,
Module::LibraryListType deplibs 
)

Get the list of dependent libraries from a bytecode file.

This function will read only the necessary parts of a bytecode file in order to determine the list of dependent libraries encoded within it. The deplibs parameter will contain a vector of strings of the bytecode module's dependent libraries.

Returns:
true on success, false otherwise

Definition at line 345 of file ReaderWrappers.cpp.

References llvm::SetVector< T >::clear(), getBytecodeModuleProvider(), llvm::Module::getLibraries(), and M.

bool llvm::GetBytecodeSymbols ( const sys::Path fileName,
std::vector< std::string > &  syms 
)

Get a bytecode file's externally visibile defined global symbols.

This function will read only the necessary parts of a bytecode file in order to obtain a list of externally visible global symbols that the bytecode module defines. This is used for archiving and linking when only the list of symbols the module defines is needed.

Returns:
true on success, false otherwise

Definition at line 375 of file ReaderWrappers.cpp.

Referenced by llvm::Archive::findModulesDefiningSymbols(), and llvm::Archive::writeMember().

ModuleProvider* llvm::GetBytecodeSymbols ( const unsigned char *  Buffer,
unsigned  Length,
const std::string &  ModuleID,
std::vector< std::string > &  symbols 
)

Get a bytecode file's externally visibile defined global symbols.

This function will read only the necessary parts of a bytecode buffer in order to obtain a list of externally visible global symbols that the bytecode module defines. This is used for archiving and linking when only the list of symbols the module defines is needed and the bytecode is already in memory.

Returns:
the ModuleProvider on success, 0 if the bytecode can't be parsed
Parameters:
Buffer  The buffer to be parsed
Length  The length of Buffer
ModuleID  An identifier for the module
symbols  The symbols defined in the module

Definition at line 396 of file ReaderWrappers.cpp.

References getBytecodeBufferModuleProvider(), getSymbols(), M, and llvm::ModuleProvider::materializeModule().

void llvm::WriteBytecodeToFile ( const Module M,
std::ostream &  Out,
bool  compress = true 
)

Definition at line 1206 of file Bytecode/Writer/Writer.cpp.

References Buffer, BytesWritten, llvm::Compressor::compressToStream(), and M.

Referenced by llvm::WriteBytecodePass::runOnModule().

FunctionPass * llvm::createInstructionSchedulingWithSSAPass ( const TargetMachine &  TM  ) 

Definition at line 1494 of file InstrScheduling.cpp.

std::ostream& llvm::operator<< ( std::ostream &  os,
const LiveRange LR 
)

Definition at line 401 of file LiveInterval.cpp.

bool llvm::operator< ( unsigned  V,
const LiveRange &  LR 
) [inline]

Definition at line 63 of file LiveInterval.h.

References llvm::LiveRange::start.

bool llvm::operator< ( const LiveRange &  LR,
unsigned  V 
) [inline]

Definition at line 67 of file LiveInterval.h.

References llvm::LiveRange::start.

std::ostream& llvm::operator<< ( std::ostream &  OS,
const LiveInterval &  LI 
) [inline]

Definition at line 199 of file LiveInterval.h.

References LI, and llvm::LoopInfo::print().

std::ostream & llvm::operator<< ( std::ostream &  OS,
const MachineInstr MI 
)

Definition at line 369 of file MachineInstr.cpp.

References llvm::MachineInstr::getImplicitOp(), llvm::MachineInstr::getImplicitRef(), llvm::MachineInstr::getNumImplicitRefs(), llvm::MachineInstr::getNumOperands(), llvm::MachineInstr::getOpcode(), llvm::MachineInstr::getOperand(), llvm::MachineBasicBlock::getParent(), llvm::MachineInstr::getParent(), llvm::MachineFunction::getTarget(), llvm::MachineOperand::isDef(), llvm::MachineOperand::isUse(), MBB, MF, MI, llvm::TargetInstrDescriptor::Name, OutputValue(), llvm::MachineInstr::print(), and TargetInstrDescriptors.

std::ostream & llvm::operator<< ( std::ostream &  OS,
const MachineOperand MO 
)

Definition at line 412 of file MachineInstr.cpp.

References llvm::MachineBasicBlock::getBasicBlock(), llvm::MachineOperand::getConstantPoolIndex(), llvm::MachineOperand::getFrameIndex(), llvm::MachineOperand::getGlobal(), llvm::MachineOperand::getImmedValue(), llvm::MachineOperand::getMachineBasicBlock(), llvm::MachineOperand::getMachineRegNum(), llvm::Intrinsic::getName(), llvm::MachineOperand::getReg(), llvm::MachineOperand::getSymbolName(), llvm::MachineOperand::getType(), llvm::MachineOperand::getVRegValue(), llvm::MachineOperand::hasAllocatedReg(), llvm::MachineOperand::isHiBits32(), llvm::MachineOperand::isHiBits64(), llvm::MachineOperand::isLoBits32(), llvm::MachineOperand::isLoBits64(), llvm::MachineOperand::MO_CCRegister, llvm::MachineOperand::MO_ConstantPoolIndex, llvm::MachineOperand::MO_ExternalSymbol, llvm::MachineOperand::MO_FrameIndex, llvm::MachineOperand::MO_GlobalAddress, llvm::MachineOperand::MO_MachineBasicBlock, llvm::MachineOperand::MO_MachineRegister, llvm::MachineOperand::MO_PCRelativeDisp, llvm::MachineOperand::MO_SignExtendedImmed, llvm::MachineOperand::MO_UnextendedImmed, llvm::MachineOperand::MO_VirtualRegister, OutputReg(), and OutputValue().

void llvm::PrintMachineInstructions ( const Function *  F  ) 

MachineInstrBuilder llvm::BuildMI ( int  Opcode,
unsigned  NumOperands 
) [inline]

BuildMI - Builder interface. Specify how to create the initial instruction itself. NumOperands is the number of operands to the machine instruction to allow for memory efficient representation of machine instructions.

Definition at line 152 of file MachineInstrBuilder.h.

Referenced by BuildMI(), llvm::X86InstrInfo::commuteInstruction(), llvm::X86InstrInfo::convertToThreeAddress(), llvm::X86RegisterInfo::copyRegToReg(), llvm::SparcRegisterInfo::copyRegToReg(), llvm::PPCRegisterInfo::copyRegToReg(), llvm::IA64RegisterInfo::copyRegToReg(), llvm::AlphaRegisterInfo::copyRegToReg(), llvm::SparcV9RegInfo::cpMem2RegMI(), llvm::SparcV9RegInfo::cpReg2MemMI(), llvm::SparcV9RegInfo::cpReg2RegMI(), llvm::SparcV9RegInfo::cpValue2Value(), llvm::X86RegisterInfo::eliminateCallFramePseudoInstr(), llvm::SparcRegisterInfo::eliminateCallFramePseudoInstr(), llvm::PPCRegisterInfo::eliminateCallFramePseudoInstr(), llvm::IA64RegisterInfo::eliminateCallFramePseudoInstr(), llvm::AlphaRegisterInfo::eliminateCallFramePseudoInstr(), llvm::SparcRegisterInfo::eliminateFrameIndex(), llvm::PPCRegisterInfo::eliminateFrameIndex(), llvm::IA64RegisterInfo::eliminateFrameIndex(), llvm::AlphaRegisterInfo::eliminateFrameIndex(), llvm::X86RegisterInfo::emitEpilogue(), llvm::SparcRegisterInfo::emitEpilogue(), llvm::PPCRegisterInfo::emitEpilogue(), llvm::IA64RegisterInfo::emitEpilogue(), llvm::AlphaRegisterInfo::emitEpilogue(), llvm::X86RegisterInfo::emitPrologue(), llvm::SparcRegisterInfo::emitPrologue(), llvm::PPCRegisterInfo::emitPrologue(), llvm::IA64RegisterInfo::emitPrologue(), llvm::AlphaRegisterInfo::emitPrologue(), EmitSpecialCodeForMain(), llvm::SparcRegisterInfo::foldMemoryOperand(), llvm::PPCRegisterInfo::foldMemoryOperand(), llvm::AlphaRegisterInfo::foldMemoryOperand(), llvm::FunctionLoweringInfo::FunctionLoweringInfo(), HandleVRSaveUpdate(), llvm::X86TargetLowering::InsertAtEndOfBasicBlock(), llvm::PPCTargetLowering::InsertAtEndOfBasicBlock(), llvm::X86InstrInfo::insertGoto(), llvm::PPCInstrInfo::insertNoop(), llvm::X86RegisterInfo::loadRegFromStackSlot(), llvm::SparcRegisterInfo::loadRegFromStackSlot(), llvm::PPCRegisterInfo::loadRegFromStackSlot(), llvm::IA64RegisterInfo::loadRegFromStackSlot(), llvm::AlphaRegisterInfo::loadRegFromStackSlot(), llvm::IA64TargetLowering::LowerArguments(), MakeM0Inst(), MakeMIInst(), MakeMInst(), MakeMRIInst(), MakeMRInst(), MakeRMIInst(), MakeRMInst(), llvm::AlphaTargetLowering::restoreGP(), llvm::AlphaTargetLowering::restoreRA(), llvm::X86InstrInfo::reverseBranchCondition(), llvm::X86RegisterInfo::storeRegToStackSlot(), llvm::SparcRegisterInfo::storeRegToStackSlot(), llvm::PPCRegisterInfo::storeRegToStackSlot(), llvm::IA64RegisterInfo::storeRegToStackSlot(), and llvm::AlphaRegisterInfo::storeRegToStackSlot().

MachineInstrBuilder llvm::BuildMI ( int  Opcode,
unsigned  NumOperands,
unsigned  DestReg,
MachineOperand::UseType  useType = MachineOperand::Def 
) [inline]

BuildMI - This version of the builder sets up the first operand as a destination virtual register. NumOperands is the number of additional add* calls that are expected, not including the destination register.

Definition at line 160 of file MachineInstrBuilder.h.

References llvm::MachineInstrBuilder::addReg().

MachineInstrBuilder llvm::BuildMI ( MachineBasicBlock &  BB,
MachineBasicBlock::iterator  I,
int  Opcode,
unsigned  NumOperands,
unsigned  DestReg 
) [inline]

BuildMI - This version of the builder inserts the newly-built instruction before the given position in the given MachineBasicBlock, and sets up the first operand as a destination virtual register. NumOperands is the number of additional add* calls that are expected, not including the destination register.

Definition at line 174 of file MachineInstrBuilder.h.

References BB, and MI.

MachineInstrBuilder llvm::BuildMI ( MachineBasicBlock &  BB,
MachineBasicBlock::iterator  I,
int  Opcode,
unsigned  NumOperands 
) [inline]

BuildMI - This version of the builder inserts the newly-built instruction before the given position in the given MachineBasicBlock, and does NOT take a destination register.

Definition at line 187 of file MachineInstrBuilder.h.

References BB, and MI.

MachineInstrBuilder llvm::BuildMI ( MachineBasicBlock *  BB,
int  Opcode,
unsigned  NumOperands 
) [inline]

BuildMI - This version of the builder inserts the newly-built instruction at the end of the given MachineBasicBlock, and does NOT take a destination register.

Definition at line 199 of file MachineInstrBuilder.h.

References BB, BuildMI(), and llvm::BasicBlock::end().

MachineInstrBuilder llvm::BuildMI ( MachineBasicBlock *  BB,
int  Opcode,
unsigned  NumOperands,
unsigned  DestReg 
) [inline]

BuildMI - This version of the builder inserts the newly-built instruction at the end of the given MachineBasicBlock, and sets up the first operand as a destination virtual register. NumOperands is the number of additional add* calls that are expected, not including the destination register.

Definition at line 210 of file MachineInstrBuilder.h.

References BB, BuildMI(), and llvm::BasicBlock::end().

FunctionPass* llvm::createUnreachableBlockEliminationPass (  ) 

createUnreachableBlockEliminationPass - The LLVM code generator does not work well with unreachable basic blocks (what live ranges make sense for a block that cannot be reached?). As such, a code generator should either not instruction select unreachable blocks, or it can run this pass as it's last LLVM modifying pass to clean up blocks that are not reachable from the entry block.

Definition at line 41 of file UnreachableBlockElim.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createMachineFunctionPrinterPass ( std::ostream *  OS,
const std::string &  Banner 
)

Returns a newly-created MachineFunction Printer pass. The default output stream is std::cerr; the default banner is empty.

Definition at line 64 of file MachineFunction.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createRegisterAllocator (  ) 

Creates a register allocator as the user specified on the command line.

Definition at line 36 of file Passes.cpp.

References abort(), createLinearScanRegisterAllocator(), createLocalRegisterAllocator(), createSimpleRegisterAllocator(), local, and RegAlloc.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createSimpleRegisterAllocator (  ) 

SimpleRegisterAllocation Pass - This pass converts the input machine code from SSA form to use explicit registers by spilling every register. Wow, great policy huh?

Definition at line 246 of file RegAllocSimple.cpp.

Referenced by createRegisterAllocator().

FunctionPass* llvm::createLocalRegisterAllocator (  ) 

LocalRegisterAllocation Pass - This pass register allocates the input code a basic block at a time, yielding code better than the simple register allocator, but not as good as a global allocator.

Definition at line 694 of file RegAllocLocal.cpp.

Referenced by createRegisterAllocator().

FunctionPass* llvm::createLinearScanRegisterAllocator (  ) 

LinearScanRegisterAllocation Pass - This pass implements the linear scan register allocation algorithm, a global register allocator.

Definition at line 763 of file RegAllocLinearScan.cpp.

Referenced by createRegisterAllocator().

FunctionPass* llvm::createPrologEpilogCodeInserter (  ) 

createPrologEpilogCodeInserter - This function returns a pass that inserts prolog and epilog code, and eliminates abstract frame references.

Definition at line 94 of file PrologEpilogInserter.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createBranchFoldingPass (  ) 

BranchFolding Pass - This pass performs machine code CFG based optimizations to delete branches to branches, eliminate branches to successor blocks (creating fall throughs), and eliminating branches over branches.

Definition at line 43 of file BranchFolding.cpp.

FunctionPass* llvm::createMachineCodeDeleter (  ) 

MachineCodeDeletion Pass - This pass deletes all of the machine code for the current function, which should happen after the function has been emitted to a .s file or to memory.

Definition at line 84 of file MachineFunction.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitMachineCode(), llvm::PPCTargetMachine::addPassesToEmitMachineCode(), and llvm::AlphaTargetMachine::addPassesToEmitMachineCode().

FunctionPass * llvm::getRegisterAllocator ( TargetMachine &  T  ) 

getRegisterAllocator - This creates an instance of the register allocator for the Sparc.

Definition at line 82 of file PhyRegAlloc.cpp.

References T.

FunctionPass* llvm::createModuloSchedulingPass ( TargetMachine targ  ) 

Create ModuloSchedulingPass

Definition at line 45 of file ModuloScheduling.cpp.

References DEBUG.

FunctionPass* llvm::createModuloSchedulingSBPass ( TargetMachine targ  ) 

Create ModuloSchedulingSBPass

Definition at line 43 of file ModuloSchedulingSuperBlock.cpp.

References DEBUG.

std::ostream& llvm::operator<< ( std::ostream &  os,
const SchedGraphNodeCommon &  node 
) [inline]

Definition at line 95 of file SchedGraphCommon.h.

References llvm::SchedGraphNodeCommon::print().

std::ostream& llvm::operator<< ( std::ostream &  os,
const SchedGraphEdge &  edge 
) [inline]

Definition at line 194 of file SchedGraphCommon.h.

References llvm::SchedGraphEdge::print().

ScheduleDAG* llvm::createBFS_DAGScheduler ( SelectionDAG DAG,
MachineBasicBlock BB 
)

Definition at line 1110 of file ScheduleDAGSimple.cpp.

References BB, DAG, and llvm::SelectionDAG::getTarget().

Referenced by llvm::SelectionDAGISel::ScheduleAndEmitDAG().

ScheduleDAG* llvm::createSimpleDAGScheduler ( bool  NoItins,
SelectionDAG DAG,
MachineBasicBlock BB 
)

createSimpleDAGScheduler - This creates a simple two pass instruction scheduler.

Definition at line 1104 of file ScheduleDAGSimple.cpp.

References BB, DAG, and llvm::SelectionDAG::getTarget().

Referenced by llvm::SelectionDAGISel::ScheduleAndEmitDAG().

ScheduleDAG* llvm::createBURRListDAGScheduler ( SelectionDAG DAG,
MachineBasicBlock BB 
)

createBURRListDAGScheduler - This creates a bottom up register usage reduction list scheduler.

Definition at line 1086 of file ScheduleDAGList.cpp.

References BB, DAG, and llvm::SelectionDAG::getTarget().

Referenced by llvm::SelectionDAGISel::ScheduleAndEmitDAG().

ScheduleDAG* llvm::createTDListDAGScheduler ( SelectionDAG DAG,
MachineBasicBlock BB,
HazardRecognizer HR 
)

createTDListDAGScheduler - This creates a top-down list scheduler with the specified hazard recognizer.

Definition at line 1095 of file ScheduleDAGList.cpp.

References BB, DAG, and llvm::SelectionDAG::getTarget().

Referenced by llvm::SelectionDAGISel::ScheduleAndEmitDAG().

std::ostream & llvm::operator<< ( std::ostream &  out,
RAV  Val 
)

Definition at line 16 of file ValueSet.cpp.

References llvm::Value::getName(), llvm::Value::hasName(), and V.

void llvm::printSet ( const ValueSet S  ) 

Definition at line 26 of file ValueSet.cpp.

References E, and I.

Referenced by llvm::BBLiveVar::printAllSets(), and llvm::BBLiveVar::printInOutSets().

GenericValue llvm::PTOGV ( void *  P  )  [inline]

Definition at line 46 of file GenericValue.h.

Referenced by CreateArgv(), llvm::ExecutionEngine::getConstantValue(), lle_X___strdup(), lle_X_calloc(), lle_X_fopen(), lle_X_fprintf(), lle_X_freopen(), lle_X_malloc(), lle_X_memcpy(), lle_X_memset(), lle_X_printf(), lle_X_strcat(), lle_X_strcpy(), lle_X_strdup(), llvm::JIT::runFunction(), llvm::ExecutionEngine::runFunctionAsMain(), and llvm::Interpreter::visitAllocationInst().

void* llvm::GVTOP ( const GenericValue &  GV  )  [inline]

Definition at line 47 of file GenericValue.h.

References GV.

Referenced by lle_X___strdup(), lle_X_atexit(), lle_X_atoi(), lle_X_fclose(), lle_X_feof(), lle_X_ferror(), lle_X_fflush(), lle_X_fgets(), lle_X_fopen(), lle_X_fprintf(), lle_X_fputc(), lle_X_fread(), lle_X_free(), lle_X_freopen(), lle_X_fwrite(), lle_X_getc(), lle_X_memcpy(), lle_X_memset(), lle_X_puts(), lle_X_scanf(), lle_X_sprintf(), lle_X_sscanf(), lle_X_strcat(), lle_X_strcmp(), lle_X_strcpy(), lle_X_strdup(), lle_X_strlen(), lle_X_ungetc(), llvm::JIT::runFunction(), llvm::ExecutionEngine::runFunctionAsMain(), llvm::Interpreter::visitCallSite(), llvm::Interpreter::visitFreeInst(), llvm::Interpreter::visitLoadInst(), and llvm::Interpreter::visitStoreInst().

void llvm::LinkInInterpreter (  ) 

Definition at line 28 of file Interpreter.cpp.

void llvm::LinkInJIT (  ) 

Definition at line 36 of file JIT.cpp.

std::ostream& llvm::operator<< ( std::ostream &  O,
const Module &  M 
) [inline]

Definition at line 255 of file Module.h.

References M, and llvm::Module::print().

std::ostream& llvm::operator<< ( std::ostream &  OS,
const Pass &  P 
) [inline]

Definition at line 209 of file Pass.h.

References llvm::Pass::print().

template<typename PassName>
Pass* llvm::callDefaultCtor (  ) 

Definition at line 185 of file PassSupport.h.

template<typename To, typename From>
bool llvm::isa_impl ( const From &  Val  )  [inline]

Definition at line 51 of file Casting.h.

template<class X, class Y>
bool llvm::isa ( const Y Val  )  [inline]

Definition at line 113 of file Casting.h.

template<class X, class Y>
cast_retty<X, Y>::ret_type llvm::cast ( const Y Val  )  [inline]

Definition at line 196 of file Casting.h.

References X, and Y.

template<class X, class Y>
cast_retty<X, Y*>::ret_type llvm::cast_or_null ( Y Val  )  [inline]

Definition at line 206 of file Casting.h.

template<class X, class Y>
cast_retty<X, Y>::ret_type llvm::dyn_cast ( Y  Val  )  [inline]

Definition at line 222 of file Casting.h.

template<class X, class Y>
cast_retty<X, Y>::ret_type llvm::dyn_cast_or_null ( Y  Val  )  [inline]

Definition at line 230 of file Casting.h.

pred_iterator llvm::pred_begin ( BasicBlock *  BB  )  [inline]

Definition at line 73 of file CFG.h.

References BB.

pred_const_iterator llvm::pred_begin ( const BasicBlock *  BB  )  [inline]

Definition at line 74 of file CFG.h.

References BB.

pred_iterator llvm::pred_end ( BasicBlock *  BB  )  [inline]

Definition at line 77 of file CFG.h.

References BB.

pred_const_iterator llvm::pred_end ( const BasicBlock *  BB  )  [inline]

Definition at line 78 of file CFG.h.

References BB.

succ_iterator llvm::succ_begin ( BasicBlock *  BB  )  [inline]

Definition at line 137 of file CFG.h.

References BB, and llvm::BasicBlock::getTerminator().

succ_const_iterator llvm::succ_begin ( const BasicBlock *  BB  )  [inline]

Definition at line 140 of file CFG.h.

References BB, and llvm::BasicBlock::getTerminator().

succ_iterator llvm::succ_end ( BasicBlock *  BB  )  [inline]

Definition at line 143 of file CFG.h.

References BB, and llvm::BasicBlock::getTerminator().

succ_const_iterator llvm::succ_end ( const BasicBlock *  BB  )  [inline]

Definition at line 146 of file CFG.h.

References BB, and llvm::BasicBlock::getTerminator().

std::ostream& llvm::operator<< ( std::ostream &  OS,
const ConstantRange &  CR 
) [inline]

Definition at line 150 of file ConstantRange.h.

References llvm::ConstantRange::print().

bool llvm::isCurrentDebugType ( const char *  Type  ) 

Definition at line 59 of file Debug.cpp.

bool llvm::LinkDynamicObject ( const char *  filename,
std::string *  ErrorMessage 
)

LinkDynamicObject - Load the named file as a dynamic library and link it with the currently running process. Returns false on success, true if there is an error (and sets ErrorMessage if it is not NULL). Analogous to dlopen().

void* llvm::GetAddressOfSymbol ( const char *  symbolName  ) 

GetAddressOfSymbol - Returns the address of the named symbol in the currently running process, as reported by the dynamic linker, or NULL if the symbol does not exist or some other error has occurred.

void* llvm::GetAddressOfSymbol ( const std::string &  symbolName  ) 

int llvm::DiffFilesWithTolerance ( const sys::Path FileA,
const sys::Path FileB,
double  AbsTol,
double  RelTol,
std::string *  Error 
)

DiffFilesWithTolerance - Compare the two files specified, returning 0 if the files match, 1 if they are different, and 2 if there is a file error. This function differs from DiffFiles in that you can specify an absolete and relative FP error that is allowed to exist. If you specify a string to fill in for the error option, it will set the string to an error message if an error occurs, allowing the caller to distinguish between a failed diff and a file system error.

Definition at line 145 of file FileUtilities.cpp.

References BackupNumber(), llvm::sys::MappedFile::charBase(), CompareNumbers(), llvm::sys::Path::getSize(), isNumberChar(), llvm::sys::MappedFile::map(), and PadFileIfNeeded().

gep_type_iterator llvm::gep_type_begin ( const User GEP  )  [inline]

Definition at line 84 of file GetElementPtrTypeIterator.h.

References llvm::generic_gep_type_iterator< ItTy >::begin(), llvm::User::getOperand(), llvm::Value::getType(), and llvm::User::op_begin().

Referenced by ConstantFoldGetElementPtr(), ConstantFoldLoadThroughGEPConstantExpr(), EmitGEPOffset(), evaluateRelation(), llvm::TargetData::getIndexedOffset(), llvm::BytecodeReader::ParseConstantPoolValue(), and llvm::Interpreter::visitGetElementPtrInst().

gep_type_iterator llvm::gep_type_end ( const User GEP  )  [inline]

Definition at line 88 of file GetElementPtrTypeIterator.h.

References llvm::generic_gep_type_iterator< ItTy >::end(), and llvm::User::op_end().

Referenced by ConstantFoldGetElementPtr(), ConstantFoldLoadThroughGEPConstantExpr(), llvm::BytecodeReader::ParseConstantPoolValue(), and llvm::Interpreter::visitGetElementPtrInst().

gep_type_iterator llvm::gep_type_begin ( const User GEP  )  [inline]

Definition at line 91 of file GetElementPtrTypeIterator.h.

References llvm::generic_gep_type_iterator< ItTy >::begin(), llvm::User::getOperand(), llvm::Value::getType(), and llvm::User::op_begin().

gep_type_iterator llvm::gep_type_end ( const User GEP  )  [inline]

Definition at line 95 of file GetElementPtrTypeIterator.h.

References llvm::generic_gep_type_iterator< ItTy >::end(), and llvm::User::op_end().

template<typename ItTy>
generic_gep_type_iterator<ItTy> llvm::gep_type_begin ( const Type Op0,
ItTy  I,
ItTy  E 
) [inline]

Definition at line 101 of file GetElementPtrTypeIterator.h.

template<typename ItTy>
generic_gep_type_iterator<ItTy> llvm::gep_type_end ( const Type Op0,
ItTy  I,
ItTy  E 
) [inline]

Definition at line 107 of file GetElementPtrTypeIterator.h.

template<typename GraphType>
std::ostream& llvm::WriteGraph ( std::ostream &  O,
const GraphType &  G,
const std::string &  Name = "" 
)

Definition at line 220 of file GraphWriter.h.

References Name, llvm::GraphWriter< GraphType >::writeFooter(), llvm::GraphWriter< GraphType >::writeHeader(), and llvm::GraphWriter< GraphType >::writeNodes().

Referenced by llvm::DSGraph::print(), llvm::MachineFunction::viewCFG(), llvm::Function::viewCFG(), llvm::SelectionDAG::viewGraph(), WriteGraphToFile(), and WriteGraphToFileSB().

inst_iterator llvm::inst_begin ( Function *  F  )  [inline]

Definition at line 128 of file InstIterator.h.

References F.

Referenced by llvm::SlotCalculator::getPlane(), llvm::ScalarEvolution::print(), and llvm::FindUsedTypes::runOnModule().

inst_iterator llvm::inst_end ( Function *  F  )  [inline]

Definition at line 129 of file InstIterator.h.

References F.

Referenced by llvm::constant_iterator::constant_iterator(), llvm::SlotCalculator::getPlane(), llvm::ScalarEvolution::print(), and llvm::FindUsedTypes::runOnModule().

const_inst_iterator llvm::inst_begin ( const Function *  F  )  [inline]

Definition at line 130 of file InstIterator.h.

References F.

const_inst_iterator llvm::inst_end ( const Function *  F  )  [inline]

Definition at line 133 of file InstIterator.h.

References F.

inst_iterator llvm::inst_begin ( Function &  F  )  [inline]

Definition at line 136 of file InstIterator.h.

References F.

inst_iterator llvm::inst_end ( Function &  F  )  [inline]

Definition at line 137 of file InstIterator.h.

References F.

const_inst_iterator llvm::inst_begin ( const Function &  F  )  [inline]

Definition at line 138 of file InstIterator.h.

References F.

const_inst_iterator llvm::inst_end ( const Function &  F  )  [inline]

Definition at line 141 of file InstIterator.h.

References F.

llvm::HANDLE_MEMORY_INST ( 21  ,
Malloc  ,
MallocInst   
)

AllocaInst PHINode llvm::HANDLE_OTHER_INST ( 28  ,
Cast  ,
CastInst   
)

AllocaInst PHINode CallInst llvm::HANDLE_OTHER_INST ( 30  ,
Shl  ,
ShiftInst   
)

AllocaInst PHINode CallInst SelectInst llvm::HANDLE_OTHER_INST ( 35  ,
UserOp1  ,
Instruction   
)

AllocaInst PHINode CallInst SelectInst VAArgInst llvm::HANDLE_OTHER_INST ( 38  ,
ExtractElement  ,
ExtractElementInst   
)

AllocaInst PHINode CallInst SelectInst VAArgInst InsertElementInst llvm::HANDLE_OTHER_INST ( 40  ,
ShuffleVector  ,
ShuffleVectorInst   
)

unsigned llvm::Hi_32 ( uint64_t  Value  )  [inline]

Definition at line 27 of file MathExtras.h.

Referenced by CountLeadingZeros_64().

unsigned llvm::Lo_32 ( uint64_t  Value  )  [inline]

Definition at line 32 of file MathExtras.h.

Referenced by CountLeadingZeros_64().

bool llvm::isInt8 ( int  Value  )  [inline]

Definition at line 37 of file MathExtras.h.

bool llvm::isUInt8 ( int  Value  )  [inline]

Definition at line 38 of file MathExtras.h.

bool llvm::isInt16 ( int  Value  )  [inline]

Definition at line 39 of file MathExtras.h.

Referenced by llvm::PPCRegisterInfo::emitPrologue().

bool llvm::isUInt16 ( int  Value  )  [inline]

Definition at line 40 of file MathExtras.h.

bool llvm::isInt32 ( int64_t  Value  )  [inline]

Definition at line 41 of file MathExtras.h.

bool llvm::isUInt32 ( int64_t  Value  )  [inline]

Definition at line 42 of file MathExtras.h.

const bool llvm::isMask_32 ( unsigned  Value  )  [inline]

Definition at line 47 of file MathExtras.h.

Referenced by isShiftedMask_32().

const bool llvm::isMask_64 ( uint64_t  Value  )  [inline]

Definition at line 53 of file MathExtras.h.

Referenced by isShiftedMask_64().

const bool llvm::isShiftedMask_32 ( unsigned  Value  )  [inline]

Definition at line 60 of file MathExtras.h.

References isMask_32().

Referenced by isRunOfOnes().

const bool llvm::isShiftedMask_64 ( uint64_t  Value  )  [inline]

Definition at line 66 of file MathExtras.h.

References isMask_64().

Referenced by isRunOfOnes().

bool llvm::isPowerOf2_32 ( unsigned  Value  )  [inline]

Definition at line 72 of file MathExtras.h.

Referenced by llvm::PPCRegisterInfo::emitPrologue(), llvm::PackedType::get(), and llvm::PPCTargetLowering::isOperandValidForConstraint().

bool llvm::isPowerOf2_64 ( uint64_t  Value  )  [inline]

Definition at line 78 of file MathExtras.h.

Referenced by llvm::SelectionDAGLowering::visitGetElementPtr().

unsigned short llvm::ByteSwap_16 ( unsigned short  Value  )  [inline]

Definition at line 84 of file MathExtras.h.

References llvm::PPCISD::Hi, and llvm::PPCISD::Lo.

Referenced by ConstantFoldCall(), and llvm::SelectionDAG::getNode().

unsigned llvm::ByteSwap_32 ( unsigned  Value  )  [inline]

Definition at line 92 of file MathExtras.h.

Referenced by ByteSwap_64(), ConstantFoldCall(), and llvm::SelectionDAG::getNode().

uint64_t llvm::ByteSwap_64 ( uint64_t  Value  )  [inline]

Definition at line 102 of file MathExtras.h.

References ByteSwap_32(), llvm::PPCISD::Hi, and llvm::PPCISD::Lo.

Referenced by ConstantFoldCall(), and llvm::SelectionDAG::getNode().

unsigned llvm::CountLeadingZeros_32 ( unsigned  Value  )  [inline]

Definition at line 112 of file MathExtras.h.

Referenced by CountLeadingZeros_64(), CountTrailingZeros_32(), llvm::SelectionDAG::getNode(), isRunOfOnes(), and Log2_32().

unsigned llvm::CountLeadingZeros_64 ( uint64_t  Value  )  [inline]

Definition at line 140 of file MathExtras.h.

References CountLeadingZeros_32(), llvm::PPCISD::Hi, Hi_32(), llvm::PPCISD::Lo, and Lo_32().

Referenced by llvm::TargetLowering::ComputeMaskedBits(), CountTrailingZeros_64(), llvm::SelectionDAG::getNode(), isRunOfOnes(), and Log2_64().

unsigned llvm::CountTrailingZeros_32 ( unsigned  Value  )  [inline]

Definition at line 184 of file MathExtras.h.

References CountLeadingZeros_32().

Referenced by llvm::SelectionDAG::getNode().

unsigned llvm::CountTrailingZeros_64 ( uint64_t  Value  )  [inline]

Definition at line 192 of file MathExtras.h.

References CountLeadingZeros_64().

Referenced by llvm::TargetLowering::ComputeMaskedBits(), GetFactor(), and llvm::SelectionDAG::getNode().

unsigned llvm::CountPopulation_32 ( unsigned  Value  )  [inline]

Definition at line 199 of file MathExtras.h.

Referenced by CountPopulation_64(), and llvm::SelectionDAG::getNode().

unsigned llvm::CountPopulation_64 ( uint64_t  Value  )  [inline]

Definition at line 212 of file MathExtras.h.

References CountPopulation_32().

Referenced by llvm::SelectionDAG::getNode().

unsigned llvm::Log2_32 ( unsigned  Value  )  [inline]

Definition at line 220 of file MathExtras.h.

References CountLeadingZeros_32().

Referenced by llvm::TargetLowering::ComputeMaskedBits(), llvm::AsmPrinter::EmitAlignment(), llvm::PPCRegisterInfo::emitPrologue(), llvm::AsmPrinter::getPreferredAlignmentLog(), llvm::TargetData::getTypeAlignmentShift(), llvm::PPCTargetLowering::LowerOperation(), and llvm::TargetLowering::SimplifyDemandedBits().

unsigned llvm::Log2_64 ( uint64_t  Value  )  [inline]

Definition at line 226 of file MathExtras.h.

References CountLeadingZeros_64().

Referenced by llvm::SelectionDAGLowering::visitGetElementPtr().

double llvm::BitsToDouble ( uint64_t  Bits  )  [inline]

Definition at line 232 of file MathExtras.h.

References D, and T.

Referenced by CastConstantPacked(), llvm::ConstantCreator< ConstantFP, Type, uint64_t >::create(), llvm::SelectionDAG::getNode(), and llvm::X86TargetLowering::LowerOperation().

float llvm::BitsToFloat ( uint32_t  Bits  )  [inline]

Definition at line 243 of file MathExtras.h.

References F, I, and T.

Referenced by CastConstantPacked(), llvm::ConstantCreator< ConstantFP, Type, uint32_t >::create(), llvm::SelectionDAG::getNode(), and llvm::X86TargetLowering::LowerOperation().

uint64_t llvm::DoubleToBits ( double  Double  )  [inline]

Definition at line 254 of file MathExtras.h.

References D, and T.

Referenced by CastConstantPacked(), llvm::AsmPrinter::EmitGlobalConstant(), llvm::ConstantFP::get(), llvm::SelectionDAG::getConstantFP(), llvm::SelectionDAG::getNode(), llvm::SelectionDAG::getTargetConstantFP(), llvm::ISD::isBuildVectorAllOnes(), llvm::ConstantFPSDNode::isExactlyValue(), llvm::ConstantFP::isExactlyValue(), llvm::ConstantFP::isNullValue(), and WriteConstantInt().

uint32_t llvm::FloatToBits ( float  Float  )  [inline]

Definition at line 265 of file MathExtras.h.

References F, I, and T.

Referenced by CastConstantPacked(), llvm::AsmPrinter::EmitGlobalConstant(), llvm::ConstantFP::get(), llvm::PPC::get_VSPLTI_elt(), GetConstantBuildVectorBits(), llvm::SelectionDAG::getNode(), and llvm::ISD::isBuildVectorAllOnes().

int llvm::IsNAN ( float  f  ) 

Definition at line 31 of file IsNAN.cpp.

Referenced by ConstantFoldCall().

int llvm::IsNAN ( double  d  ) 

Definition at line 32 of file IsNAN.cpp.

int llvm::IsInf ( float  f  ) 

Definition at line 42 of file IsInf.cpp.

int llvm::IsInf ( double  d  ) 

Definition at line 43 of file IsInf.cpp.

bool llvm::CheckBytecodeOutputToConsole ( std::ostream *  stream_to_check,
bool  print_warning = true 
)

Check for output written to a console.

Determine if the ostream provided is connected to the std::cout and displayed or not (to a console window). If so, generate a warning message advising against display of bytecode and return true. Otherwise just return false

Parameters:
stream_to_check  The stream to be checked
print_warning  Control whether warnings are printed

Definition at line 21 of file SystemUtils.cpp.

References llvm::sys::Process::StandardOutIsDisplayed().

sys::Path llvm::FindExecutable ( const std::string &  ExeName,
const std::string &  ProgramPath 
)

Find a named executable.

FindExecutable - Find a named executable, giving the argv[0] of program being executed. This allows us to find another LLVM tool if it is built into the same directory, but that directory is neither the current directory, nor in the PATH. If the executable cannot be found, return an empty string.

Definition at line 42 of file SystemUtils.cpp.

References llvm::sys::Path::appendComponent(), llvm::sys::Path::canExecute(), llvm::sys::Path::eraseComponent(), llvm::sys::Program::FindProgramByName(), and llvm::sys::Path::isEmpty().

Referenced by llvm::GCC::create(), llvm::AbstractInterpreter::createCBE(), llvm::AbstractInterpreter::createJIT(), llvm::AbstractInterpreter::createLLC(), and llvm::AbstractInterpreter::createLLI().

bool llvm::operator== ( const TypeInfo &  lhs,
const TypeInfo &  rhs 
) [inline]

Definition at line 50 of file TypeInfo.h.

References llvm::TypeInfo::get().

bool llvm::operator< ( const TypeInfo &  lhs,
const TypeInfo &  rhs 
) [inline]

Definition at line 54 of file TypeInfo.h.

References llvm::TypeInfo::before().

bool llvm::operator!= ( const TypeInfo &  lhs,
const TypeInfo &  rhs 
) [inline]

Definition at line 58 of file TypeInfo.h.

bool llvm::operator> ( const TypeInfo &  lhs,
const TypeInfo &  rhs 
) [inline]

Definition at line 62 of file TypeInfo.h.

bool llvm::operator<= ( const TypeInfo &  lhs,
const TypeInfo &  rhs 
) [inline]

Definition at line 66 of file TypeInfo.h.

bool llvm::operator>= ( const TypeInfo &  lhs,
const TypeInfo &  rhs 
) [inline]

Definition at line 70 of file TypeInfo.h.

std::ostream& llvm::operator<< ( std::ostream &  strm,
const sys::Path &  aPath 
) [inline]

Definition at line 570 of file Path.h.

References llvm::sys::Path::toString().

FunctionPass* llvm::createLoopInstrumentationPass (  ) 

FunctionPass* llvm::createCombineBranchesPass (  ) 

ModulePass * llvm::createEmitFunctionTablePass (  ) 

Definition at line 121 of file EmitFunctions.cpp.

ModulePass* llvm::createFunctionProfilerPass (  ) 

Definition at line 44 of file BlockProfiling.cpp.

ModulePass* llvm::createBlockProfilerPass (  ) 

Definition at line 89 of file BlockProfiling.cpp.

ModulePass* llvm::createEdgeProfilerPass (  ) 

Definition at line 40 of file EdgeProfiling.cpp.

ModulePass* llvm::createTraceBasicBlockPass (  ) 

Definition at line 38 of file TraceBasicBlocks.cpp.

FunctionPass* llvm::createProfilePathsPass (  ) 

ModulePass* llvm::createNullProfilerRSPass (  ) 

Definition at line 637 of file RSProfiling.cpp.

FunctionPass* llvm::createRSProfilingPass (  ) 

Definition at line 641 of file RSProfiling.cpp.

FunctionPass* llvm::createTraceValuesPassForBasicBlocks (  ) 

Trace BB's and functions.

Definition at line 117 of file TraceValues.cpp.

FunctionPass* llvm::createTraceValuesPassForFunction (  ) 

Just trace functions.

Definition at line 112 of file TraceValues.cpp.

ModulePass* llvm::createStripSymbolsPass ( bool  OnlyDebugInfo = false  ) 

Definition at line 49 of file StripSymbols.cpp.

ModulePass* llvm::createLowerSetJmpPass (  ) 

createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics to invoke/unwind instructions. This should really be part of the C/C++ front-end, but it's so much easier to write transformations in LLVM proper.

Definition at line 534 of file LowerSetJmp.cpp.

ModulePass* llvm::createConstantMergePass (  ) 

createConstantMergePass - This function returns a new pass that merges duplicate global constants together into a single constant that is shared. This is useful because some passes (ie TraceValues) insert a lot of string constants into the program, regardless of whether or not they duplicate an existing string.

Definition at line 39 of file ConstantMerge.cpp.

ModulePass* llvm::createGlobalOptimizerPass (  ) 

createGlobalOptimizerPass - This function returns a new pass that optimizes non-address taken internal globals.

Definition at line 69 of file GlobalOpt.cpp.

ModulePass* llvm::createRaiseAllocationsPass (  ) 

createRaiseAllocationsPass - Return a new pass that transforms malloc and free function calls into malloc and free instructions.

Definition at line 53 of file RaiseAllocations.cpp.

ModulePass* llvm::createDeadTypeEliminationPass (  ) 

createDeadTypeEliminationPass - Return a new pass that eliminates symbol table entries for types that are never used.

Definition at line 44 of file DeadTypeElimination.cpp.

ModulePass* llvm::createGlobalDCEPass (  ) 

createGlobalDCEPass - This transform is designed to eliminate unreachable internal globals (functions or global variables)

Definition at line 50 of file GlobalDCE.cpp.

ModulePass* llvm::createFunctionExtractionPass ( Function F,
bool  deleteFn = false 
)

createFunctionExtractionPass - If deleteFn is true, this pass deletes as the specified function. Otherwise, it deletes as much of the module as possible, except for the function specified.

Definition at line 115 of file ExtractFunction.cpp.

References F.

ModulePass* llvm::createFunctionResolvingPass (  ) 

FunctionResolvingPass - Go over the functions that are in the module and look for functions that have the same name. More often than not, there will be things like: void "foo"(...) void "foo"(int, int) because of the way things are declared in C. If this is the case, patch things up.

This is an interprocedural pass.

Definition at line 49 of file FunctionResolution.cpp.

ModulePass* llvm::createFunctionInliningPass (  ) 

createFunctionInliningPass - Return a new pass object that uses a heuristic to inline direct function calls to small functions.

Definition at line 61 of file InlineSimple.cpp.

ModulePass* llvm::createPruneEHPass (  ) 

createPruneEHPass - Return a new pass object which transforms invoke instructions into calls, if the callee can _not_ unwind the stack.

Definition at line 52 of file PruneEH.cpp.

ModulePass* llvm::createInternalizePass ( bool  InternalizeEverything  ) 

createInternalizePass - This pass loops over all of the functions in the input module, looking for a main function. If a list of symbols is specified with the -internalize-public-api-* command line options, those symbols are internalized. Otherwise if InternalizeEverything is set and the main function is found, all other globals are marked as internal.

Definition at line 151 of file Internalize.cpp.

ModulePass* llvm::createDeadArgEliminationPass (  ) 

createDeadArgEliminationPass - This pass removes arguments from functions which are not used by the body of the function.

Definition at line 111 of file DeadArgumentElimination.cpp.

ModulePass* llvm::createDeadArgHackingPass (  ) 

DeadArgHacking pass - Same as DAE, but delete arguments of external functions as well. This is definitely not safe, and should only be used by bugpoint.

Definition at line 112 of file DeadArgumentElimination.cpp.

ModulePass* llvm::createArgumentPromotionPass (  ) 

createArgumentPromotionPass - This pass promotes "by reference" arguments to be passed by value.

Definition at line 79 of file ArgumentPromotion.cpp.

ModulePass* llvm::createIPConstantPropagationPass (  ) 

createIPConstantPropagationPass - This pass propagates constants from call sites into the bodies of functions.

Definition at line 44 of file IPConstantPropagation.cpp.

ModulePass* llvm::createIPSCCPPass (  ) 

createIPSCCPPass - This pass propagates constants from call sites into the bodies of functions, and keeps track of whether basic blocks are executable in the process.

Definition at line 1191 of file SCCP.cpp.

FunctionPass* llvm::createLoopExtractorPass (  ) 

createLoopExtractorPass - This pass extracts all natural loops from the program into a function if it can.

Definition at line 64 of file LoopExtractor.cpp.

FunctionPass* llvm::createSingleLoopExtractorPass (  ) 

createSingleLoopExtractorPass - This pass extracts one natural loop from the program into a function if it can. This is used by bugpoint.

Definition at line 134 of file LoopExtractor.cpp.

ModulePass* llvm::createBlockExtractorPass ( std::vector< BasicBlock * > &  BTNE  ) 

Definition at line 158 of file LoopExtractor.cpp.

ModulePass* llvm::createSimplifyLibCallsPass (  ) 

Definition at line 345 of file SimplifyLibCalls.cpp.

ModulePass* llvm::createIndMemRemPass (  ) 

Definition at line 90 of file IndMemRemoval.cpp.

FunctionPass* llvm::createRaisePointerReferencesPass (  ) 

Definition at line 87 of file LevelRaise.cpp.

FunctionPass* llvm::createConstantPropagationPass (  ) 

Definition at line 45 of file ConstantProp.cpp.

FunctionPass* llvm::createSCCPPass (  ) 

Definition at line 1083 of file SCCP.cpp.

FunctionPass* llvm::createDeadInstEliminationPass (  ) 

Definition at line 56 of file DCE.cpp.

FunctionPass* llvm::createDeadCodeEliminationPass (  ) 

Definition at line 120 of file DCE.cpp.

FunctionPass* llvm::createDeadStoreEliminationPass (  ) 

Definition at line 60 of file DeadStoreElimination.cpp.

FunctionPass* llvm::createAggressiveDCEPass (  ) 

Definition at line 110 of file ADCE.cpp.

FunctionPass* llvm::createScalarReplAggregatesPass (  ) 

Definition at line 76 of file ScalarReplAggregates.cpp.

FunctionPass* llvm::createGCSEPass (  ) 

Definition at line 58 of file GCSE.cpp.

FunctionPass* llvm::createIndVarSimplifyPass (  ) 

Definition at line 97 of file IndVarSimplify.cpp.

FunctionPass* llvm::createInstructionCombiningPass (  ) 

Definition at line 7193 of file InstructionCombining.cpp.

FunctionPass* llvm::createLICMPass (  ) 

Definition at line 203 of file LICM.cpp.

FunctionPass* llvm::createLoopStrengthReducePass ( const TargetLowering TLI = NULL  ) 

Definition at line 200 of file LoopStrengthReduce.cpp.

References TLI.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLoopUnswitchPass (  ) 

Definition at line 107 of file LoopUnswitch.cpp.

FunctionPass* llvm::createLoopUnrollPass (  ) 

Definition at line 63 of file LoopUnroll.cpp.

FunctionPass* llvm::createPromoteMemoryToRegisterPass (  ) 

Definition at line 79 of file Mem2Reg.cpp.

FunctionPass* llvm::createDemoteRegisterToMemoryPass (  ) 

Definition at line 85 of file Reg2Mem.cpp.

FunctionPass* llvm::createReassociatePass (  ) 

Definition at line 97 of file Reassociate.cpp.

FunctionPass* llvm::createCorrelatedExpressionEliminationPass (  ) 

Definition at line 292 of file CorrelatedExprs.cpp.

FunctionPass* llvm::createCondPropagationPass (  ) 

Definition at line 52 of file CondPropagate.cpp.

FunctionPass* llvm::createTailDuplicationPass (  ) 

Definition at line 54 of file TailDuplication.cpp.

FunctionPass* llvm::createCFGSimplificationPass (  ) 

Definition at line 42 of file Scalar/SimplifyCFG.cpp.

Referenced by llvm::CTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createBreakCriticalEdgesPass (  ) 

Definition at line 55 of file BreakCriticalEdges.cpp.

FunctionPass* llvm::createLoopSimplifyPass (  ) 

Definition at line 97 of file LoopSimplify.cpp.

FunctionPass* llvm::createTailCallEliminationPass (  ) 

Definition at line 82 of file TailRecursionElimination.cpp.

FunctionPass* llvm::createLowerAllocationsPass ( bool  LowerMallocArgToInteger = false  ) 

Definition at line 64 of file LowerAllocations.cpp.

Referenced by llvm::CTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createLowerSwitchPass (  ) 

Definition at line 64 of file LowerSwitch.cpp.

FunctionPass* llvm::createLowerSelectPass ( bool  OnlyFP = false  ) 

Definition at line 55 of file LowerSelect.cpp.

FunctionPass* llvm::createLowerPackedPass (  ) 

Definition at line 111 of file LowerPacked.cpp.

FunctionPass* llvm::createLowerInvokePass ( unsigned  JumBufSize = 200,
unsigned  JumpBufAlign = 0 
)

Definition at line 95 of file LowerInvoke.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::CTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLowerGCPass (  ) 

createLowerGCPass - This function returns an instance of the "lowergc" pass, which lowers garbage collection intrinsics to normal LLVM code.

Definition at line 64 of file LowerGC.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::CTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createBlockPlacementPass (  ) 

Definition at line 75 of file BasicBlockPlacement.cpp.

FunctionPass* llvm::createPREPass (  ) 

void llvm::ReplaceInstWithValue ( BasicBlock::InstListType &  BIL,
BasicBlock::iterator BI,
Value V 
)

ReplaceInstWithValue - Replace all uses of an instruction (specified by BI) with a value, then remove and delete the original instruction.

Definition at line 26 of file BasicBlockUtils.cpp.

References llvm::Value::getName(), I, llvm::Value::replaceAllUsesWith(), and V.

Referenced by ReplaceInstWithInst().

void llvm::ReplaceInstWithInst ( BasicBlock::InstListType &  BIL,
BasicBlock::iterator BI,
Instruction I 
)

ReplaceInstWithInst - Replace the instruction specified by BI with the instruction specified by I. The original instruction is deleted and BI is updated to point to the new instruction.

Definition at line 47 of file BasicBlockUtils.cpp.

Referenced by RemoveSuccessor(), and ReplaceInstWithInst().

void llvm::ReplaceInstWithInst ( Instruction From,
Instruction To 
)

ReplaceInstWithInst - Replace the instruction specified by From with the instruction specified by To.

Definition at line 65 of file BasicBlockUtils.cpp.

References llvm::BasicBlock::getInstList(), llvm::Instruction::getParent(), and ReplaceInstWithInst().

void llvm::RemoveSuccessor ( TerminatorInst TI,
unsigned  SuccNum 
)

RemoveSuccessor - Change the specified terminator instruction such that its successor SuccNum no longer exists. Because this reduces the outgoing degree of the current basic block, the actual terminator instruction itself may have to be changed. In the case where the last successor of the block is deleted, a return instruction is inserted in its place which can cause a surprising change in program behavior if it is not expected.

Definition at line 77 of file BasicBlockUtils.cpp.

References abort(), BB, llvm::Constant::getNullValue(), llvm::TerminatorInst::getNumSuccessors(), llvm::Instruction::getOpcode(), llvm::Instruction::getParent(), llvm::TerminatorInst::getSuccessor(), llvm::BasicBlock::removePredecessor(), ReplaceInstWithInst(), and llvm::Type::VoidTy.

bool llvm::isCriticalEdge ( const TerminatorInst TI,
unsigned  SuccNum 
)

isCriticalEdge - Return true if the specified edge is a critical edge. Critical edges are edges from a block with multiple successors to a block with multiple predecessors.

Definition at line 85 of file BreakCriticalEdges.cpp.

References Dest, E, llvm::TerminatorInst::getNumSuccessors(), llvm::TerminatorInst::getSuccessor(), I, pred_begin(), and pred_end().

Referenced by SplitCriticalEdge().

bool llvm::SplitCriticalEdge ( TerminatorInst TI,
unsigned  SuccNum,
Pass P = 0 
)

SplitCriticalEdge - If this edge is a critical edge, insert a new node to split the critical edge. This will update DominatorSet, ImmediateDominator, DominatorTree, and DominatorFrontier information if it is available, thus calling this pass will not invalidate either of them. This returns true if the edge was split, false otherwise.

Definition at line 104 of file BreakCriticalEdges.cpp.

References llvm::DominatorSetBase::addBasicBlock(), llvm::ETForestBase::addNewBlock(), llvm::ISD::BasicBlock, llvm::BasicBlock::begin(), llvm::DominatorTreeBase::createNewNode(), llvm::X86II::DF, DS, DT, EF, F, llvm::Pass::getAnalysisToUpdate(), llvm::DominatorSetBase::getDominators(), llvm::LoopInfo::getLoopFor(), llvm::Value::getName(), llvm::BasicBlock::getNext(), llvm::DominatorTreeBase::getNode(), llvm::Instruction::getParent(), llvm::BasicBlock::getParent(), llvm::TerminatorInst::getSuccessor(), I, isCriticalEdge(), LI, Node, and llvm::TerminatorInst::setSuccessor().

Referenced by IVUseShouldUsePostIncValue(), llvm::SelectionDAGISel::runOnFunction(), and SplitCriticalEdge().

bool llvm::SplitCriticalEdge ( BasicBlock *  BB,
succ_iterator  SI,
Pass *  P = 0 
) [inline]

Definition at line 70 of file BasicBlockUtils.h.

References BB, llvm::SuccIterator< Term_, BB_ >::getSuccessorIndex(), llvm::BasicBlock::getTerminator(), and SplitCriticalEdge().

bool llvm::SplitCriticalEdge ( BasicBlock *  Succ,
pred_iterator  PI,
Pass *  P = 0 
) [inline]

SplitCriticalEdge - If the edge from *PI to BB is not critical, return false. Otherwise, split all edges between the two blocks and return true. This updates all of the same analyses as the other SplitCriticalEdge function.

Definition at line 78 of file BasicBlockUtils.h.

References llvm::TerminatorInst::getNumSuccessors(), llvm::TerminatorInst::getSuccessor(), MadeChange, and SplitCriticalEdge().

bool llvm::SplitCriticalEdge ( BasicBlock *  Src,
BasicBlock *  Dst,
Pass *  P = 0 
) [inline]

Definition at line 87 of file BasicBlockUtils.h.

References llvm::TerminatorInst::getNumSuccessors(), llvm::TerminatorInst::getSuccessor(), SplitCriticalEdge(), and Src.

Module* llvm::CloneModule ( const Module M  ) 

CloneModule - Return an exact copy of the specified module. This is not as easy as it might seem because we have to worry about making copies of global variables and functions, and making their (initializers and references, respectively) refer to the right globals.

Definition at line 28 of file CloneModule.cpp.

References llvm::Module::addLibrary(), llvm::Module::addTypeName(), llvm::Module::begin(), CloneFunctionInto(), E, llvm::Module::end(), llvm::GlobalValue::ExternalLinkage, F, llvm::Module::getEndianness(), llvm::Module::getModuleIdentifier(), llvm::Module::getModuleInlineAsm(), llvm::Module::getPointerSize(), llvm::Module::getSymbolTable(), llvm::Module::getTargetTriple(), llvm::Module::global_begin(), llvm::Module::global_end(), GV, I, llvm::Module::lib_begin(), llvm::Module::lib_end(), M, MapValue(), llvm::Module::setEndianness(), llvm::GlobalValue::setLinkage(), llvm::Module::setModuleInlineAsm(), llvm::Module::setPointerSize(), llvm::Module::setTargetTriple(), llvm::SymbolTable::type_begin(), llvm::SymbolTable::type_end(), and ValueMap.

BasicBlock* llvm::CloneBasicBlock ( const BasicBlock BB,
std::map< const Value *, Value * > &  ValueMap,
const char *  NameSuffix = "",
Function F = 0,
ClonedCodeInfo CodeInfo = 0 
)

CloneBasicBlock - Return a copy of the specified basic block, but without embedding the block into a particular function. The block returned is an exact copy of the specified basic block, without any remapping having been performed. Because of this, this is only suitable for applications where the basic block will be inserted into the same function that it was cloned from (loop unrolling would use this, for example).

Also, note that this function makes a direct copy of the basic block, and can thus produce illegal LLVM code. In particular, it will copy any PHI nodes from the original block, even though there are no predecessors for the newly cloned block (thus, phi nodes will have to be updated). Also, this block will branch to the old successors of the original block: these successors will have to have any PHI nodes updated to account for the new incoming edges.

The correlation between instructions in the source and result basic blocks is recorded in the ValueMap map.

If you have a particular suffix you'd like to use to add to any cloned names, specify it as the optional third parameter.

If you would like the basic block to be auto-inserted into the end of a function, you can specify it as the optional fourth parameter.

If you would like to collect additional information about the cloned function, you can specify a ClonedCodeInfo object with the optional fifth parameter.

Definition at line 25 of file CloneFunction.cpp.

References AI, llvm::ISD::BasicBlock, BB, llvm::BasicBlock::begin(), llvm::ClonedCodeInfo::ContainsCalls, llvm::ClonedCodeInfo::ContainsDynamicAllocas, llvm::ClonedCodeInfo::ContainsUnwinds, llvm::BasicBlock::end(), F, llvm::Function::front(), llvm::AllocationInst::getArraySize(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::TargetInstrInfo::getName(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getTerminator(), llvm::Value::hasName(), II, and llvm::Value::setName().

Referenced by CloneFunctionInto(), CloneTrace(), and CloneTraceInto().

Function* llvm::CloneFunction ( const Function F,
std::map< const Value *, Value * > &  ValueMap,
ClonedCodeInfo CodeInfo 
)

CloneFunction - Return a copy of the specified function, but without embedding the function into another module. Also, any references specified in the ValueMap are changed to refer to their mapped value instead of the original one. If any of the arguments to the function are in the ValueMap, the arguments are deleted from the resultant function. The ValueMap is updated to include mappings from all of the instructions and basicblocks in the function from their old to new values.

Definition at line 112 of file CloneFunction.cpp.

References CloneFunctionInto(), E, F, llvm::FunctionType::get(), and I.

Referenced by CloneFunction().

Function* llvm::CloneFunction ( const Function *  F,
ClonedCodeInfo *  CodeInfo = 0 
) [inline]

CloneFunction - Version of the function that doesn't need the ValueMap.

Definition at line 115 of file Cloning.h.

References CloneFunction(), F, and ValueMap.

void llvm::CloneFunctionInto ( Function NewFunc,
const Function OldFunc,
std::map< const Value *, Value * > &  ValueMap,
std::vector< ReturnInst * > &  Returns,
const char *  NameSuffix = "",
ClonedCodeInfo CodeInfo = 0 
)

Clone OldFunc into NewFunc, transforming the old arguments into references to ArgMap values. Note that if NewFunc already has basic blocks, the ones cloned into it will be added to the end of the function. This function fills in a list of return instructions, and can optionally append the specified suffix to all values cloned.

Definition at line 65 of file CloneFunction.cpp.

References llvm::Function::arg_begin(), llvm::Function::arg_end(), BB, llvm::Function::begin(), llvm::BasicBlock::begin(), CloneBasicBlock(), E, llvm::Function::end(), llvm::BasicBlock::end(), llvm::BasicBlock::getTerminator(), I, II, and RemapInstruction().

Referenced by CloneFunction(), CloneModule(), and InlineFunction().

void llvm::CloneTraceInto ( Function NewFunc,
Trace T,
std::map< const Value *, Value * > &  ValueMap,
const char *  NameSuffix 
)

CloneTraceInto - Clone T into NewFunc. Original<->clone mapping is saved in ValueMap.

Definition at line 94 of file CloneTrace.cpp.

References BB, llvm::BasicBlock::begin(), CloneBasicBlock(), llvm::Function::end(), llvm::BasicBlock::end(), II, RemapInstruction(), and T.

std::vector<BasicBlock *> llvm::CloneTrace ( const std::vector< BasicBlock * > &  origTrace  ) 

CloneTrace - Returns a copy of the specified trace. It takes a vector of basic blocks clones the basic blocks, removes internal phi nodes, adds it to the same function as the original (although there is no jump to it) and returns the new vector of basic blocks.

Definition at line 27 of file CloneTrace.cpp.

References BB, llvm::BasicBlock::begin(), CloneBasicBlock(), E, I, Op, T, V, and ValueMap.

bool llvm::InlineFunction ( CallInst C,
CallGraph CG = 0 
)

InlineFunction - This function inlines the called function into the basic block of the caller. This returns false if it is not possible to inline this call. The program is still in a well defined state if this occurs though.

Note that this only does one level of inlining. For example, if the instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now exists in the instruction stream. Similiarly this will inline a recursive function by one level.

If a non-null callgraph pointer is provided, these functions update the CallGraph to represent the program after inlining.

Definition at line 25 of file InlineFunction.cpp.

Referenced by InlineCallIfPossible(), and InlineFunction().

bool llvm::InlineFunction ( InvokeInst II,
CallGraph CG = 0 
)

Definition at line 28 of file InlineFunction.cpp.

bool llvm::InlineFunction ( CallSite  CS,
CallGraph CG = 0 
)

Definition at line 167 of file InlineFunction.cpp.

References llvm::CallGraphNode::addCalledFunction(), AI, llvm::CallSite::arg_begin(), llvm::CallSite::arg_end(), llvm::Function::back(), BB, llvm::Function::begin(), llvm::BasicBlock::begin(), CloneFunctionInto(), llvm::ClonedCodeInfo::ContainsCalls, llvm::ClonedCodeInfo::ContainsDynamicAllocas, llvm::ClonedCodeInfo::ContainsUnwinds, E, llvm::Function::end(), llvm::BasicBlock::end(), llvm::BasicBlock::eraseFromParent(), llvm::Function::front(), llvm::PointerType::get(), llvm::UndefValue::get(), llvm::AllocationInst::getArraySize(), llvm::Function::getBasicBlockList(), llvm::CallSite::getCalledFunction(), llvm::BasicBlock::getInstList(), llvm::CallSite::getInstruction(), llvm::Value::getName(), llvm::Instruction::getOpcode(), llvm::Module::getOrInsertFunction(), llvm::CallGraph::getOrInsertFunction(), llvm::Instruction::getParent(), llvm::BasicBlock::getParent(), llvm::GlobalValue::getParent(), llvm::BasicBlock::getTerminator(), HandleInlinedInvoke(), I, II, M, PHI, llvm::Value::replaceAllUsesWith(), llvm::Type::SByteTy, llvm::User::setOperand(), llvm::Function::size(), llvm::BasicBlock::splitBasicBlock(), UpdateCallGraphAfterInlining(), ValueMap, and llvm::Type::VoidTy.

Function* llvm::ExtractCodeRegion ( DominatorSet DS,
const std::vector< BasicBlock * > &  code,
bool  AggregateArgs 
)

ExtractCodeRegion - slurp a sequence of basic blocks into a brand new function

Definition at line 731 of file CodeExtractor.cpp.

References DS.

Function* llvm::ExtractLoop ( DominatorSet DS,
Loop L,
bool  AggregateArgs 
)

ExtractBasicBlock - slurp a natural loop into a brand new function

Definition at line 739 of file CodeExtractor.cpp.

References DS, and llvm::Loop::getBlocks().

Function* llvm::ExtractBasicBlock ( BasicBlock BB,
bool  AggregateArgs 
)

ExtractBasicBlock - slurp a basic block into a brand new function

Definition at line 745 of file CodeExtractor.cpp.

References BB, and Blocks.

bool llvm::doConstantPropagation ( BasicBlock::iterator II  ) 

doConstantPropagation - If an instruction references constants, try to fold them together...

Definition at line 34 of file Transforms/Utils/Local.cpp.

References llvm::CallingConv::C, and ConstantFoldInstruction().

bool llvm::ConstantFoldTerminator ( BasicBlock BB  ) 

ConstantFoldTerminator - If a terminator instruction is predicated on a constant value, convert it into an unconditional branch to the constant destination. This is a nontrivial operation because the successors of this basic block must have their PHI nodes updated.

Definition at line 132 of file Transforms/Utils/Local.cpp.

References BB, llvm::BasicBlock::getInstList(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getTerminator(), llvm::BasicBlock::removePredecessor(), and T.

Referenced by MarkAliveBlocks(), and SimplifyCFG().

Constant* llvm::ConstantFoldInstruction ( Instruction I  ) 

ConstantFoldInstruction - Attempt to constant fold the specified instruction. If successful, the constant result is returned, if not, null is returned. Note that this function can only fail when attempting to fold instructions like loads and stores, which have no constant expression form.

Definition at line 52 of file Transforms/Utils/Local.cpp.

References llvm::CallingConv::C, canConstantFoldCallTo(), llvm::Instruction::Cast, ConstantFoldCall(), llvm::Instruction::ExtractElement, F, llvm::ConstantExpr::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getExtractElement(), llvm::ConstantExpr::getGetElementPtr(), llvm::ConstantExpr::getInsertElement(), llvm::Constant::getNullValue(), llvm::ConstantExpr::getSelect(), llvm::ConstantExpr::getShuffleVector(), llvm::Value::getType(), llvm::Instruction::InsertElement, Op, llvm::Instruction::Select, and llvm::Instruction::ShuffleVector.

Referenced by CleanupConstantGlobalUsers(), ConstantPropUsersOf(), doConstantPropagation(), and FoldCondBranchOnPHI().

Constant* llvm::ConstantFoldLoadThroughGEPConstantExpr ( Constant C,
ConstantExpr CE 
)

ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a getelementptr constantexpr, return the constant value being addressed by the constant expression, or null if something is funny and we can't decide.

Definition at line 251 of file Transforms/Utils/Local.cpp.

References llvm::CallingConv::C, CP, E, gep_type_begin(), gep_type_end(), llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::ConstantExpr::getOperand(), llvm::Constant::getOperand(), llvm::Value::getType(), and I.

Referenced by CleanupConstantGlobalUsers(), ComputeLoadResult(), and isSimpleEnoughPointerToCommit().

bool llvm::isInstructionTriviallyDead ( Instruction I  ) 

isInstructionTriviallyDead - Return true if the result produced by the instruction is not used, and the instruction has no side effects.

Definition at line 309 of file Transforms/Utils/Local.cpp.

References F, llvm::Instruction::mayWriteToMemory(), and llvm::Value::use_empty().

Referenced by dceInstruction(), ErasePossiblyDeadInstructionTree(), and SimplifyCFG().

bool llvm::dceInstruction ( BasicBlock::iterator BBI  ) 

dceInstruction - Inspect the instruction at *BBI and figure out if it isTriviallyDead. If so, remove the instruction and update the iterator to point to the instruction that immediately succeeded the original instruction.

Definition at line 329 of file Transforms/Utils/Local.cpp.

References isInstructionTriviallyDead().

bool llvm::SimplifyCFG ( BasicBlock BB  ) 

SimplifyCFG - This function is used to do simplification of a CFG. For example, it adjusts branches to branches to eliminate the extra hop, it eliminates unreachable basic blocks, and does other "peephole" optimization of the CFG. It returns true if a modification was made, possibly deleting the basic block that was pointed to.

WARNING: The entry node of a method may not be simplified.

Definition at line 1151 of file Utils/SimplifyCFG.cpp.

References llvm::SwitchInst::addCase(), llvm::PHINode::addIncoming(), AddPredecessorToBlock(), llvm::BasicBlock::back(), BB, llvm::BasicBlock::begin(), BlockIsSimpleEnoughToThreadThrough(), llvm::Type::BoolTy, Changed, llvm::BinaryOperator::clone(), ConstantFoldTerminator(), llvm::BinaryOperator::create(), llvm::BinaryOperator::createNot(), DEBUG, E, llvm::BasicBlock::empty(), llvm::BasicBlock::end(), ErasePossiblyDeadInstructionTree(), FoldCondBranchOnPHI(), FoldTwoEntryPHINode(), FoldValueComparisonIntoPredecessors(), llvm::Function::front(), llvm::BasicBlock::front(), GatherValueComparisons(), llvm::UndefValue::get(), llvm::ConstantBool::get(), llvm::PHINode::getBasicBlockIndex(), llvm::PHINode::getIncomingValue(), llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), llvm::TargetInstrInfo::getName(), llvm::Value::getName(), llvm::User::getNumOperands(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getSinglePredecessor(), llvm::BasicBlock::getTerminator(), llvm::Value::hasName(), HoistThenElseCodeToIf(), I, II, isInstructionTriviallyDead(), isValueEqualityComparison(), M, PI, pred_begin(), pred_end(), Preds, llvm::BasicBlock::removePredecessor(), llvm::Value::replaceAllUsesWith(), SafeToMergeTerminators(), SE, llvm::PHINode::setIncomingValue(), llvm::Value::setName(), llvm::User::setOperand(), SimplifyCFG(), SimplifyEqualityComparisonWithOnlyPredecessor(), succ_begin(), succ_end(), TryToSimplifyUncondBranchFromEmptyBlock(), and V.

Referenced by SimplifyCFG().

AllocaInst* llvm::DemoteRegToStack ( Instruction I,
bool  VolatileLoads 
)

DemoteRegToStack - This function takes a virtual register computed by an Instruction and replaces it with a slot in the stack frame, allocated via alloca. This allows the CFG to be changed around without fear of invalidating the SSA information for the value. It returns the pointer to the alloca inserted to create a stack slot for I.

Definition at line 32 of file DemoteRegToStack.cpp.

References F, llvm::Value::getName(), llvm::Instruction::getParent(), llvm::BasicBlock::getParent(), llvm::Value::getType(), II, Slot, U, llvm::Value::use_back(), llvm::Value::use_empty(), and V.

bool llvm::isAllocaPromotable ( const AllocaInst AI,
const TargetData TD 
)

isAllocaPromotable - Return true if this alloca is legal for promotion. This is true if there are only loads and stores to the alloca.

Definition at line 35 of file PromoteMemoryToRegister.cpp.

References AI, llvm::Value::use_begin(), and llvm::Value::use_end().

void llvm::PromoteMemToReg ( const std::vector< AllocaInst * > &  Allocas,
DominatorTree DT,
DominanceFrontier DF,
const TargetData TD,
AliasSetTracker AST 
)

PromoteMemToReg - Promote the specified list of alloca instructions into scalar registers, inserting PHI nodes as appropriate. This function makes use of DominanceFrontier information. This function does not modify the CFG of the function at all. All allocas must be from the same function.

If AST is specified, the specified tracker is updated to reflect changes made to the IR.

Definition at line 714 of file PromoteMemoryToRegister.cpp.

References AST, llvm::X86II::DF, DT, RetryList, and TD.

Pass* llvm::createUnifyFunctionExitNodesPass (  ) 

Definition at line 28 of file UnifyFunctionExitNodes.cpp.

template<>
bool llvm::isa_impl< PointerType, Type > ( const Type Ty  )  [inline]

std::ostream & llvm::operator<< ( std::ostream &  OS,
const Type T 
)

Definition at line 1426 of file Type.cpp.

References llvm::Type::print(), and T.

std::ostream& llvm::operator<< ( std::ostream &  OS,
const Value &  V 
) [inline]

Definition at line 185 of file Value.h.

References V.

template<>
bool llvm::isa_impl< Constant, Value > ( const Value &  Val  )  [inline]

template<>
bool llvm::isa_impl< Argument, Value > ( const Value &  Val  )  [inline]

template<>
bool llvm::isa_impl< InlineAsm, Value > ( const Value &  Val  )  [inline]

template<>
bool llvm::isa_impl< Instruction, Value > ( const Value &  Val  )  [inline]

template<>
bool llvm::isa_impl< BasicBlock, Value > ( const Value &  Val  )  [inline]

template<>
bool llvm::isa_impl< Function, Value > ( const Value &  Val  )  [inline]

template<>
bool llvm::isa_impl< GlobalVariable, Value > ( const Value &  Val  )  [inline]

template<>
bool llvm::isa_impl< GlobalValue, Value > ( const Value &  Val  )  [inline]

ModulePass* llvm::createAliasAnalysisCounterPass (  ) 

Definition at line 117 of file AliasAnalysisCounter.cpp.

FunctionPass* llvm::createAAEvalPass (  ) 

Definition at line 77 of file AliasAnalysisEvaluator.cpp.

void llvm::BasicAAStub (  ) 

Definition at line 30 of file BasicAliasAnalysis.cpp.

ImmutablePass* llvm::createNoAAPass (  ) 

Definition at line 84 of file BasicAliasAnalysis.cpp.

ImmutablePass* llvm::createBasicAliasAnalysisPass (  ) 

Definition at line 129 of file BasicAliasAnalysis.cpp.

FunctionPass* llvm::createCFGPrinterPass (  ) 

Definition at line 197 of file CFGPrinter.cpp.

FunctionPass* llvm::createCFGOnlyPrinterPass (  ) 

Definition at line 201 of file CFGPrinter.cpp.

bool llvm::canConstantFoldCallTo ( Function F  ) 

canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function.

Definition at line 34 of file Analysis/ConstantFolding.cpp.

References llvm::Intrinsic::bswap_i16, llvm::Intrinsic::bswap_i32, llvm::Intrinsic::bswap_i64, F, llvm::Intrinsic::isunordered_f32, llvm::Intrinsic::isunordered_f64, Name, llvm::Intrinsic::sqrt_f32, and llvm::Intrinsic::sqrt_f64.

Referenced by CanConstantFold(), and ConstantFoldInstruction().

Constant* llvm::ConstantFoldFP ( double(*)(double)  NativeFP,
double  V,
const Type Ty 
)

ConstantFoldFP - Given a function that evaluates the constant, return an LLVM Constant that represents the evaluated constant

Definition at line 88 of file Analysis/ConstantFolding.cpp.

References llvm::ConstantFP::get(), and Ty.

Referenced by ConstantFoldCall().

Constant* llvm::ConstantFoldCall ( Function F,
const std::vector< Constant * > &  Operands 
)

ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified arguments, returning null if unsuccessful.

Definition at line 99 of file Analysis/ConstantFolding.cpp.

References ByteSwap_16(), ByteSwap_32(), ByteSwap_64(), ConstantFoldFP(), F, llvm::ConstantBool::get(), llvm::ConstantUInt::get(), llvm::ConstantFP::get(), IsNAN(), Name, Op, Ty, and V.

Referenced by ConstantFold(), ConstantFoldInstruction(), and EvaluateFunction().

ModulePass* llvm::createDSAAPass (  ) 

Definition at line 105 of file DataStructureAA.cpp.

ModulePass* llvm::createDSOptPass (  ) 

Definition at line 53 of file DataStructureOpt.cpp.

FunctionPass* llvm::createDataStructureStatsPass (  ) 

Definition at line 66 of file DataStructureStats.cpp.

FunctionPass* llvm::createDataStructureGraphCheckerPass (  ) 

Definition at line 80 of file GraphChecker.cpp.

ModulePass* llvm::createSteensgaardPass (  ) 

Definition at line 83 of file Steensgaard.cpp.

FunctionPass* llvm::createInstCountPass (  ) 

Definition at line 62 of file InstCount.cpp.

ModulePass* llvm::createAndersensPass (  ) 

Definition at line 343 of file Andersens.cpp.

void llvm::BasicCallGraphStub (  ) 

Definition at line 22 of file CallGraph.cpp.

Pass* llvm::createGlobalsModRefPass (  ) 

Definition at line 143 of file GlobalsModRef.cpp.

FunctionPass* llvm::createLoadValueNumberingPass (  ) 

createLoadValueNumberingPass - Create and return a new pass that implements the ValueNumbering interface.

Definition at line 90 of file LoadValueNumbering.cpp.

ImmutablePass* llvm::createNoProfileInfoPass (  ) 

Definition at line 95 of file ProfileInfo.cpp.

ModulePass* llvm::createProfileLoaderPass (  ) 

Definition at line 59 of file ProfileInfoLoaderPass.cpp.

Pass* llvm::createProfileLoaderPass ( const std::string &  Filename  ) 

createProfileLoaderPass - This function returns a Pass that loads the profiling information for the module from the specified filename, making it available to the optimizers.

Definition at line 64 of file ProfileInfoLoaderPass.cpp.

ImmutablePass* llvm::createBasicVNPass (  ) 

Definition at line 90 of file ValueNumbering.cpp.

void llvm::BasicValueNumberingStub (  ) 

Definition at line 236 of file ValueNumbering.cpp.

static uint64_t llvm::atoull ( const char *  Buffer  )  [static]

Definition at line 884 of file Lexer.cpp.

References ThrowException().

static uint64_t llvm::HexIntToVal ( const char *  Buffer  )  [static]

Definition at line 896 of file Lexer.cpp.

References llvm::CallingConv::C, and ThrowException().

Referenced by HexToFP().

static double llvm::HexToFP ( const char *  Buffer  )  [static]

Definition at line 919 of file Lexer.cpp.

References HexIntToVal().

char * llvm::UnEscapeLexed ( char *  Buffer,
bool  AllowNull = false 
)

Definition at line 941 of file Lexer.cpp.

References ThrowException().

Module * llvm::RunVMAsmParser ( const std::string &  Filename,
FILE *  F 
)

Definition at line 1140 of file llvmAsmParser.cpp.

References CurFilename, RunParser(), and set_scan_file().

Referenced by ParseAssemblyFile(), and ParseAssemblyString().

Module * llvm::RunVMAsmParser ( const char *  AsmString,
Module M 
)

Definition at line 1147 of file llvmAsmParser.cpp.

References CurFilename, M, RunParser(), and set_scan_string().

Module* llvm::ParseAssemblyFile ( const std::string &  Filename  ) 

Definition at line 21 of file Parser.cpp.

References F, and RunVMAsmParser().

Module* llvm::ParseAssemblyString ( const char *  AsmString,
Module M 
)

Definition at line 45 of file Parser.cpp.

References M, and RunVMAsmParser().

static void llvm::ThrowException ( const std::string &  message,
int  LineNo = -1 
) [inline, static]

Definition at line 68 of file ParserInternals.h.

References CurFilename, and llvmAsmlineno.

Referenced by atoull(), PerFunctionInfo::FunctionDone(), getBBVal(), getTypeVal(), getVal(), getValNonImprovising(), HexIntToVal(), PerModuleInfo::ModuleDone(), ParseGlobalVariable(), ResolveDefinitions(), RunParser(), setTypeName(), setValueName(), UnEscapeLexed(), and yyerror().

BytecodeHandler * llvm::createBytecodeAnalyzerHandler ( BytecodeAnalysis bca,
std::ostream *  output 
)

A function for creating a BytecodeAnalzer as a handler for the Bytecode reader.

Definition at line 727 of file Analyzer.cpp.

References bca.

Referenced by AnalyzeBytecodeBuffer(), and AnalyzeBytecodeFile().

ModuleProvider* llvm::getBytecodeBufferModuleProvider ( const unsigned char *  Buffer,
unsigned  Length,
const std::string &  ModuleID,
BytecodeHandler H 
)

getBytecodeBufferModuleProvider - lazy function-at-a-time loading from a buffer

Definition at line 259 of file ReaderWrappers.cpp.

References CheckVarargs(), and H.

Referenced by AnalyzeBytecodeBuffer(), llvm::Archive::findModuleDefiningSymbol(), GetBytecodeSymbols(), and ParseBytecodeBuffer().

Module* llvm::ParseBytecodeBuffer ( const unsigned char *  Buffer,
unsigned  Length,
const std::string &  ModuleID,
std::string *  ErrorStr 
)

Parse a given bytecode buffer.

ParseBytecodeBuffer - Parse a given bytecode buffer

Definition at line 269 of file ReaderWrappers.cpp.

References getBytecodeBufferModuleProvider().

Referenced by llvm::Archive::getAllModules(), and llvm::Archive::isBytecodeArchive().

ModuleProvider* llvm::getBytecodeModuleProvider ( const std::string &  Filename,
BytecodeHandler H 
)

getBytecodeModuleProvider - lazy function-at-a-time loading from a file

Parameters:
Filename  Name of file to be read
H  Optional handler for reader events

Definition at line 284 of file ReaderWrappers.cpp.

References CheckVarargs(), and H.

Referenced by AnalyzeBytecodeFile(), GetBytecodeDependentLibraries(), GetBytecodeSymbols(), getMaterializedModuleProvider(), and ParseBytecodeFile().

Module* llvm::ParseBytecodeFile ( const std::string &  Filename,
std::string *  ErrorStr 
)

Parse the given bytecode file.

ParseBytecodeFile - Parse the given bytecode file

Definition at line 294 of file ReaderWrappers.cpp.

References getBytecodeModuleProvider().

Module* llvm::AnalyzeBytecodeFile ( const std::string &  Filename,
BytecodeAnalysis Results,
std::string *  ErrorStr = 0,
std::ostream *  output = 0 
)

Analyze contents of a bytecode File.

This function is the main entry point into the bytecode analysis library. It allows you to simply provide a filename and storage for the Results that will be filled in with the analysis results.

Parameters:
Filename  File to analyze
bca  Statistical output
ErrorStr  Error output
output  Dump output

Definition at line 306 of file ReaderWrappers.cpp.

References bca, createBytecodeAnalyzerHandler(), and getBytecodeModuleProvider().

Module* llvm::AnalyzeBytecodeBuffer ( const unsigned char *  Buffer,
unsigned  BufferSize,
const std::string &  ModuleID,
BytecodeAnalysis Results,
std::string *  ErrorStr = 0,
std::ostream *  output = 0 
)

Analyze contents of a bytecode buffer.

This function is an alternate entry point into the bytecode analysis library. It allows you to provide an arbitrary memory buffer which is assumed to contain a complete bytecode file. The Buffer is analyzed and the Results are filled in.

Parameters:
Buffer  Pointer to start of bytecode buffer
Length  Size of the bytecode buffer
ModuleID  Identifier for the module
bca  The results of the analysis
ErrorStr  Errors, if any.
output  Dump output, if any

Definition at line 325 of file ReaderWrappers.cpp.

References bca, createBytecodeAnalyzerHandler(), and getBytecodeBufferModuleProvider().

bool llvm::GetBytecodeDependentLibraries ( const std::string &  fileName,
Module::LibraryListType deplibs 
)

Get the list of dependent libraries from a bytecode file.

This function will read only the necessary parts of a bytecode file in order to determine the list of dependent libraries encoded within it. The deplibs parameter will contain a vector of strings of the bytecode module's dependent libraries.

Returns:
true on success, false otherwise

Definition at line 345 of file ReaderWrappers.cpp.

References llvm::SetVector< T >::clear(), getBytecodeModuleProvider(), llvm::Module::getLibraries(), and M.

bool llvm::GetBytecodeSymbols ( const sys::Path fileName,
std::vector< std::string > &  syms 
)

Get a bytecode file's externally visibile defined global symbols.

This function will read only the necessary parts of a bytecode file in order to obtain a list of externally visible global symbols that the bytecode module defines. This is used for archiving and linking when only the list of symbols the module defines is needed.

Returns:
true on success, false otherwise

Definition at line 375 of file ReaderWrappers.cpp.

References getBytecodeModuleProvider(), getSymbols(), M, and llvm::sys::Path::toString().

ModuleProvider* llvm::GetBytecodeSymbols ( const unsigned char *  Buffer,
unsigned  Length,
const std::string &  ModuleID,
std::vector< std::string > &  symbols 
)

Get a bytecode file's externally visibile defined global symbols.

This function will read only the necessary parts of a bytecode buffer in order to obtain a list of externally visible global symbols that the bytecode module defines. This is used for archiving and linking when only the list of symbols the module defines is needed and the bytecode is already in memory.

Returns:
the ModuleProvider on success, 0 if the bytecode can't be parsed
Parameters:
Buffer  The buffer to be parsed
Length  The length of Buffer
ModuleID  An identifier for the module
symbols  The symbols defined in the module

Definition at line 396 of file ReaderWrappers.cpp.

References getBytecodeBufferModuleProvider(), getSymbols(), M, and llvm::ModuleProvider::materializeModule().

void llvm::WriteBytecodeToFile ( const Module M,
std::ostream &  Out,
bool  compress 
)

Definition at line 1206 of file Bytecode/Writer/Writer.cpp.

References Buffer, BytesWritten, llvm::Compressor::compressToStream(), and M.

Referenced by llvm::WriteBytecodePass::runOnModule().

FunctionPass* llvm::createBranchFoldingPass (  ) 

BranchFolding Pass - This pass performs machine code CFG based optimizations to delete branches to branches, eliminate branches to successor blocks (creating fall throughs), and eliminating branches over branches.

Definition at line 43 of file BranchFolding.cpp.

std::ostream& llvm::operator<< ( std::ostream &  os,
const LiveRange LR 
)

Definition at line 401 of file LiveInterval.cpp.

References llvm::LiveRange::end, llvm::LiveRange::start, and llvm::LiveRange::ValId.

FunctionPass* llvm::createMachineFunctionPrinterPass ( std::ostream *  OS,
const std::string &  Banner 
)

Returns a newly-created MachineFunction Printer pass. The default output stream is std::cerr; the default banner is empty.

Definition at line 64 of file MachineFunction.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createMachineCodeDeleter (  ) 

MachineCodeDeletion Pass - This pass deletes all of the machine code for the current function, which should happen after the function has been emitted to a .s file or to memory.

Definition at line 84 of file MachineFunction.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitMachineCode(), llvm::PPCTargetMachine::addPassesToEmitMachineCode(), and llvm::X86TargetMachine::addPassesToEmitMachineCode().

FunctionPass* llvm::createRegisterAllocator (  ) 

Creates a register allocator as the user specified on the command line.

Definition at line 36 of file Passes.cpp.

References abort(), createLinearScanRegisterAllocator(), createLocalRegisterAllocator(), createSimpleRegisterAllocator(), local, and RegAlloc.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createPrologEpilogCodeInserter (  ) 

createPrologEpilogCodeInserter - This function returns a pass that inserts prolog and epilog code, and eliminates abstract frame references.

Definition at line 94 of file PrologEpilogInserter.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLinearScanRegisterAllocator (  ) 

LinearScanRegisterAllocation Pass - This pass implements the linear scan register allocation algorithm, a global register allocator.

Definition at line 763 of file RegAllocLinearScan.cpp.

Referenced by createRegisterAllocator().

FunctionPass* llvm::createLocalRegisterAllocator (  ) 

LocalRegisterAllocation Pass - This pass register allocates the input code a basic block at a time, yielding code better than the simple register allocator, but not as good as a global allocator.

Definition at line 694 of file RegAllocLocal.cpp.

Referenced by createRegisterAllocator().

FunctionPass* llvm::createSimpleRegisterAllocator (  ) 

SimpleRegisterAllocation Pass - This pass converts the input machine code from SSA form to use explicit registers by spilling every register. Wow, great policy huh?

Definition at line 246 of file RegAllocSimple.cpp.

Referenced by createRegisterAllocator().

llvm::ScheduleDAG* llvm::createBURRListDAGScheduler ( SelectionDAG DAG,
MachineBasicBlock BB 
)

createBURRListDAGScheduler - This creates a bottom up register usage reduction list scheduler.

Definition at line 1086 of file ScheduleDAGList.cpp.

References BB, DAG, and llvm::SelectionDAG::getTarget().

Referenced by llvm::SelectionDAGISel::ScheduleAndEmitDAG().

ScheduleDAG* llvm::createTDListDAGScheduler ( SelectionDAG DAG,
MachineBasicBlock BB,
HazardRecognizer HR 
)

createTDListDAGScheduler - This creates a top-down list scheduler with the specified hazard recognizer.

Definition at line 1095 of file ScheduleDAGList.cpp.

References BB, DAG, and llvm::SelectionDAG::getTarget().

Referenced by llvm::SelectionDAGISel::ScheduleAndEmitDAG().

llvm::ScheduleDAG* llvm::createSimpleDAGScheduler ( bool  NoItins,
SelectionDAG DAG,
MachineBasicBlock BB 
)

createSimpleDAGScheduler - This creates a simple two pass instruction scheduler.

Definition at line 1104 of file ScheduleDAGSimple.cpp.

References BB, DAG, and llvm::SelectionDAG::getTarget().

Referenced by llvm::SelectionDAGISel::ScheduleAndEmitDAG().

llvm::ScheduleDAG* llvm::createBFS_DAGScheduler ( SelectionDAG DAG,
MachineBasicBlock BB 
)

Definition at line 1110 of file ScheduleDAGSimple.cpp.

References BB, DAG, and llvm::SelectionDAG::getTarget().

Referenced by llvm::SelectionDAGISel::ScheduleAndEmitDAG().

FunctionPass* llvm::createUnreachableBlockEliminationPass (  ) 

createUnreachableBlockEliminationPass - The LLVM code generator does not work well with unreachable basic blocks (what live ranges make sense for a block that cannot be reached?). As such, a code generator should either not instruction select unreachable blocks, or it can run this pass as it's last LLVM modifying pass to clean up blocks that are not reachable from the entry block.

Definition at line 41 of file UnreachableBlockElim.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

Spiller * llvm::createSpiller (  ) 

createSpiller - Create an return a spiller object, as specified on the command line.

Definition at line 805 of file VirtRegMap.cpp.

References local, and SpillerOpt.

std::ostream& llvm::operator<< ( std::ostream &  OS,
const VirtRegMap &  VRM 
) [inline]

Definition at line 144 of file VirtRegMap.h.

References llvm::VirtRegMap::print().

bool llvm::isCurrentDebugType ( const char *  DebugType  ) 

Definition at line 59 of file Debug.cpp.

int llvm::DiffFilesWithTolerance ( const sys::Path FileA,
const sys::Path FileB,
double  AbsTol,
double  RelTol,
std::string *  Error 
)

DiffFilesWithTolerance - Compare the two files specified, returning 0 if the files match, 1 if they are different, and 2 if there is a file error. This function differs from DiffFiles in that you can specify an absolete and relative FP error that is allowed to exist. If you specify a string to fill in for the error option, it will set the string to an error message if an error occurs, allowing the caller to distinguish between a failed diff and a file system error.

Definition at line 145 of file FileUtilities.cpp.

References BackupNumber(), llvm::sys::MappedFile::charBase(), CompareNumbers(), llvm::sys::Path::getSize(), isNumberChar(), llvm::sys::MappedFile::map(), and PadFileIfNeeded().

std::ostream * llvm::GetLibSupportInfoOutputFile (  ) 

Definition at line 262 of file Timer.cpp.

References getLibSupportInfoOutputFilename().

Referenced by llvm::StatisticBase::destroy().

std::string llvm::getToken ( std::string &  Source,
const char *  Delimiters 
)

getToken - This function extracts one token from source, ignoring any leading characters that appear in the Delimiters string, and ending the token at any of the characters that appear in the Delimiters string. If there are no tokens in the source string, an empty string is returned. The Source source string is updated in place to remove the returned string and any delimiter prefix from it.

Definition at line 23 of file StringExtras.cpp.

Referenced by llvm::Debugger::loadProgram().

bool llvm::CheckBytecodeOutputToConsole ( std::ostream *  stream_to_check,
bool  print_warning = true 
)

Check for output written to a console.

Determine if the ostream provided is connected to the std::cout and displayed or not (to a console window). If so, generate a warning message advising against display of bytecode and return true. Otherwise just return false

Parameters:
stream_to_check  The stream to be checked
print_warning  Control whether warnings are printed

Definition at line 21 of file SystemUtils.cpp.

References llvm::sys::Process::StandardOutIsDisplayed().

sys::Path llvm::FindExecutable ( const std::string &  ExeName,
const std::string &  ProgramPath 
)

Find a named executable.

FindExecutable - Find a named executable, giving the argv[0] of program being executed. This allows us to find another LLVM tool if it is built into the same directory, but that directory is neither the current directory, nor in the PATH. If the executable cannot be found, return an empty string.

Definition at line 42 of file SystemUtils.cpp.

References llvm::sys::Path::appendComponent(), llvm::sys::Path::canExecute(), llvm::sys::Path::eraseComponent(), llvm::sys::Program::FindProgramByName(), and llvm::sys::Path::isEmpty().

Referenced by llvm::GCC::create(), llvm::AbstractInterpreter::createCBE(), llvm::AbstractInterpreter::createJIT(), llvm::AbstractInterpreter::createLLC(), and llvm::AbstractInterpreter::createLLI().

std::ostream* llvm::GetLibSupportInfoOutputFile (  ) 

Definition at line 262 of file Timer.cpp.

References getLibSupportInfoOutputFilename().

Referenced by llvm::StatisticBase::destroy().

FunctionPass* llvm::createAlphaSimpleInstructionSelector ( TargetMachine &  TM  ) 

FunctionPass* llvm::createAlphaISelDag ( TargetMachine TM  ) 

createAlphaISelDag - This pass converts a legalized DAG into a Alpha-specific DAG, ready for instruction scheduling.

Definition at line 516 of file AlphaISelDAGToDAG.cpp.

References TM.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createAlphaCodePrinterPass ( std::ostream &  o,
TargetMachine tm 
)

createAlphaCodePrinterPass - Returns a pass that prints the Alpha assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 70 of file AlphaAsmPrinter.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createAlphaPatternInstructionSelector ( TargetMachine &  TM  ) 

FunctionPass* llvm::createAlphaCodeEmitterPass ( MachineCodeEmitter MCE  ) 

createAlphaCodeEmitterPass - Return a pass that emits the collected Alpha code to the specified MCE object.

Definition at line 76 of file AlphaCodeEmitter.cpp.

References MCE.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitMachineCode().

FunctionPass* llvm::createAlphaCodePrinterPass ( std::ostream &  o,
TargetMachine tm 
)

createAlphaCodePrinterPass - Returns a pass that prints the Alpha assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 70 of file AlphaAsmPrinter.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createAlphaCodeEmitterPass ( MachineCodeEmitter MCE  ) 

createAlphaCodeEmitterPass - Return a pass that emits the collected Alpha code to the specified MCE object.

Definition at line 76 of file AlphaCodeEmitter.cpp.

References MCE.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitMachineCode().

FunctionPass* llvm::createAlphaISelDag ( TargetMachine TM  ) 

createAlphaISelDag - This pass converts a legalized DAG into a Alpha-specific DAG, ready for instruction scheduling.

Definition at line 516 of file AlphaISelDAGToDAG.cpp.

References TM.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createIA64DAGToDAGInstructionSelector ( IA64TargetMachine TM  ) 

createIA64DAGToDAGInstructionSelector - This pass converts a legalized DAG into an IA64-specific DAG, ready for instruction scheduling.

Definition at line 626 of file IA64ISelDAGToDAG.cpp.

References TM.

Referenced by llvm::IA64TargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createIA64BundlingPass ( IA64TargetMachine tm  ) 

createIA64BundlingPass - Returns a pass that adds STOP (;;) instructions and arranges the result into bundles.

Definition at line 67 of file IA64Bundling.cpp.

Referenced by llvm::IA64TargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createIA64CodePrinterPass ( std::ostream &  o,
IA64TargetMachine tm 
)

createIA64CodePrinterPass - Returns a pass that prints the IA64 assembly code for a MachineFunction to the given output stream, using the given target machine description.

Definition at line 377 of file IA64AsmPrinter.cpp.

Referenced by llvm::IA64TargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createIA64CodePrinterPass ( std::ostream &  o,
IA64TargetMachine tm 
)

createIA64CodePrinterPass - Returns a pass that prints the IA64 assembly code for a MachineFunction to the given output stream, using the given target machine description.

Definition at line 377 of file IA64AsmPrinter.cpp.

Referenced by llvm::IA64TargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createIA64BundlingPass ( IA64TargetMachine tm  ) 

createIA64BundlingPass - Returns a pass that adds STOP (;;) instructions and arranges the result into bundles.

Definition at line 67 of file IA64Bundling.cpp.

Referenced by llvm::IA64TargetMachine::addPassesToEmitFile().

const MachineInstrBuilder & llvm::addFrameReference ( const MachineInstrBuilder &  MIB,
int  FI,
int  Offset = 0,
bool  mem = true 
) [inline]

addFrameReference - This function is used to add a reference to the base of an abstract object on the stack frame of the current function. This reference has base register as the FrameIndex offset until it is resolved. This allows a constant offset to be specified as well...

Definition at line 29 of file IA64InstrBuilder.h.

References llvm::MachineInstrBuilder::addFrameIndex(), llvm::MachineInstrBuilder::addSImm(), and Offset.

Referenced by EmitSpecialCodeForMain(), llvm::PPCRegisterInfo::foldMemoryOperand(), llvm::X86TargetLowering::InsertAtEndOfBasicBlock(), llvm::X86RegisterInfo::loadRegFromStackSlot(), llvm::PPCRegisterInfo::loadRegFromStackSlot(), MakeM0Inst(), MakeMIInst(), MakeMInst(), MakeMRIInst(), MakeMRInst(), MakeRMIInst(), MakeRMInst(), llvm::X86RegisterInfo::storeRegToStackSlot(), and llvm::PPCRegisterInfo::storeRegToStackSlot().

const MachineInstrBuilder & llvm::addConstantPoolReference ( const MachineInstrBuilder &  MIB,
unsigned  CPI,
int  Offset = 0 
) [inline]

addConstantPoolReference - This function is used to add a reference to the base of a constant value spilled to the per-function constant pool. The reference has base register ConstantPoolIndex offset which is retained until either machine code emission or assembly output. This allows an optional offset to be added as well.

Definition at line 44 of file IA64InstrBuilder.h.

References llvm::MachineInstrBuilder::addConstantPoolIndex(), llvm::MachineInstrBuilder::addSImm(), and Offset.

FunctionPass* llvm::createIA64DAGToDAGInstructionSelector ( IA64TargetMachine TM  ) 

createIA64DAGToDAGInstructionSelector - This pass converts a legalized DAG into an IA64-specific DAG, ready for instruction scheduling.

Definition at line 626 of file IA64ISelDAGToDAG.cpp.

References TM.

Referenced by llvm::IA64TargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createPPCBranchSelectionPass (  ) 

createPPCBranchSelectionPass - returns an instance of the Branch Selection Pass

Definition at line 41 of file PPCBranchSelector.cpp.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile(), and llvm::PPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createPPCISelDag ( PPCTargetMachine TM  ) 

createPPCISelDag - This pass converts a legalized DAG into a PowerPC-specific DAG, ready for instruction scheduling.

Definition at line 1253 of file PPCISelDAGToDAG.cpp.

References TM.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile(), and llvm::PPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createDarwinAsmPrinter ( std::ostream &  o,
PPCTargetMachine tm 
)

createDarwinAsmPrinterPass - Returns a pass that prints the PPC assembly code for a MachineFunction to the given output stream, in a format that the Darwin assembler can deal with.

Definition at line 333 of file PPCAsmPrinter.cpp.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createAIXAsmPrinter ( std::ostream &  o,
PPCTargetMachine tm 
)

createAIXAsmPrinterPass - Returns a pass that prints the PPC assembly code for a MachineFunction to the given output stream, in a format that the AIX 5L assembler can deal with.

Definition at line 342 of file PPCAsmPrinter.cpp.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createDarwinAsmPrinter ( std::ostream &  o,
PPCTargetMachine tm 
)

createDarwinAsmPrinterPass - Returns a pass that prints the PPC assembly code for a MachineFunction to the given output stream, in a format that the Darwin assembler can deal with.

Definition at line 333 of file PPCAsmPrinter.cpp.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createAIXAsmPrinter ( std::ostream &  o,
PPCTargetMachine tm 
)

createAIXAsmPrinterPass - Returns a pass that prints the PPC assembly code for a MachineFunction to the given output stream, in a format that the AIX 5L assembler can deal with.

Definition at line 342 of file PPCAsmPrinter.cpp.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createPPCBranchSelectionPass (  ) 

createPPCBranchSelectionPass - returns an instance of the Branch Selection Pass

Definition at line 41 of file PPCBranchSelector.cpp.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile(), and llvm::PPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createPPCISelDag ( PPCTargetMachine TM  ) 

createPPCISelDag - This pass converts a legalized DAG into a PowerPC-specific DAG, ready for instruction scheduling.

Definition at line 1253 of file PPCISelDAGToDAG.cpp.

References TM.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile(), and llvm::PPCJITInfo::addPassesToJITCompile().

cl::opt<PPCTargetEnum, true> llvm::PPCTargetArg ( cl::  desc("Force generation of code for a specific PPC target:"),
cl::  values(clEnumValN(TargetAIX,"aix"," Enable AIX codegen"), clEnumValN(TargetDarwin,"darwin"," Enable Darwin codegen"), clEnumValEnd),
cl::  location(PPCTarget),
cl::  init(TargetDefault) 
)

FunctionPass * llvm::createSparcDelaySlotFillerPass ( TargetMachine tm  ) 

createSparcDelaySlotFillerPass - Returns a pass that fills in delay slots in Sparc MachineFunctions

Definition at line 53 of file DelaySlotFiller.cpp.

Referenced by llvm::SparcTargetMachine::addPassesToEmitFile().

FunctionPass * llvm::createSparcFPMoverPass ( TargetMachine tm  ) 

createSparcFPMoverPass - Returns a pass that turns FpMOVD instructions into FMOVS instructions

Definition at line 48 of file FPMover.cpp.

Referenced by llvm::SparcTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createSparcISelDag ( TargetMachine TM  ) 

createSparcISelDag - This pass converts a legalized DAG into a SPARC-specific DAG, ready for instruction scheduling.

Definition at line 1132 of file SparcISelDAGToDAG.cpp.

References TM.

Referenced by llvm::SparcTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createSparcCodePrinterPass ( std::ostream &  o,
TargetMachine tm 
)

createSparcCodePrinterPass - Returns a pass that prints the SPARC assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 78 of file SparcAsmPrinter.cpp.

Referenced by llvm::SparcTargetMachine::addPassesToEmitFile().

static const char* llvm::SPARCCondCodeToString ( SPCC::CondCodes  CC  )  [static]

Definition at line 82 of file Sparc.h.

References llvm::SPCC::FCC_E, llvm::SPCC::FCC_G, llvm::SPCC::FCC_GE, llvm::SPCC::FCC_L, llvm::SPCC::FCC_LE, llvm::SPCC::FCC_LG, llvm::SPCC::FCC_NE, llvm::SPCC::FCC_O, llvm::SPCC::FCC_U, llvm::SPCC::FCC_UE, llvm::SPCC::FCC_UG, llvm::SPCC::FCC_UGE, llvm::SPCC::FCC_UL, llvm::SPCC::FCC_ULE, llvm::SPCC::ICC_CC, llvm::SPCC::ICC_CS, llvm::SPCC::ICC_E, llvm::SPCC::ICC_G, llvm::SPCC::ICC_GE, llvm::SPCC::ICC_GU, llvm::SPCC::ICC_L, llvm::SPCC::ICC_LE, llvm::SPCC::ICC_LEU, llvm::SPCC::ICC_NE, llvm::SPCC::ICC_NEG, llvm::SPCC::ICC_POS, llvm::SPCC::ICC_VC, and llvm::SPCC::ICC_VS.

FunctionPass* llvm::createSparcCodePrinterPass ( std::ostream &  o,
TargetMachine tm 
)

createSparcCodePrinterPass - Returns a pass that prints the SPARC assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 78 of file SparcAsmPrinter.cpp.

Referenced by llvm::SparcTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createSparcISelDag ( TargetMachine TM  ) 

createSparcISelDag - This pass converts a legalized DAG into a SPARC-specific DAG, ready for instruction scheduling.

Definition at line 1132 of file SparcISelDAGToDAG.cpp.

References TM.

Referenced by llvm::SparcTargetMachine::addPassesToEmitFile().

FunctionPass * llvm::createDecomposeMultiDimRefsPass (  ) 

Definition at line 52 of file DecomposeMultiDimRefs.cpp.

bool llvm::DecomposeArrayRef ( GetElementPtrInst GEP  ) 

Definition at line 83 of file DecomposeMultiDimRefs.cpp.

References BB, DEBUG, llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::Instruction::getNext(), llvm::Constant::getNullValue(), llvm::GetElementPtrInst::getNumIndices(), llvm::User::getOperand(), llvm::Instruction::getParent(), llvm::GetElementPtrInst::getPointerOperand(), llvm::Value::getType(), llvm::GetElementPtrInst::idx_begin(), llvm::GetElementPtrInst::idx_end(), isZeroConst(), llvm::Type::LongTy, NumAdded, OE, OI, and llvm::Value::replaceAllUsesWith().

ModulePass * llvm::createBytecodeAsmPrinterPass ( std::ostream &  Out  ) 

getBytecodeAsmPrinterPass - Emits final LLVM bytecode to assembly file.

Definition at line 112 of file EmitBytecodeToAssembly.cpp.

static void llvm::AssignInstructionsToSlots ( class SchedulingManager &  S,
unsigned  maxIssue 
) [static]

Definition at line 568 of file InstrScheduling.cpp.

Referenced by ChooseOneGroup().

static void llvm::RecordSchedule ( MachineBasicBlock &  MBB,
const SchedulingManager &  S 
) [static]

Definition at line 629 of file InstrScheduling.cpp.

References llvm::InstrSchedule::begin(), llvm::MachineBasicBlock::begin(), llvm::InstrSchedule::end(), llvm::MachineBasicBlock::end(), llvm::TargetSchedInfo::getInstrInfo(), llvm::InstrSchedule::getNumInstructions(), I, llvm::SchedulingManager::isched, MBB, NI, PHI, llvm::MachineBasicBlock::push_back(), llvm::MachineBasicBlock::remove(), and llvm::SchedulingManager::schedInfo.

static void llvm::MarkSuccessorsReady ( SchedulingManager &  S,
const SchedGraphNode *  node 
) [static]

Definition at line 664 of file InstrScheduling.cpp.

References llvm::SchedPriorities::insertReady(), llvm::SchedulingManager::isScheduled(), llvm::SchedPriorities::nodeIsReady(), pred_begin(), pred_end(), llvm::SchedulingManager::schedPrio, succ_begin(), and succ_end().

Referenced by ForwardListSchedule().

static unsigned llvm::FindSlotChoices ( SchedulingManager &  S,
DelaySlotInfo *&  getDelaySlotInfo 
) [static]

Definition at line 699 of file InstrScheduling.cpp.

References llvm::SchedulingManager::addChoice(), llvm::SchedulingManager::addChoiceToSlot(), llvm::TargetSchedInfo::breaksIssueGroup(), llvm::SchedulingManager::getChoice(), llvm::SchedulingManager::getDelaySlotInfoForInstr(), llvm::InstrSchedule::getIGroup(), llvm::SchedulingManager::getInstrInfo(), llvm::SchedPriorities::getNextHighest(), llvm::SchedulingManager::getNumChoices(), llvm::TargetInstrInfo::getNumDelaySlots(), llvm::SchedGraphNode::getOpcode(), llvm::SchedulingManager::getTime(), llvm::TargetSchedInfo::instrCanUseSlot(), llvm::SchedulingManager::isched, llvm::TargetSchedInfo::isSingleIssue(), llvm::SchedulingManager::nslots, llvm::DelaySlotInfo::recordChosenSlot(), llvm::SchedulingManager::resetChoices(), llvm::SchedulingManager::schedInfo, and llvm::SchedulingManager::schedPrio.

Referenced by ChooseOneGroup().

static unsigned llvm::ChooseOneGroup ( SchedulingManager &  S  )  [static]

Definition at line 932 of file InstrScheduling.cpp.

References AssignInstructionsToSlots(), c, FindSlotChoices(), llvm::InstrSchedule::getIGroup(), llvm::SchedPriorities::getNumReady(), llvm::SchedulingManager::getTime(), llvm::SchedulingManager::isched, llvm::SchedulingManager::nslots, Sched_PrintSchedTrace, llvm::SchedulingManager::schedPrio, llvm::DelaySlotInfo::scheduleDelayedNode(), and llvm::SchedulingManager::updateTime().

Referenced by ForwardListSchedule().

static void llvm::ForwardListSchedule ( SchedulingManager &  S  )  [static]

Definition at line 973 of file InstrScheduling.cpp.

References c, ChooseOneGroup(), llvm::SchedulingManager::getEarliestIssueTime(), llvm::SchedPriorities::getEarliestReadyTime(), llvm::InstrSchedule::getIGroup(), llvm::SchedPriorities::getNumReady(), llvm::SchedulingManager::getTime(), llvm::SchedPriorities::initialize(), llvm::SchedulingManager::isched, llvm::SchedPriorities::issuedReadyNodeAt(), MarkSuccessorsReady(), llvm::SchedulingManager::nslots, llvm::SchedulingManager::schedPrio, and llvm::SchedulingManager::updateTime().

static bool llvm::NodeCanFillDelaySlot ( const SchedulingManager &  S,
const SchedGraphNode *  node,
const SchedGraphNode *  brNode,
bool  nodeIsPredecessor 
) [static]

Definition at line 1024 of file InstrScheduling.cpp.

References llvm::SchedGraphNodeCommon::beginInEdges(), llvm::SchedGraphNodeCommon::beginOutEdges(), llvm::SchedGraphEdge::CtrlDep, llvm::SchedGraphNodeCommon::endInEdges(), llvm::SchedGraphNodeCommon::endOutEdges(), llvm::SchedulingManager::getInstrInfo(), llvm::SchedGraphNode::getOpcode(), llvm::TargetInstrInfo::isBranch(), llvm::SchedGraphNode::isDummyNode(), llvm::TargetInstrInfo::isLoad(), llvm::TargetSchedInfo::isSingleIssue(), and llvm::SchedulingManager::schedInfo.

Referenced by FindUsefulInstructionsForDelaySlots().

static void llvm::MarkNodeForDelaySlot ( SchedulingManager &  S,
SchedGraph *  graph,
SchedGraphNode *  node,
const SchedGraphNode *  brNode,
bool  nodeIsPredecessor 
) [static]

Definition at line 1074 of file InstrScheduling.cpp.

References llvm::DelaySlotInfo::addDelayNode(), llvm::SchedGraphCommon::eraseIncidentEdges(), and llvm::SchedulingManager::getDelaySlotInfoForInstr().

Referenced by ReplaceNopsWithUsefulInstr().

void llvm::FindUsefulInstructionsForDelaySlots ( SchedulingManager &  S,
SchedGraphNode *  brNode,
std::vector< SchedGraphNode * > &  sdelayNodeVec 
)

Definition at line 1097 of file InstrScheduling.cpp.

References llvm::SchedulingManager::getInstrInfo(), llvm::TargetInstrInfo::getNumDelaySlots(), llvm::SchedGraphNode::getOpcode(), llvm::TargetInstrInfo::isNop(), llvm::TargetInstrInfo::maxLatency(), NodeCanFillDelaySlot(), pred_begin(), and pred_end().

Referenced by ChooseInstructionsForDelaySlots().

static void llvm::ReplaceNopsWithUsefulInstr ( SchedulingManager &  S,
SchedGraphNode *  node,
std::vector< SchedGraphNode * >  sdelayNodeVec,
SchedGraph *  graph 
) [static]

Definition at line 1158 of file InstrScheduling.cpp.

References abort(), llvm::MachineCodeForInstruction::begin(), llvm::MachineBasicBlock::begin(), llvm::MachineCodeForInstruction::end(), llvm::MachineCodeForInstruction::erase(), llvm::SchedGraphCommon::eraseIncidentEdges(), llvm::MachineCodeForInstruction::get(), llvm::MachineBasicBlock::getBasicBlock(), llvm::SchedGraph::getGraphNodeForInstr(), llvm::SchedulingManager::getInstrInfo(), llvm::SchedGraphNode::getMachineBasicBlock(), llvm::SchedGraphNode::getMachineInstr(), llvm::TargetInstrInfo::getNumDelaySlots(), llvm::MachineInstr::getOpcode(), llvm::SchedGraphNodeCommon::getOrigIndexInBB(), llvm::BasicBlock::getTerminator(), llvm::TargetInstrInfo::isNop(), MarkNodeForDelaySlot(), and MBB.

Referenced by ChooseInstructionsForDelaySlots().

static void llvm::ChooseInstructionsForDelaySlots ( SchedulingManager &  S,
MachineBasicBlock &  MBB,
SchedGraph *  graph 
) [static]

Definition at line 1243 of file InstrScheduling.cpp.

References llvm::MachineBasicBlock::begin(), E, EnableFillingDelaySlots, llvm::MachineBasicBlock::end(), FindUsefulInstructionsForDelaySlots(), first, llvm::MachineCodeForInstruction::get(), llvm::MachineBasicBlock::getBasicBlock(), llvm::SchedGraph::getGraphNodeForInstr(), llvm::SchedulingManager::getInstrInfo(), llvm::TargetInstrInfo::getNumDelaySlots(), llvm::Instruction::getOpcode(), llvm::BasicBlock::getTerminator(), I, llvm::TargetInstrInfo::isBranch(), MBB, ReplaceNopsWithUsefulInstr(), and llvm::MachineCodeForInstruction::size().

static bool llvm::ConflictsWithChoices ( const SchedulingManager &  S,
MachineOpCode  opCode 
) [inline, static]

Definition at line 1366 of file InstrScheduling.cpp.

References llvm::TargetSchedInfo::getMaxIssueForClass(), llvm::SchedulingManager::getNumChoices(), llvm::SchedulingManager::getNumChoicesInClass(), llvm::TargetSchedInfo::getSchedClass(), llvm::TargetSchedInfo::isSingleIssue(), and llvm::SchedulingManager::schedInfo.

Referenced by instrIsFeasible().

static bool llvm::ViolatesMinimumGap ( const SchedulingManager &  S,
MachineOpCode  opCode,
const CycleCount_t  inCycle 
) [inline, static]

Definition at line 1396 of file InstrScheduling.cpp.

References llvm::SchedulingManager::getEarliestStartTimeForOp().

Referenced by instrIsFeasible().

bool llvm::instrIsFeasible ( const SchedulingManager &  S,
MachineOpCode  opCode 
)

Definition at line 1413 of file InstrScheduling.cpp.

References ConflictsWithChoices(), llvm::SchedulingManager::getTime(), and ViolatesMinimumGap().

Referenced by llvm::SchedPriorities::getNextHighest(), and llvm::DelaySlotInfo::scheduleDelayedNode().

sg_pred_iterator llvm::pred_begin ( SchedGraphNode *  N  )  [inline]

Definition at line 193 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::beginInEdges().

sg_pred_iterator llvm::pred_end ( SchedGraphNode *  N  )  [inline]

Definition at line 196 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::endInEdges().

sg_pred_const_iterator llvm::pred_begin ( const SchedGraphNode *  N  )  [inline]

Definition at line 199 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::beginInEdges().

sg_pred_const_iterator llvm::pred_end ( const SchedGraphNode *  N  )  [inline]

Definition at line 202 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::endInEdges().

sg_succ_iterator llvm::succ_begin ( SchedGraphNode *  N  )  [inline]

Definition at line 216 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::beginOutEdges().

sg_succ_iterator llvm::succ_end ( SchedGraphNode *  N  )  [inline]

Definition at line 219 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::endOutEdges().

sg_succ_const_iterator llvm::succ_begin ( const SchedGraphNode *  N  )  [inline]

Definition at line 222 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::beginOutEdges().

sg_succ_const_iterator llvm::succ_end ( const SchedGraphNode *  N  )  [inline]

Definition at line 225 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::endOutEdges().

std::ostream & llvm::operator<< ( std::ostream &  os,
const NodeDelayPair *  nd 
)

Definition at line 29 of file SchedPriorities.cpp.

References llvm::NodeDelayPair::delay, llvm::SchedGraphNodeCommon::getNodeId(), and llvm::NodeDelayPair::node.

bool llvm::NDPLessThan ( const NodeDelayPair *  np1,
const NodeDelayPair *  np2 
) [inline]

Definition at line 70 of file SchedPriorities.h.

References llvm::NodeDelayPair::delay.

ModulePass * llvm::createInternalGlobalMapperPass (  ) 

Definition at line 34 of file InternalGlobalMapper.cpp.

static void llvm::applyTranferFuncForMInst ( ValueSet LVS,
const MachineInstr *  MInst 
) [static]

Definition at line 236 of file FunctionLiveVarInfo.cpp.

References llvm::MachineInstr::begin(), llvm::MachineInstr::end(), llvm::MachineInstr::getImplicitOp(), llvm::MachineInstr::getImplicitRef(), llvm::MachineInstr::getNumImplicitRefs(), llvm::MachineOperand::isDef(), and llvm::MachineOperand::isUse().

ModulePass * llvm::getMappingInfoAsmPrinterPass ( std::ostream &  out  ) 

getMappingInfoAsmPrinterPass - Static factory method: returns a new MappingInfoAsmPrinter Pass object, which uses OUT as its output stream for assembly output.

Definition at line 63 of file MappingInfo.cpp.

static void llvm::writePrologue ( std::ostream &  Out,
const std::string &  comment,
const std::string &  symName 
) [static]

Definition at line 164 of file MappingInfo.cpp.

Referenced by llvm::MappingInfo::dumpAssembly().

static void llvm::writeEpilogue ( std::ostream &  Out,
const std::string &  symName 
) [static]

Definition at line 177 of file MappingInfo.cpp.

Referenced by llvm::MappingInfo::dumpAssembly().

FunctionPass* llvm::createDependenceAnalyzer (  ) 

Create ModuloSchedulingPass.

Definition at line 27 of file DependenceAnalyzer.cpp.

FunctionPass* llvm::createModuloSchedulingPass ( TargetMachine targ  ) 

Create ModuloSchedulingPass

Definition at line 45 of file ModuloScheduling.cpp.

References DEBUG.

FunctionPass* llvm::createModuloSchedulingSBPass ( TargetMachine targ  ) 

Create ModuloSchedulingSBPass

Definition at line 43 of file ModuloSchedulingSuperBlock.cpp.

References DEBUG.

std::ostream& llvm::operator<< ( std::ostream &  os,
const MSchedGraphNode &  node 
) [inline]

Definition at line 207 of file MSchedGraph.h.

References llvm::MSchedGraphNode::print().

static MSchedGraphNode& llvm::getSecond ( std::pair< const MachineInstr *const, MSchedGraphNode * > &  Pair  )  [static]

Definition at line 301 of file MSchedGraph.h.

Referenced by llvm::GraphTraits< Inverse< const MSchedGraphSB * > >::nodes_begin(), llvm::GraphTraits< Inverse< MSchedGraphSB * > >::nodes_begin(), llvm::GraphTraits< const MSchedGraphSB * >::nodes_begin(), llvm::GraphTraits< MSchedGraphSB * >::nodes_begin(), llvm::GraphTraits< Inverse< const MSchedGraph * > >::nodes_begin(), llvm::GraphTraits< Inverse< MSchedGraph * > >::nodes_begin(), llvm::GraphTraits< const MSchedGraph * >::nodes_begin(), llvm::GraphTraits< MSchedGraph * >::nodes_begin(), llvm::GraphTraits< Inverse< const MSchedGraphSB * > >::nodes_end(), llvm::GraphTraits< Inverse< MSchedGraphSB * > >::nodes_end(), llvm::GraphTraits< const MSchedGraphSB * >::nodes_end(), llvm::GraphTraits< MSchedGraphSB * >::nodes_end(), llvm::GraphTraits< Inverse< const MSchedGraph * > >::nodes_end(), llvm::GraphTraits< Inverse< MSchedGraph * > >::nodes_end(), llvm::GraphTraits< const MSchedGraph * >::nodes_end(), and llvm::GraphTraits< MSchedGraph * >::nodes_end().

std::ostream& llvm::operator<< ( std::ostream &  os,
const MSchedGraphSBNode &  node 
) [inline]

Definition at line 217 of file MSchedGraphSB.h.

References llvm::MSchedGraphSBNode::print().

static MSchedGraphSBNode& llvm::getSecond ( std::pair< const MachineInstr *const, MSchedGraphSBNode * > &  Pair  )  [static]

Definition at line 313 of file MSchedGraphSB.h.

static std::ostream& llvm::operator<< ( std::ostream &  OS,
AllocInfo &  S 
) [inline, static]

Definition at line 86 of file AllocInfo.h.

References llvm::AllocInfo::allocStateToString(), llvm::AllocInfo::Instruction, llvm::AllocInfo::Operand, and llvm::AllocInfo::Placement.

static void llvm::assertIGNode ( const InterferenceGraph *  IG,
const IGNode *  Node 
) [inline, static]

Definition at line 24 of file InterferenceGraph.cpp.

References llvm::InterferenceGraph::getIGNodeList(), and Node.

Referenced by llvm::InterferenceGraph::getInterference(), llvm::InterferenceGraph::mergeIGNodesOfLRs(), and llvm::InterferenceGraph::setInterference().

static std::ostream& llvm::operator<< ( std::ostream &  os,
const V9LiveRange &  lr 
) [inline, static]

Definition at line 187 of file LiveRange.h.

bool llvm::InterferesWithColor ( const V9LiveRange &  LR,
unsigned  color 
) [inline]

Definition at line 280 of file LiveRangeInfo.cpp.

References llvm::IGNode::getAdjIGNode(), llvm::IGNode::getNumOfNeighbors(), llvm::IGNode::getParentLR(), and llvm::V9LiveRange::getUserIGNode().

Referenced by InterfsPreventCoalescing().

bool llvm::InterfsPreventCoalescing ( const V9LiveRange &  LROfDef,
const V9LiveRange &  LROfUse 
) [inline]

Definition at line 299 of file LiveRangeInfo.cpp.

References llvm::V9LiveRange::getColor(), llvm::V9LiveRange::hasColor(), llvm::V9LiveRange::hasSuggestedColor(), and InterferesWithColor().

Referenced by llvm::LiveRangeInfo::coalesceLRs().

void llvm::InsertBefore ( MachineInstr *  newMI,
MachineBasicBlock &  MBB,
MachineBasicBlock::iterator MII 
) [inline]

The following are utility functions used solely by updateMachineCode and the functions that it calls. They should probably be folded back into updateMachineCode at some point.

Definition at line 338 of file PhyRegAlloc.cpp.

References llvm::MachineBasicBlock::insert(), and MBB.

Referenced by llvm::BasicBlock::BasicBlock(), CastArg(), InsertPrintInst(), InsertRecordInst(), InsertReleaseInst(), InsertVerbosePrintInst(), llvm::Instruction::Instruction(), and PrependInstructions().

void llvm::InsertAfter ( MachineInstr *  newMI,
MachineBasicBlock &  MBB,
MachineBasicBlock::iterator MII 
) [inline]

Definition at line 345 of file PhyRegAlloc.cpp.

References llvm::MachineBasicBlock::insert(), and MBB.

Referenced by AppendInstructions().

void llvm::PrependInstructions ( std::vector< MachineInstr * > &  IBef,
MachineBasicBlock &  MBB,
MachineBasicBlock::iterator MII,
const std::string &  msg 
) [inline]

Definition at line 352 of file PhyRegAlloc.cpp.

References InsertBefore(), and MBB.

void llvm::AppendInstructions ( std::vector< MachineInstr * > &  IAft,
MachineBasicBlock &  MBB,
MachineBasicBlock::iterator MII,
const std::string &  msg 
) [inline]

Definition at line 370 of file PhyRegAlloc.cpp.

References InsertAfter(), and MBB.

static void llvm::markRegisterUsed ( int  RegNo,
RegClass *  RC,
int  RegType,
const SparcV9RegInfo &  TRI 
) [static]

Modify the IsColorUsedArr of register class RC, by setting the bits corresponding to register RegNo. This is a helper method of setRelRegsUsedByThisInst().

Definition at line 996 of file PhyRegAlloc.cpp.

References llvm::SparcV9RegInfo::getClassRegNum(), and RC.

FunctionPass * llvm::createAsmPrinterPass ( std::ostream &  Out,
TargetMachine TM 
)

Writes out assembly code for the module, one function at a time

Definition at line 801 of file SparcV9AsmPrinter.cpp.

References TM.

uint64_t llvm::ConvertConstantToIntType ( const TargetMachine target,
const Value V,
const Type destType,
bool &  isValidConstant 
)

ConvertConstantToIntType - Function to get the value of an integral constant in the form that must be put into the machine register. The specified constant is interpreted as (i.e., converted if necessary to) the specified destination type. The result is always returned as an uint64_t, since the representation of int64_t and uint64_t are identical. The argument can be any known const. isValidConstant is set to true if a valid constant was found.

Definition at line 524 of file SparcV9BurgISel.cpp.

References llvm::CallingConv::C, llvm::Instruction::Cast, llvm::TargetMachine::getTargetData(), llvm::TargetData::getTypeSize(), GV, llvm::Type::isIntegral(), llvm::Type::isSigned(), target, U, and V.

static void llvm::CreateSETUWConst ( uint32_t  C,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi,
Value val,
bool  isSigned = false 
) [inline, static]

CreateSETUWConst - Copy a 32-bit unsigned constant into the register `dest', using SETHI, OR in the worst case. This function correctly emulates the SETUW pseudo-op for SPARC v9 (if argument isSigned == false). The isSigned=true case is used to implement SETSW without duplicating code. It optimizes some common cases: (1) Small value that fits in simm13 field of OR: don't need SETHI. (2) isSigned = true and C is a small negative signed value, i.e., high bits are 1, and the remaining bits fit in simm13(OR).

Definition at line 616 of file SparcV9BurgISel.cpp.

static void llvm::CreateSETSWConst ( int32_t  C,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi,
Value val 
) [inline, static]

CreateSETSWConst - Set a 32-bit signed constant in the register `dest', with sign-extension to 64 bits. This uses SETHI, OR, SRA in the worst case. This function correctly emulates the SETSW pseudo-op for SPARC v9. It optimizes the same cases as SETUWConst, plus: (1) SRA is not needed for positive or small negative values.

Definition at line 668 of file SparcV9BurgISel.cpp.

static void llvm::CreateSETXConst ( uint64_t  C,
Instruction tmpReg,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi,
Value val 
) [inline, static]

CreateSETXConst - Set a 64-bit signed or unsigned constant in the register `dest'. Use SETUWConst for each 32 bit word, plus a left-shift-by-32 in between. This function correctly emulates the SETX pseudo-op for SPARC v9. It optimizes the same cases as SETUWConst for each 32 bit word.

Definition at line 693 of file SparcV9BurgISel.cpp.

static void llvm::CreateSETUWLabel ( Value val,
Instruction dest,
std::vector< MachineInstr * > &  mvec 
) [inline, static]

CreateSETUWLabel - Set a 32-bit constant (given by a symbolic label) in the register `dest'.

Definition at line 725 of file SparcV9BurgISel.cpp.

static void llvm::CreateSETXLabel ( Value val,
Instruction tmpReg,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
) [inline, static]

CreateSETXLabel - Set a 64-bit constant (given by a symbolic label) in the register `dest'.

Definition at line 747 of file SparcV9BurgISel.cpp.

static void llvm::CreateUIntSetInstruction ( uint64_t  C,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi,
Value val 
) [inline, static]

CreateUIntSetInstruction - Create code to Set an unsigned constant in the register `dest'. Uses CreateSETUWConst, CreateSETSWConst or CreateSETXConst as needed. CreateSETSWConst is an optimization for the case that the unsigned value has all ones in the 33 high bits (so that sign-extension sets them all).

Definition at line 797 of file SparcV9BurgISel.cpp.

static void llvm::CreateIntSetInstruction ( int64_t  C,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi,
Value val 
) [inline, static]

CreateIntSetInstruction - Create code to Set a signed constant in the register `dest'. Really the same as CreateUIntSetInstruction.

Definition at line 818 of file SparcV9BurgISel.cpp.

bool llvm::ConstantMayNotFitInImmedField ( const Constant CV,
const Instruction I 
)

ConstantMayNotFitInImmedField - Test if this constant may not fit in the immediate field of the machine instructions (probably) generated for this instruction.

Definition at line 879 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseLoadInstruction ( const Type DestTy  )  [inline, static]

ChooseLoadInstruction - Return the appropriate load instruction opcode based on the given LLVM value type.

Definition at line 905 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseStoreInstruction ( const Type DestTy  )  [inline, static]

ChooseStoreInstruction - Return the appropriate store instruction opcode based on the given LLVM value type.

Definition at line 927 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseAddInstructionByType ( const Type resultType  )  [inline, static]

Definition at line 946 of file SparcV9BurgISel.cpp.

static unsigned llvm::convertOpcodeFromRegToImm ( unsigned  Opcode  )  [static]

convertOpcodeFromRegToImm - Because the SparcV9 instruction selector likes to re-write operands to instructions, making them change from a Value* (virtual register) to a Constant* (making an immediate field), we need to change the opcode from a register-based instruction to an immediate-based instruction, hence this mapping.

Definition at line 967 of file SparcV9BurgISel.cpp.

void llvm::CreateCodeToLoadConst ( const TargetMachine target,
Function F,
Value val,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
)

CreateCodeToLoadConst - Create an instruction sequence to put the constant `val' into the virtual register `dest'. `val' may be a Constant or a GlobalValue, viz., the constant address of a global variable or function. The generated instructions are returned in `mvec'. Any temp. registers (TmpInstruction) created are recorded in mcfi. Any stack space required is allocated via MachineFunction.

Definition at line 1099 of file SparcV9BurgISel.cpp.

void llvm::CreateCodeToCopyFloatToInt ( const TargetMachine target,
Function F,
Value val,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
)

CreateCodeToCopyFloatToInt - Similarly, create an instruction sequence to copy an FP register `val' to an integer register `dest' by copying to memory and back. The generated instructions are returned in `mvec'. Any temp. virtual registers (TmpInstruction) created are recorded in mcfi. Temporary stack space required is allocated via MachineFunction.

Definition at line 1202 of file SparcV9BurgISel.cpp.

void llvm::CreateBitExtensionInstructions ( bool  signExtend,
const TargetMachine target,
Function F,
Value srcVal,
Value destVal,
unsigned int  numLowBits,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
) [inline]

CreateBitExtensionInstructions - Helper function for sign-extension and zero-extension. For SPARC v9, we sign-extend the given operand using SLL; SRA/SRL.

Definition at line 1244 of file SparcV9BurgISel.cpp.

void llvm::CreateSignExtensionInstructions ( const TargetMachine target,
Function F,
Value srcVal,
Value destVal,
unsigned int  numLowBits,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
)

CreateSignExtensionInstructions - Create instruction sequence to produce a sign-extended register value from an arbitrary-sized integer value (sized in bits, not bytes). The generated instructions are returned in `mvec'. Any temp. registers (TmpInstruction) created are recorded in mcfi. Any stack space required is allocated via MachineFunction.

Definition at line 1272 of file SparcV9BurgISel.cpp.

void llvm::CreateZeroExtensionInstructions ( const TargetMachine target,
Function F,
Value srcVal,
Value destVal,
unsigned int  numLowBits,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
)

CreateZeroExtensionInstructions - Create instruction sequence to produce a zero-extended register value from an arbitrary-sized integer value (sized in bits, not bytes). For SPARC v9, we sign-extend the given operand using SLL; SRL. The generated instructions are returned in `mvec'. Any temp. registers (TmpInstruction) created are recorded in mcfi. Any stack space required is allocated via MachineFunction.

Definition at line 1288 of file SparcV9BurgISel.cpp.

void llvm::CreateCodeToCopyIntToFloat ( const TargetMachine target,
Function F,
Value val,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
)

CreateCodeToCopyIntToFloat - Create an instruction sequence to copy an integer register `val' to a floating point register `dest' by copying to memory and back. val must be an integral type. dest must be a Float or Double. The generated instructions are returned in `mvec'. Any temp. registers (TmpInstruction) created are recorded in mcfi. Any stack space required is allocated via MachineFunction.

Definition at line 1304 of file SparcV9BurgISel.cpp.

static TmpInstruction* llvm::InsertCodeToLoadConstant ( Function F,
Value opValue,
Instruction vmInstr,
std::vector< MachineInstr * > &  loadConstVec,
TargetMachine target 
) [static]

InsertCodeToLoadConstant - Generates code to load the constant into a TmpInstruction (virtual reg) and returns the virtual register.

Definition at line 1358 of file SparcV9BurgISel.cpp.

MachineOperand::MachineOperandType llvm::ChooseRegOrImmed ( int64_t  intValue,
bool  isSigned,
MachineOpCode  opCode,
const TargetMachine target,
bool  canUseImmed,
unsigned int &  getMachineRegNum,
int64_t &  getImmedValue 
)

Definition at line 1375 of file SparcV9BurgISel.cpp.

MachineOperand::MachineOperandType llvm::ChooseRegOrImmed ( Value val,
MachineOpCode  opCode,
const TargetMachine target,
bool  canUseImmed,
unsigned int &  getMachineRegNum,
int64_t &  getImmedValue 
)

Definition at line 1398 of file SparcV9BurgISel.cpp.

void llvm::CreateCopyInstructionsByType ( const TargetMachine target,
Function F,
Value src,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
)

CreateCopyInstructionsByType - Create instruction(s) to copy src to dest, for arbitrary types. The generated instructions are returned in `mvec'. Any temp. registers (TmpInstruction) created are recorded in mcfi. Any stack space required is allocated via MachineFunction.

Definition at line 1424 of file SparcV9BurgISel.cpp.

std::vector<MachineInstr*> llvm::FixConstantOperandsForInstr ( Instruction vmInstr,
MachineInstr minstr,
TargetMachine target 
)

FixConstantOperandsForInstr - Make a machine instruction use its constant operands more efficiently. If the constant is 0, then use the hardwired 0 register, if any. Else, if the constant fits in the IMMEDIATE field, then use that field. Otherwise, else create instructions to put the constant into a register, either directly or by loading explicitly from the constant pool. In the first 2 cases, the operand of `minstr' is modified in place. Returns a vector of machine instructions generated for operands that fall under case 3; these must be inserted before `minstr'.

Definition at line 1482 of file SparcV9BurgISel.cpp.

static void llvm::Add3OperandInstr ( unsigned  Opcode,
InstructionNode Node,
std::vector< MachineInstr * > &  mvec 
) [inline, static]

Definition at line 1617 of file SparcV9BurgISel.cpp.

static bool llvm::IsZero ( Value idx  )  [inline, static]

IsZero - Check for a constant 0.

Definition at line 1626 of file SparcV9BurgISel.cpp.

static Value* llvm::FoldGetElemChain ( InstrTreeNode ptrNode,
std::vector< Value * > &  chainIdxVec,
bool  lastInstHasLeadingNonZero 
) [static]

FoldGetElemChain - Fold a chain of GetElementPtr instructions containing only constant offsets into an equivalent (Pointer, IndexVector) pair. Returns the pointer Value, and stores the resulting IndexVector in argument chainIdxVec. This is a helper function for FoldConstantIndices that does the actual folding.

Definition at line 1638 of file SparcV9BurgISel.cpp.

static Value* llvm::GetGEPInstArgs ( InstructionNode gepNode,
std::vector< Value * > &  idxVec,
bool &  allConstantIndices 
) [static]

GetGEPInstArgs - Helper function for GetMemInstArgs that handles the final getElementPtr instruction used by (or same as) the memory operation. Extracts the indices of the current instruction and tries to fold in preceding ones if all indices of the current one are constant.

Definition at line 1720 of file SparcV9BurgISel.cpp.

static Value* llvm::GetMemInstArgs ( InstructionNode memInstrNode,
std::vector< Value * > &  idxVec,
bool &  allConstantIndices 
) [static]

GetMemInstArgs - Get the pointer value and the index vector for a memory operation (GetElementPtr, Load, or Store). If all indices of the given memory operation are constant, fold in constant indices in a chain of preceding GetElementPtr instructions (if any), and return the pointer value of the first instruction in the chain. All folded instructions are marked so no code is generated for them. Returns the pointer Value to use, and returns the resulting IndexVector in idxVec. Sets allConstantIndices to true/false if all indices are/aren't const.

Definition at line 1766 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseBprInstruction ( const InstructionNode instrNode  )  [inline, static]

Definition at line 1802 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseBpccInstruction ( const InstructionNode instrNode,
const BinaryOperator setCCInstr 
) [inline, static]

Definition at line 1825 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseBFpccInstruction ( const InstructionNode instrNode,
const BinaryOperator setCCInstr 
) [inline, static]

Definition at line 1861 of file SparcV9BurgISel.cpp.

static TmpInstruction* llvm::GetTmpForCC ( Value boolVal,
const Function F,
const Type ccType,
MachineCodeForInstruction mcfi 
) [static]

Definition at line 1888 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseBccInstruction ( const InstructionNode instrNode,
const Type *&  setCCType 
) [inline, static]

Definition at line 1912 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseMovFpcciInstruction ( const InstructionNode instrNode  )  [inline, static]

ChooseMovFpcciInstruction - WARNING: since this function has only one caller, it always returns the opcode that expects an immediate and a register. If this function is ever used in cases where an opcode that takes two registers is required, then modify this function and use convertOpcodeFromRegToImm() where required. It will be necessary to expand convertOpcodeFromRegToImm() to handle the new cases of opcodes.

Definition at line 1932 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseMovpcciForSetCC ( const InstructionNode instrNode  )  [static]

ChooseMovpcciForSetCC -- Choose a conditional-move instruction based on the type of SetCC operation.

WARNING: like the previous function, this function always returns the opcode that expects an immediate and a register. See above.

Definition at line 1956 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseMovpregiForSetCC ( const InstructionNode instrNode  )  [static]

ChooseMovpregiForSetCC -- Choose a conditional-move-on-register-value instruction based on the type of SetCC operation. These instructions compare a register with 0 and perform the move is the comparison is true.

WARNING: like the previous function, this function it always returns the opcode that expects an immediate and a register. See above.

Definition at line 1983 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseConvertToFloatInstr ( const TargetMachine target,
OpLabel  vopCode,
const Type opType 
) [inline, static]

Definition at line 2000 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseConvertFPToIntInstr ( const TargetMachine target,
const Type destType,
const Type opType 
) [inline, static]

Definition at line 2027 of file SparcV9BurgISel.cpp.

static MachineInstr* llvm::CreateConvertFPToIntInstr ( const TargetMachine target,
Value srcVal,
Value destVal,
const Type destType 
) [static]

Definition at line 2051 of file SparcV9BurgISel.cpp.

static void llvm::CreateCodeToConvertFloatToInt ( const TargetMachine target,
Value opVal,
Instruction destI,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
) [static]

CreateCodeToConvertFloatToInt: Convert FP value to signed or unsigned integer. The FP value must be converted to the dest type in an FP register, and the result is then copied from FP to int register via memory. SPARC does not have a float-to-uint conversion, only a float-to-int (fdtoi). Since fdtoi converts to signed integers, any FP value V between MAXINT+1 and MAXUNSIGNED (i.e., 2^31 <= V <= 2^32-1) would be converted incorrectly. Therefore, for converting an FP value to uint32_t, we first need to convert to uint64_t and then to uint32_t.

Definition at line 2069 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseAddInstruction ( const InstructionNode instrNode  )  [inline, static]

Definition at line 2113 of file SparcV9BurgISel.cpp.

static MachineInstr* llvm::CreateMovFloatInstruction ( const InstructionNode instrNode,
const Type resultType 
) [inline, static]

Definition at line 2118 of file SparcV9BurgISel.cpp.

static MachineInstr* llvm::CreateAddConstInstruction ( const InstructionNode instrNode  )  [inline, static]

Definition at line 2126 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseSubInstructionByType ( const Type resultType  )  [inline, static]

Definition at line 2145 of file SparcV9BurgISel.cpp.

static MachineInstr* llvm::CreateSubConstInstruction ( const InstructionNode instrNode  )  [inline, static]

Definition at line 2162 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseFcmpInstruction ( const InstructionNode instrNode  )  [inline, static]

Definition at line 2182 of file SparcV9BurgISel.cpp.

static bool llvm::BothFloatToDouble ( const InstructionNode instrNode  )  [inline, static]

BothFloatToDouble - Assumes that leftArg and rightArg of instrNode are both cast instructions. Returns true if both are floats cast to double.

Definition at line 2198 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseMulInstructionByType ( const Type resultType  )  [inline, static]

Definition at line 2209 of file SparcV9BurgISel.cpp.

static MachineInstr* llvm::CreateIntNegInstruction ( const TargetMachine target,
Value vreg 
) [inline, static]

Definition at line 2225 of file SparcV9BurgISel.cpp.

static MachineInstr* llvm::CreateIntNegInstruction ( const TargetMachine target,
Value vreg,
Value destreg 
) [inline, static]

Definition at line 2231 of file SparcV9BurgISel.cpp.

static void llvm::CreateShiftInstructions ( const TargetMachine target,
Function F,
MachineOpCode  shiftOpCode,
Value argVal1,
Value optArgVal2,
unsigned  optShiftNum,
Instruction destVal,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
) [inline, static]

CreateShiftInstructions - Create instruction sequence for any shift operation. SLL or SLLX on an operand smaller than the integer reg. size (64bits) requires a second instruction for explicit sign-extension. Note that we only have to worry about a sign-bit appearing in the most significant bit of the operand after shifting (e.g., bit 32 of Int or bit 16 of Short), so we do not have to worry about results that are as large as a normal integer register.

Definition at line 2245 of file SparcV9BurgISel.cpp.

static unsigned llvm::CreateMulConstInstruction ( const TargetMachine target,
Function F,
Value lval,
Value rval,
Instruction destVal,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
) [static]

CreateMulConstInstruction - Does not create any instructions if we cannot exploit constant to create a cheaper instruction. This returns the approximate cost of the instructions generated, which is used to pick the cheapest when both operands are constant.

Definition at line 2287 of file SparcV9BurgISel.cpp.

static void llvm::CreateCheapestMulConstInstruction ( const TargetMachine target,
Function F,
Value lval,
Value rval,
Instruction destVal,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi 
) [inline, static]

CreateCheapestMulConstInstruction - Does not create any instructions if we cannot exploit constant to create a cheaper instruction.

Definition at line 2381 of file SparcV9BurgISel.cpp.

static void llvm::CreateMulInstruction ( const TargetMachine target,
Function F,
Value lval,
Value rval,
Instruction destVal,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi,
MachineOpCode  forceMulOp = -1 
) [inline, static]

CreateMulInstruction - Returns NULL if we cannot exploit constant to create a cheaper instruction.

Definition at line 2407 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseDivInstruction ( TargetMachine target,
const InstructionNode instrNode 
) [inline, static]

ChooseDivInstruction - Generate a divide instruction for Div or Rem. For Rem, this assumes that the operand type will be signed if the result type is signed. This is correct because they must have the same sign.

Definition at line 2431 of file SparcV9BurgISel.cpp.

static void llvm::CreateDivConstInstruction ( TargetMachine target,
const InstructionNode instrNode,
std::vector< MachineInstr * > &  mvec 
) [static]

CreateDivConstInstruction - Return if we cannot exploit constant to create a cheaper instruction.

Definition at line 2451 of file SparcV9BurgISel.cpp.

static void llvm::CreateCodeForVariableSizeAlloca ( const TargetMachine target,
Instruction result,
unsigned  tsize,
Value numElementsVal,
std::vector< MachineInstr * > &  getMvec 
) [static]

Definition at line 2562 of file SparcV9BurgISel.cpp.

static void llvm::CreateCodeForFixedSizeAlloca ( const TargetMachine target,
Instruction result,
unsigned  tsize,
unsigned  numElements,
std::vector< MachineInstr * > &  getMvec 
) [static]

Definition at line 2634 of file SparcV9BurgISel.cpp.

static void llvm::SetOperandsForMemInstr ( unsigned  Opcode,
std::vector< MachineInstr * > &  mvec,
InstructionNode vmInstrNode,
const TargetMachine target 
) [static]

SetOperandsForMemInstr - Choose addressing mode for the given load or store instruction. Use [reg+reg] if it is an indexed reference, and the index offset is not a constant or if it cannot fit in the offset field. Use [reg+offset] in all other cases. This assumes that all array refs are "lowered" to one of these forms: x = load (subarray*) ptr, constant ; single constant offset x = load (subarray*) ptr, offsetVal ; single non-constant offset Generally, this should happen via strength reduction + LICM. Also, strength reduction should take care of using the same register for the loop index variable and an array index, when that is profitable.

Definition at line 2694 of file SparcV9BurgISel.cpp.

static void llvm::ForwardOperand ( InstructionNode treeNode,
InstrTreeNode parent,
int  operandNum 
) [static]

ForwardOperand - Substitute operand `operandNum' of the instruction in node `treeNode' in place of the use(s) of that instruction in node `parent'. Check both explicit and implicit operands! Also make sure to skip over a parent who: (1) is a list node in the Burg tree, or (2) itself had its results forwarded to its parent.

Definition at line 2801 of file SparcV9BurgISel.cpp.

bool llvm::AllUsesAreBranches ( const Instruction I  )  [inline]

AllUsesAreBranches - Returns true if all the uses of I are Branch instructions, false otherwise.

Definition at line 2847 of file SparcV9BurgISel.cpp.

static bool llvm::CodeGenIntrinsic ( Intrinsic::ID  iid,
CallInst callInstr,
TargetMachine target,
std::vector< MachineInstr * > &  mvec 
) [static]

CodeGenIntrinsic - Generate code for any intrinsic that needs a special code sequence instead of a regular call. If not that kind of intrinsic, do nothing. Returns true if code was generated, otherwise false.

Definition at line 2860 of file SparcV9BurgISel.cpp.

bool llvm::ThisIsAChainRule ( int  eruleno  ) 

ThisIsAChainRule - returns true if the given BURG rule is a chain rule.

Definition at line 2902 of file SparcV9BurgISel.cpp.

void llvm::GetInstructionsByRule ( InstructionNode subtreeRoot,
int  ruleForNode,
short *  nts,
TargetMachine target,
std::vector< MachineInstr * > &  mvec 
)

GetInstructionsByRule - Choose machine instructions for the SPARC V9 according to the patterns chosen by the BURG-generated parser. This is where most of the work in the V9 instruction selector gets done.

Definition at line 2937 of file SparcV9BurgISel.cpp.

FunctionPass * llvm::createSparcV9BurgInstSelector ( TargetMachine TM  ) 

createSparcV9BurgInstSelector - Creates and returns a new SparcV9 BURG-based instruction selection pass.

Definition at line 4613 of file SparcV9BurgISel.cpp.

FunctionPass* llvm::createStackSlotsPass ( const TargetMachine TM  ) 

createStackSlotsPass - External interface to stack-slots pass that enters 2 empty slots at the top of each function stack

Definition at line 49 of file SparcV9StackSlots.cpp.

References StackSlots, and Target.

FunctionPass* llvm::createPreSelectionPass ( const TargetMachine TM  ) 

createPreSelectionPass - Public entry point for the PreSelection pass

Definition at line 306 of file SparcV9PreSelection.cpp.

References TM.

FunctionPass * llvm::createPeepholeOptsPass ( const TargetMachine &  TM  ) 

Peephole optimization pass operating on machine code

Definition at line 159 of file SparcV9PeepholeOpts.cpp.

References TM.

FunctionPass * llvm::createPrologEpilogInsertionPass (  ) 

getPrologEpilogInsertionPass - Inserts prolog/epilog code.

Definition at line 180 of file SparcV9PrologEpilogInserter.cpp.

FunctionPass* llvm::createSparcV9MachineCodeDestructionPass (  ) 

Definition at line 692 of file SparcV9TargetMachine.cpp.

Referenced by llvm::SparcV9TargetMachine::addPassesToEmitMachineCode().

static void llvm::DeleteInstruction ( MachineBasicBlock &  mvec,
MachineBasicBlock::iterator BBI,
const TargetMachine &  target 
) [inline, static]

Definition at line 29 of file SparcV9PeepholeOpts.cpp.

References llvm::MachineBasicBlock::begin(), llvm::MachineBasicBlock::end(), llvm::MachineBasicBlock::erase(), llvm::TargetMachine::getInstrInfo(), prior(), and target.

Referenced by RemoveUselessCopies().

static bool llvm::IsUselessCopy ( const TargetMachine &  target,
const MachineInstr *  MI 
) [static]

Definition at line 64 of file SparcV9PeepholeOpts.cpp.

References llvm::MachineOperand::getImmedValue(), llvm::MachineInstr::getOpcode(), llvm::MachineInstr::getOperand(), llvm::MachineOperand::getReg(), llvm::TargetMachine::getRegInfo(), llvm::MachineOperand::getType(), llvm::SparcV9RegInfo::getZeroRegNum(), llvm::MachineOperand::hasAllocatedReg(), MI, llvm::MachineOperand::MO_SignExtendedImmed, and target.

Referenced by RemoveUselessCopies().

bool llvm::RemoveUselessCopies ( MachineBasicBlock &  mvec,
MachineBasicBlock::iterator BBI,
const TargetMachine &  target 
) [inline]

Definition at line 99 of file SparcV9PeepholeOpts.cpp.

References DeleteInstruction(), IsUselessCopy(), and target.

FunctionPass* llvm::createPreSelectionPass ( const TargetMachine TM  ) 

createPreSelectionPass - Public entry point for the PreSelection pass

Definition at line 306 of file SparcV9PreSelection.cpp.

References TM.

static unsigned llvm::getStaticStackSize ( MachineFunction &  MF  )  [static]

Definition at line 52 of file SparcV9PrologEpilogInserter.cpp.

References llvm::TargetMachine::getFrameInfo(), llvm::MachineFunction::getInfo(), llvm::MachineFunction::getTarget(), MF, llvm::SparcV9FrameInfo::MinStackFrameSize, and llvm::SparcV9FrameInfo::StackFrameSizeAlignment.

bool llvm::isVarArgsFunction ( const Type funcType  )  [inline]

Definition at line 155 of file SparcV9RegInfo.cpp.

Referenced by llvm::SparcV9RegInfo::colorMethodArgs(), isVarArgsCall(), and llvm::SparcV9RegInfo::suggestRegs4MethodArgs().

bool llvm::isVarArgsCall ( const MachineInstr *  CallMI  )  [inline]

Definition at line 161 of file SparcV9RegInfo.cpp.

References llvm::MachineInstr::getOperand(), llvm::Value::getType(), llvm::MachineOperand::getVRegValue(), and isVarArgsFunction().

FunctionPass* llvm::createStackSlotsPass ( const TargetMachine TM  ) 

createStackSlotsPass - External interface to stack-slots pass that enters 2 empty slots at the top of each function stack

Definition at line 49 of file SparcV9StackSlots.cpp.

References StackSlots, and Target.

FunctionPass* llvm::createSparcV9MachineCodeDestructionPass (  ) 

Definition at line 692 of file SparcV9TargetMachine.cpp.

Referenced by llvm::SparcV9TargetMachine::addPassesToEmitMachineCode().

FunctionPass* llvm::createX86ISelDag ( X86TargetMachine TM  ) 

createX86ISelDag - This pass converts a legalized DAG into a X86-specific DAG, ready for instruction scheduling.

Definition at line 848 of file X86ISelDAGToDAG.cpp.

References TM.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86FloatingPointStackifierPass (  ) 

createX86FloatingPointStackifierPass - This function returns a pass which converts floating point register references and pseudo instructions into floating point stack references and physical instructions.

Definition at line 155 of file X86FloatingPoint.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86CodePrinterPass ( std::ostream &  o,
X86TargetMachine tm 
)

createX86CodePrinterPass - Returns a pass that prints the X86 assembly code for a MachineFunction to the given output stream, using the given target machine description.

Definition at line 212 of file X86AsmPrinter.cpp.

References AsmWriterFlavor, and intel.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86CodeEmitterPass ( MachineCodeEmitter MCE  ) 

createX86CodeEmitterPass - Return a pass that emits the collected X86 code to the specified MCE object.

Definition at line 75 of file X86CodeEmitter.cpp.

References MCE.

Referenced by llvm::X86TargetMachine::addPassesToEmitMachineCode(), and addX86ELFObjectWriterPass().

void llvm::addX86ELFObjectWriterPass ( PassManager FPM,
std::ostream &  O,
X86TargetMachine TM 
)

addX86ELFObjectWriterPass - Returns a pass that outputs the generated code as an ELF object file.

Definition at line 33 of file X86ELFWriter.cpp.

References llvm::PassManager::add(), createX86CodeEmitterPass(), and TM.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createEmitX86CodeToMemory (  ) 

createX86EmitCodeToMemory - Returns a pass that converts a register allocated function into raw machine code in a dynamically allocated chunk of memory.

Statistic llvm::EmittedInsts ( "asm-printer"  ,
"Number of machine instrs printed"   
)

FunctionPass* llvm::createX86CodePrinterPass ( std::ostream &  o,
X86TargetMachine tm 
)

createX86CodePrinterPass - Returns a pass that prints the X86 assembly code for a MachineFunction to the given output stream, using the given target machine description.

Definition at line 212 of file X86AsmPrinter.cpp.

References AsmWriterFlavor, and intel.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86CodeEmitterPass ( MachineCodeEmitter MCE  ) 

createX86CodeEmitterPass - Return a pass that emits the collected X86 code to the specified MCE object.

Definition at line 75 of file X86CodeEmitter.cpp.

References MCE.

Referenced by llvm::X86TargetMachine::addPassesToEmitMachineCode(), and addX86ELFObjectWriterPass().

void llvm::addX86ELFObjectWriterPass ( PassManager FPM,
std::ostream &  O,
X86TargetMachine TM 
)

addX86ELFObjectWriterPass - Returns a pass that outputs the generated code as an ELF object file.

Definition at line 33 of file X86ELFWriter.cpp.

References llvm::PassManager::add(), createX86CodeEmitterPass(), and TM.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createX86FloatingPointStackifierPass (  ) 

createX86FloatingPointStackifierPass - This function returns a pass which converts floating point register references and pseudo instructions into floating point stack references and physical instructions.

Definition at line 155 of file X86FloatingPoint.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), and llvm::X86JITInfo::addPassesToJITCompile().

const MachineInstrBuilder& llvm::addDirectMem ( const MachineInstrBuilder &  MIB,
unsigned  Reg 
) [inline]

addDirectMem - This function is used to add a direct memory reference to the current instruction -- that is, a dereference of an address in a register, with no scale, index or displacement. An example is: DWORD PTR [EAX].

Definition at line 60 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addReg(), llvm::MachineInstrBuilder::addSImm(), and llvm::MachineInstrBuilder::addZImm().

const MachineInstrBuilder& llvm::addRegOffset ( const MachineInstrBuilder &  MIB,
unsigned  Reg,
int  Offset 
) [inline]

addRegOffset - This function is used to add a memory reference of the form [Reg + Offset], i.e., one with no scale or index, but with a displacement. An example is: DWORD PTR [EAX + 4].

Definition at line 72 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addReg(), llvm::MachineInstrBuilder::addSImm(), and llvm::MachineInstrBuilder::addZImm().

Referenced by llvm::X86InstrInfo::convertToThreeAddress(), and llvm::X86RegisterInfo::emitPrologue().

const MachineInstrBuilder& llvm::addRegReg ( const MachineInstrBuilder &  MIB,
unsigned  Reg1,
unsigned  Reg2 
) [inline]

addRegReg - This function is used to add a memory reference of the form: [Reg + Reg].

Definition at line 79 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addReg(), llvm::MachineInstrBuilder::addSImm(), and llvm::MachineInstrBuilder::addZImm().

Referenced by llvm::X86InstrInfo::convertToThreeAddress().

const MachineInstrBuilder& llvm::addFullAddress ( const MachineInstrBuilder &  MIB,
const X86AddressMode &  AM 
) [inline]

Definition at line 84 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addFrameIndex(), llvm::MachineInstrBuilder::addGlobalAddress(), llvm::MachineInstrBuilder::addReg(), llvm::MachineInstrBuilder::addSImm(), llvm::MachineInstrBuilder::addZImm(), llvm::X86AddressMode::Base, llvm::X86AddressMode::BaseType, llvm::X86AddressMode::Disp, llvm::X86AddressMode::FrameIndex, llvm::X86AddressMode::FrameIndexBase, llvm::X86AddressMode::GV, llvm::X86AddressMode::IndexReg, llvm::X86AddressMode::Reg, llvm::X86AddressMode::RegBase, and llvm::X86AddressMode::Scale.

Referenced by llvm::X86InstrInfo::convertToThreeAddress(), and llvm::X86TargetLowering::InsertAtEndOfBasicBlock().

const MachineInstrBuilder& llvm::addFrameReference ( const MachineInstrBuilder &  MIB,
int  FI,
int  Offset = 0 
) [inline]

addFrameReference - This function is used to add a reference to the base of an abstract object on the stack frame of the current function. This reference has base register as the FrameIndex offset until it is resolved. This allows a constant offset to be specified as well...

Definition at line 107 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addFrameIndex(), llvm::MachineInstrBuilder::addReg(), llvm::MachineInstrBuilder::addSImm(), llvm::MachineInstrBuilder::addZImm(), and Offset.

FunctionPass* llvm::createX86ISelDag ( X86TargetMachine TM  ) 

createX86ISelDag - This pass converts a legalized DAG into a X86-specific DAG, ready for instruction scheduling.

Definition at line 848 of file X86ISelDAGToDAG.cpp.

References TM.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), and llvm::X86JITInfo::addPassesToJITCompile().

bool llvm::ExpressionConvertibleToType ( Value V,
const Type Ty,
ValueTypeCache CTMap,
const TargetData TD 
)

Definition at line 34 of file ExprTypeConvert.cpp.

References BaseType, llvm::Instruction::Call, llvm::Instruction::Cast, E, llvm::FunctionType::get(), llvm::PointerType::get(), llvm::SequentialType::getElementType(), llvm::PHINode::getIncomingValue(), llvm::GetElementPtrInst::getIndexedType(), llvm::Constant::getNullValue(), llvm::PHINode::getNumIncomingValues(), llvm::User::getNumOperands(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::GetElementPtrInst::getPointerOperand(), llvm::GetElementPtrInst::getType(), llvm::Value::getType(), llvm::TargetData::getTypeSize(), I, llvm::GetElementPtrInst::idx_begin(), llvm::GetElementPtrInst::idx_end(), llvm::Type::isFirstClassType(), llvm::Type::isFloatingPoint(), llvm::Type::isInteger(), llvm::Type::isLosslesslyConvertibleTo(), llvm::Type::isSigned(), LI, llvm::Instruction::Load, OperandConvertibleToType(), llvm::Instruction::PHI, llvm::Instruction::Shl, TD, Ty, llvm::Value::use_begin(), llvm::Value::use_end(), and V.

Referenced by OperandConvertibleToType().

Value * llvm::ConvertExpressionToType ( Value V,
const Type Ty,
ValueMapCache VMC,
const TargetData TD 
)

Definition at line 192 of file ExprTypeConvert.cpp.

References BaseType, BB, llvm::Instruction::Call, llvm::Instruction::Cast, ConvertOperandToType(), llvm::BinaryOperator::create(), DEBUG, llvm::ValueMapCache::ExprMap, llvm::FunctionType::get(), llvm::PointerType::get(), llvm::ConstantExpr::getCast(), llvm::SequentialType::getElementType(), llvm::PHINode::getIncomingBlock(), llvm::PHINode::getIncomingValue(), llvm::GetElementPtrInst::getIndexedType(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::Constant::getNullValue(), llvm::User::getNumOperands(), llvm::Value::getNumUses(), llvm::Instruction::getOpcode(), llvm::Constant::getOperand(), llvm::User::getOperand(), llvm::Instruction::getParent(), llvm::GetElementPtrInst::getPointerOperand(), llvm::Value::getType(), llvm::GlobalValue::getType(), GV, I, llvm::GetElementPtrInst::idx_begin(), llvm::GetElementPtrInst::idx_end(), LI, llvm::Instruction::Load, Name, llvm::ValueMapCache::NewCasts, llvm::Instruction::PHI, llvm::PHINode::removeIncomingValue(), llvm::Value::setName(), llvm::User::setOperand(), llvm::Instruction::Shl, TD, Ty, llvm::Value::use_begin(), V, and llvm::Type::VoidTy.

Referenced by ConvertOperandToType().

bool llvm::ValueConvertibleToType ( Value V,
const Type Ty,
ValueTypeCache ConvertedTypes,
const TargetData TD 
)

Definition at line 395 of file ExprTypeConvert.cpp.

References E, I, OperandConvertibleToType(), TD, Ty, and V.

Referenced by OperandConvertibleToType().

void llvm::ConvertValueToNewType ( Value V,
Value NewVal,
ValueMapCache VMC,
const TargetData TD 
)

Definition at line 673 of file ExprTypeConvert.cpp.

References ConvertOperandToType(), TD, and V.

Referenced by ConvertOperandToType().

ModulePass* llvm::createFunctionProfilerPass (  ) 

Definition at line 44 of file BlockProfiling.cpp.

ModulePass* llvm::createBlockProfilerPass (  ) 

Definition at line 89 of file BlockProfiling.cpp.

ModulePass* llvm::createEdgeProfilerPass (  ) 

Definition at line 40 of file EdgeProfiling.cpp.

static char llvm::doDFS ( BasicBlock node,
std::map< BasicBlock *, Color > &  color 
) [static]

Definition at line 47 of file EmitFunctions.cpp.

References BB, BLACK, GREY, succ_begin(), and succ_end().

Referenced by hasBackEdge().

static char llvm::hasBackEdge ( Function F  )  [static]

Definition at line 70 of file EmitFunctions.cpp.

References doDFS(), and F.

void llvm::InsertProfilingInitCall ( Function *  MainFn,
const char *  FnName,
GlobalValue *  Array = 0 
)

Definition at line 23 of file ProfilingUtils.cpp.

References AI, llvm::Function::arg_begin(), llvm::Function::arg_size(), llvm::BasicBlock::begin(), llvm::Function::begin(), llvm::ConstantUInt::get(), llvm::ConstantPointerNull::get(), llvm::PointerType::get(), llvm::SequentialType::getElementType(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), llvm::Module::getOrInsertFunction(), llvm::GlobalValue::getParent(), llvm::Value::getType(), llvm::GlobalValue::getType(), InsertPos, llvm::Type::IntTy, M, llvm::Type::SByteTy, llvm::User::setOperand(), and llvm::Type::UIntTy.

void llvm::IncrementCounterInBlock ( BasicBlock *  BB,
unsigned  CounterNum,
GlobalValue *  CounterArray 
)

Definition at line 89 of file ProfilingUtils.cpp.

References BB, llvm::BasicBlock::begin(), llvm::BinaryOperator::create(), llvm::ConstantInt::get(), llvm::ConstantSInt::get(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), InsertPos, llvm::Type::IntTy, and llvm::Type::UIntTy.

ModulePass* llvm::createNullProfilerRSPass (  ) 

Definition at line 637 of file RSProfiling.cpp.

FunctionPass* llvm::createRSProfilingPass (  ) 

Definition at line 641 of file RSProfiling.cpp.

ModulePass* llvm::createTraceBasicBlockPass (  ) 

Definition at line 38 of file TraceBasicBlocks.cpp.

FunctionPass* llvm::createTraceValuesPassForFunction (  ) 

Just trace functions.

Definition at line 112 of file TraceValues.cpp.

FunctionPass* llvm::createTraceValuesPassForBasicBlocks (  ) 

Trace BB's and functions.

Definition at line 117 of file TraceValues.cpp.

ModulePass* llvm::createArgumentPromotionPass (  ) 

createArgumentPromotionPass - This pass promotes "by reference" arguments to be passed by value.

Definition at line 79 of file ArgumentPromotion.cpp.

ModulePass* llvm::createConstantMergePass (  ) 

createConstantMergePass - This function returns a new pass that merges duplicate global constants together into a single constant that is shared. This is useful because some passes (ie TraceValues) insert a lot of string constants into the program, regardless of whether or not they duplicate an existing string.

Definition at line 39 of file ConstantMerge.cpp.

ModulePass* llvm::createDeadArgEliminationPass (  ) 

createDeadArgEliminationPass - This pass removes arguments from functions which are not used by the body of the function.

Definition at line 111 of file DeadArgumentElimination.cpp.

ModulePass* llvm::createDeadArgHackingPass (  ) 

DeadArgHacking pass - Same as DAE, but delete arguments of external functions as well. This is definitely not safe, and should only be used by bugpoint.

Definition at line 112 of file DeadArgumentElimination.cpp.

ModulePass* llvm::createDeadTypeEliminationPass (  ) 

createDeadTypeEliminationPass - Return a new pass that eliminates symbol table entries for types that are never used.

Definition at line 44 of file DeadTypeElimination.cpp.

ModulePass* llvm::createFunctionExtractionPass ( Function F,
bool  deleteFn = false 
)

createFunctionExtractionPass - If deleteFn is true, this pass deletes as the specified function. Otherwise, it deletes as much of the module as possible, except for the function specified.

Definition at line 115 of file ExtractFunction.cpp.

References F.

ModulePass* llvm::createFunctionResolvingPass (  ) 

FunctionResolvingPass - Go over the functions that are in the module and look for functions that have the same name. More often than not, there will be things like: void "foo"(...) void "foo"(int, int) because of the way things are declared in C. If this is the case, patch things up.

This is an interprocedural pass.

Definition at line 49 of file FunctionResolution.cpp.

ModulePass* llvm::createGlobalDCEPass (  ) 

createGlobalDCEPass - This transform is designed to eliminate unreachable internal globals (functions or global variables)

Definition at line 50 of file GlobalDCE.cpp.

ModulePass* llvm::createGlobalOptimizerPass (  ) 

createGlobalOptimizerPass - This function returns a new pass that optimizes non-address taken internal globals.

Definition at line 69 of file GlobalOpt.cpp.

ModulePass* llvm::createIndMemRemPass (  ) 

Definition at line 90 of file IndMemRemoval.cpp.

ModulePass* llvm::createFunctionInliningPass (  ) 

createFunctionInliningPass - Return a new pass object that uses a heuristic to inline direct function calls to small functions.

Definition at line 61 of file InlineSimple.cpp.

ModulePass* llvm::createInternalizePass ( bool  InternalizeEverything  ) 

createInternalizePass - This pass loops over all of the functions in the input module, looking for a main function. If a list of symbols is specified with the -internalize-public-api-* command line options, those symbols are internalized. Otherwise if InternalizeEverything is set and the main function is found, all other globals are marked as internal.

Definition at line 151 of file Internalize.cpp.

ModulePass* llvm::createIPConstantPropagationPass (  ) 

createIPConstantPropagationPass - This pass propagates constants from call sites into the bodies of functions.

Definition at line 44 of file IPConstantPropagation.cpp.

FunctionPass* llvm::createLoopExtractorPass (  ) 

createLoopExtractorPass - This pass extracts all natural loops from the program into a function if it can.

Definition at line 64 of file LoopExtractor.cpp.

FunctionPass* llvm::createSingleLoopExtractorPass (  ) 

createSingleLoopExtractorPass - This pass extracts one natural loop from the program into a function if it can. This is used by bugpoint.

Definition at line 134 of file LoopExtractor.cpp.

ModulePass* llvm::createBlockExtractorPass ( std::vector< BasicBlock * > &  BTNE  ) 

Definition at line 158 of file LoopExtractor.cpp.

ModulePass* llvm::createLowerSetJmpPass (  ) 

createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics to invoke/unwind instructions. This should really be part of the C/C++ front-end, but it's so much easier to write transformations in LLVM proper.

Definition at line 534 of file LowerSetJmp.cpp.

ModulePass* llvm::createPruneEHPass (  ) 

createPruneEHPass - Return a new pass object which transforms invoke instructions into calls, if the callee can _not_ unwind the stack.

Definition at line 52 of file PruneEH.cpp.

ModulePass* llvm::createRaiseAllocationsPass (  ) 

createRaiseAllocationsPass - Return a new pass that transforms malloc and free function calls into malloc and free instructions.

Definition at line 53 of file RaiseAllocations.cpp.

ModulePass* llvm::createSimplifyLibCallsPass (  ) 

Definition at line 345 of file SimplifyLibCalls.cpp.

ModulePass* llvm::createStripSymbolsPass ( bool  OnlyDebugInfo  ) 

Definition at line 49 of file StripSymbols.cpp.

FunctionPass* llvm::createRaisePointerReferencesPass (  ) 

Definition at line 87 of file LevelRaise.cpp.

FunctionPass* llvm::createAggressiveDCEPass (  ) 

Definition at line 110 of file ADCE.cpp.

FunctionPass* llvm::createBlockPlacementPass (  ) 

Definition at line 75 of file BasicBlockPlacement.cpp.

FunctionPass* llvm::createCondPropagationPass (  ) 

Definition at line 52 of file CondPropagate.cpp.

FunctionPass* llvm::createConstantPropagationPass (  ) 

Definition at line 45 of file ConstantProp.cpp.

FunctionPass* llvm::createCorrelatedExpressionEliminationPass (  ) 

Definition at line 292 of file CorrelatedExprs.cpp.

FunctionPass* llvm::createDeadInstEliminationPass (  ) 

Definition at line 56 of file DCE.cpp.

FunctionPass* llvm::createDeadCodeEliminationPass (  ) 

Definition at line 120 of file DCE.cpp.

FunctionPass* llvm::createDeadStoreEliminationPass (  ) 

Definition at line 60 of file DeadStoreElimination.cpp.

FunctionPass* llvm::createGCSEPass (  ) 

Definition at line 58 of file GCSE.cpp.

FunctionPass* llvm::createIndVarSimplifyPass (  ) 

Definition at line 97 of file IndVarSimplify.cpp.

FunctionPass* llvm::createInstructionCombiningPass (  ) 

Definition at line 7193 of file InstructionCombining.cpp.

FunctionPass* llvm::createLICMPass (  ) 

Definition at line 203 of file LICM.cpp.

FunctionPass* llvm::createLoopStrengthReducePass ( const TargetLowering TLI  ) 

Definition at line 200 of file LoopStrengthReduce.cpp.

References TLI.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLoopUnrollPass (  ) 

Definition at line 63 of file LoopUnroll.cpp.

FunctionPass* llvm::createLoopUnswitchPass (  ) 

Definition at line 107 of file LoopUnswitch.cpp.

FunctionPass* llvm::createLowerAllocationsPass ( bool  LowerMallocArgToInteger  ) 

Definition at line 64 of file LowerAllocations.cpp.

Referenced by llvm::CTargetMachine::addPassesToEmitFile().

FunctionPass* llvm::createLowerGCPass (  ) 

createLowerGCPass - This function returns an instance of the "lowergc" pass, which lowers garbage collection intrinsics to normal LLVM code.

Definition at line 64 of file LowerGC.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::CTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLowerInvokePass ( unsigned  JumpBufSize,
unsigned  JumpBufAlign 
)

Definition at line 95 of file LowerInvoke.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::CTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLowerPackedPass (  ) 

Definition at line 111 of file LowerPacked.cpp.

FunctionPass* llvm::createLowerSelectPass ( bool  OnlyFP  ) 

Definition at line 55 of file LowerSelect.cpp.

FunctionPass* llvm::createLowerSwitchPass (  ) 

Definition at line 64 of file LowerSwitch.cpp.

FunctionPass* llvm::createPromoteMemoryToRegisterPass (  ) 

Definition at line 79 of file Mem2Reg.cpp.

FunctionPass* llvm::createReassociatePass (  ) 

Definition at line 97 of file Reassociate.cpp.

FunctionPass* llvm::createDemoteRegisterToMemoryPass (  ) 

Definition at line 85 of file Reg2Mem.cpp.

FunctionPass* llvm::createScalarReplAggregatesPass (  ) 

Definition at line 76 of file ScalarReplAggregates.cpp.

FunctionPass* llvm::createSCCPPass (  ) 

Definition at line 1083 of file SCCP.cpp.

ModulePass* llvm::createIPSCCPPass (  ) 

createIPSCCPPass - This pass propagates constants from call sites into the bodies of functions, and keeps track of whether basic blocks are executable in the process.

Definition at line 1191 of file SCCP.cpp.

FunctionPass* llvm::createCFGSimplificationPass (  ) 

Definition at line 42 of file Scalar/SimplifyCFG.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::CTargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), and llvm::PPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createTailDuplicationPass (  ) 

Definition at line 54 of file TailDuplication.cpp.

FunctionPass* llvm::createTailCallEliminationPass (  ) 

Definition at line 82 of file TailRecursionElimination.cpp.

const Type * llvm::getStructOffsetType ( const Type Ty,
unsigned &  Offset,
std::vector< Value * > &  Indices,
const TargetData TD,
bool  StopEarly = true 
)

Definition at line 54 of file TransformInternals.cpp.

References llvm::ConstantSInt::get(), getStructOffsetStep(), llvm::TargetData::getTypeSize(), llvm::Type::IntTy, llvm::ConstantSInt::isValueValidForType(), llvm::Type::LongTy, TD, and Ty.

Referenced by ConvertOperandToType(), and OperandConvertibleToType().

static int64_t llvm::getConstantValue ( const ConstantInt *  CPI  )  [inline, static]

Definition at line 27 of file TransformInternals.h.

static const CompositeType* llvm::getPointedToComposite ( const Type Ty  )  [inline, static]

Definition at line 35 of file TransformInternals.h.

References llvm::SequentialType::getElementType(), and Ty.

void llvm::ReplaceInstWithValue ( BasicBlock::InstListType &  BIL,
BasicBlock::iterator BI,
Value V 
)

ReplaceInstWithValue - Replace all uses of an instruction (specified by BI) with a value, then remove and delete the original instruction.

Definition at line 26 of file BasicBlockUtils.cpp.

References llvm::Value::getName(), I, llvm::Value::replaceAllUsesWith(), and V.

Referenced by ReplaceInstWithInst().

void llvm::ReplaceInstWithInst ( BasicBlock::InstListType &  BIL,
BasicBlock::iterator BI,
Instruction I 
)

ReplaceInstWithInst - Replace the instruction specified by BI with the instruction specified by I. The original instruction is deleted and BI is updated to point to the new instruction.

Definition at line 47 of file BasicBlockUtils.cpp.

References llvm::Instruction::getParent(), and ReplaceInstWithValue().

void llvm::ReplaceInstWithInst ( Instruction From,
Instruction To 
)

ReplaceInstWithInst - Replace the instruction specified by From with the instruction specified by To.

Definition at line 65 of file BasicBlockUtils.cpp.

References llvm::BasicBlock::getInstList(), llvm::Instruction::getParent(), and ReplaceInstWithInst().

void llvm::RemoveSuccessor ( TerminatorInst TI,
unsigned  SuccNum 
)

RemoveSuccessor - Change the specified terminator instruction such that its successor SuccNum no longer exists. Because this reduces the outgoing degree of the current basic block, the actual terminator instruction itself may have to be changed. In the case where the last successor of the block is deleted, a return instruction is inserted in its place which can cause a surprising change in program behavior if it is not expected.

Definition at line 77 of file BasicBlockUtils.cpp.

References abort(), BB, llvm::Constant::getNullValue(), llvm::TerminatorInst::getNumSuccessors(), llvm::Instruction::getOpcode(), llvm::Instruction::getParent(), llvm::TerminatorInst::getSuccessor(), llvm::BasicBlock::removePredecessor(), ReplaceInstWithInst(), and llvm::Type::VoidTy.

FunctionPass* llvm::createBreakCriticalEdgesPass (  ) 

Definition at line 55 of file BreakCriticalEdges.cpp.

bool llvm::isCriticalEdge ( const TerminatorInst TI,
unsigned  SuccNum 
)

isCriticalEdge - Return true if the specified edge is a critical edge. Critical edges are edges from a block with multiple successors to a block with multiple predecessors.

Definition at line 85 of file BreakCriticalEdges.cpp.

References Dest, E, llvm::TerminatorInst::getNumSuccessors(), llvm::TerminatorInst::getSuccessor(), I, pred_begin(), and pred_end().

Referenced by SplitCriticalEdge().

bool llvm::SplitCriticalEdge ( TerminatorInst TI,
unsigned  SuccNum,
Pass P = 0 
)

SplitCriticalEdge - If this edge is a critical edge, insert a new node to split the critical edge. This will update DominatorSet, ImmediateDominator, DominatorTree, and DominatorFrontier information if it is available, thus calling this pass will not invalidate either of them. This returns true if the edge was split, false otherwise.

Definition at line 104 of file BreakCriticalEdges.cpp.

References llvm::DominatorSetBase::addBasicBlock(), llvm::ETForestBase::addNewBlock(), llvm::ISD::BasicBlock, llvm::BasicBlock::begin(), llvm::DominatorTreeBase::createNewNode(), llvm::X86II::DF, DS, DT, EF, F, llvm::Pass::getAnalysisToUpdate(), llvm::DominatorSetBase::getDominators(), llvm::LoopInfo::getLoopFor(), llvm::Value::getName(), llvm::BasicBlock::getNext(), llvm::DominatorTreeBase::getNode(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::TerminatorInst::getSuccessor(), I, isCriticalEdge(), LI, Node, and llvm::TerminatorInst::setSuccessor().

Referenced by IVUseShouldUsePostIncValue(), llvm::SelectionDAGISel::runOnFunction(), and SplitCriticalEdge().

BasicBlock* llvm::CloneBasicBlock ( const BasicBlock BB,
std::map< const Value *, Value * > &  ValueMap,
const char *  NameSuffix = "",
Function F = 0,
ClonedCodeInfo CodeInfo = 0 
)

CloneBasicBlock - Return a copy of the specified basic block, but without embedding the block into a particular function. The block returned is an exact copy of the specified basic block, without any remapping having been performed. Because of this, this is only suitable for applications where the basic block will be inserted into the same function that it was cloned from (loop unrolling would use this, for example).

Also, note that this function makes a direct copy of the basic block, and can thus produce illegal LLVM code. In particular, it will copy any PHI nodes from the original block, even though there are no predecessors for the newly cloned block (thus, phi nodes will have to be updated). Also, this block will branch to the old successors of the original block: these successors will have to have any PHI nodes updated to account for the new incoming edges.

The correlation between instructions in the source and result basic blocks is recorded in the ValueMap map.

If you have a particular suffix you'd like to use to add to any cloned names, specify it as the optional third parameter.

If you would like the basic block to be auto-inserted into the end of a function, you can specify it as the optional fourth parameter.

If you would like to collect additional information about the cloned function, you can specify a ClonedCodeInfo object with the optional fifth parameter.

Definition at line 25 of file CloneFunction.cpp.

References AI, llvm::ISD::BasicBlock, BB, llvm::BasicBlock::begin(), llvm::ClonedCodeInfo::ContainsCalls, llvm::ClonedCodeInfo::ContainsDynamicAllocas, llvm::ClonedCodeInfo::ContainsUnwinds, llvm::BasicBlock::end(), F, llvm::Function::front(), llvm::AllocationInst::getArraySize(), llvm::BasicBlock::getInstList(), llvm::TargetInstrInfo::getName(), llvm::Value::getName(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getTerminator(), llvm::Value::hasName(), II, and llvm::Value::setName().

Referenced by CloneFunctionInto(), CloneTrace(), and CloneTraceInto().

void llvm::CloneFunctionInto ( Function NewFunc,
const Function OldFunc,
std::map< const Value *, Value * > &  ValueMap,
std::vector< ReturnInst * > &  Returns,
const char *  NameSuffix = "",
ClonedCodeInfo CodeInfo = 0 
)

Clone OldFunc into NewFunc, transforming the old arguments into references to ArgMap values. Note that if NewFunc already has basic blocks, the ones cloned into it will be added to the end of the function. This function fills in a list of return instructions, and can optionally append the specified suffix to all values cloned.

Definition at line 65 of file CloneFunction.cpp.

References llvm::Function::arg_begin(), llvm::Function::arg_end(), BB, llvm::BasicBlock::begin(), llvm::Function::begin(), CloneBasicBlock(), E, llvm::BasicBlock::end(), llvm::Function::end(), llvm::BasicBlock::getTerminator(), I, II, and RemapInstruction().

Referenced by CloneFunction(), CloneModule(), and InlineFunction().

Function* llvm::CloneFunction ( const Function F,
std::map< const Value *, Value * > &  ValueMap,
ClonedCodeInfo CodeInfo 
)

CloneFunction - Return a copy of the specified function, but without embedding the function into another module. Also, any references specified in the ValueMap are changed to refer to their mapped value instead of the original one. If any of the arguments to the function are in the ValueMap, the arguments are deleted from the resultant function. The ValueMap is updated to include mappings from all of the instructions and basicblocks in the function from their old to new values.

Definition at line 112 of file CloneFunction.cpp.

References CloneFunctionInto(), E, F, llvm::FunctionType::get(), and I.

Referenced by CloneFunction().

Module* llvm::CloneModule ( const Module M  ) 

CloneModule - Return an exact copy of the specified module. This is not as easy as it might seem because we have to worry about making copies of global variables and functions, and making their (initializers and references, respectively) refer to the right globals.

Definition at line 28 of file CloneModule.cpp.

References llvm::Module::addLibrary(), llvm::Module::addTypeName(), llvm::Module::begin(), CloneFunctionInto(), E, llvm::Module::end(), llvm::GlobalValue::ExternalLinkage, F, llvm::Module::getEndianness(), llvm::Module::getModuleIdentifier(), llvm::Module::getModuleInlineAsm(), llvm::Module::getPointerSize(), llvm::Module::getSymbolTable(), llvm::Module::getTargetTriple(), llvm::Module::global_begin(), llvm::Module::global_end(), GV, I, llvm::Module::lib_begin(), llvm::Module::lib_end(), M, MapValue(), llvm::Module::setEndianness(), llvm::GlobalValue::setLinkage(), llvm::Module::setModuleInlineAsm(), llvm::Module::setPointerSize(), llvm::Module::setTargetTriple(), llvm::SymbolTable::type_begin(), llvm::SymbolTable::type_end(), and ValueMap.

std::vector<BasicBlock *> llvm::CloneTrace ( const std::vector< BasicBlock * > &  origTrace  ) 

CloneTrace - Returns a copy of the specified trace. It takes a vector of basic blocks clones the basic blocks, removes internal phi nodes, adds it to the same function as the original (although there is no jump to it) and returns the new vector of basic blocks.

Definition at line 27 of file CloneTrace.cpp.

References BB, llvm::BasicBlock::begin(), CloneBasicBlock(), E, I, Op, T, V, and ValueMap.

void llvm::CloneTraceInto ( Function NewFunc,
Trace T,
std::map< const Value *, Value * > &  ValueMap,
const char *  NameSuffix 
)

CloneTraceInto - Clone T into NewFunc. Original<->clone mapping is saved in ValueMap.

Definition at line 94 of file CloneTrace.cpp.

References BB, llvm::BasicBlock::begin(), CloneBasicBlock(), llvm::BasicBlock::end(), llvm::Function::end(), II, RemapInstruction(), and T.

Function* llvm::ExtractCodeRegion ( DominatorSet DS,
const std::vector< BasicBlock * > &  code,
bool  AggregateArgs 
)

ExtractCodeRegion - slurp a sequence of basic blocks into a brand new function

Definition at line 731 of file CodeExtractor.cpp.

References DS.

Function* llvm::ExtractLoop ( DominatorSet DS,
Loop L,
bool  AggregateArgs 
)

ExtractBasicBlock - slurp a natural loop into a brand new function

Definition at line 739 of file CodeExtractor.cpp.

References DS, and llvm::Loop::getBlocks().

Function* llvm::ExtractBasicBlock ( BasicBlock BB,
bool  AggregateArgs 
)

ExtractBasicBlock - slurp a basic block into a brand new function

Definition at line 745 of file CodeExtractor.cpp.

References BB, and Blocks.

AllocaInst* llvm::DemoteRegToStack ( Instruction I,
bool  VolatileLoads 
)

DemoteRegToStack - This function takes a virtual register computed by an Instruction and replaces it with a slot in the stack frame, allocated via alloca. This allows the CFG to be changed around without fear of invalidating the SSA information for the value. It returns the pointer to the alloca inserted to create a stack slot for I.

Definition at line 32 of file DemoteRegToStack.cpp.

References F, llvm::Value::getName(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::Value::getType(), II, Slot, U, llvm::Value::use_back(), llvm::Value::use_empty(), and V.

bool llvm::InlineFunction ( CallInst C,
CallGraph CG = 0 
)

InlineFunction - This function inlines the called function into the basic block of the caller. This returns false if it is not possible to inline this call. The program is still in a well defined state if this occurs though.

Note that this only does one level of inlining. For example, if the instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now exists in the instruction stream. Similiarly this will inline a recursive function by one level.

If a non-null callgraph pointer is provided, these functions update the CallGraph to represent the program after inlining.

Definition at line 25 of file InlineFunction.cpp.

References InlineFunction().

bool llvm::InlineFunction ( InvokeInst II,
CallGraph CG 
)

Definition at line 28 of file InlineFunction.cpp.

References II, and InlineFunction().

bool llvm::InlineFunction ( CallSite  CS,
CallGraph CG 
)

Definition at line 167 of file InlineFunction.cpp.

References llvm::CallGraphNode::addCalledFunction(), AI, llvm::CallSite::arg_begin(), llvm::CallSite::arg_end(), llvm::Function::back(), BB, llvm::BasicBlock::begin(), llvm::Function::begin(), CloneFunctionInto(), llvm::ClonedCodeInfo::ContainsCalls, llvm::ClonedCodeInfo::ContainsDynamicAllocas, llvm::ClonedCodeInfo::ContainsUnwinds, E, llvm::BasicBlock::end(), llvm::Function::end(), llvm::BasicBlock::eraseFromParent(), llvm::Function::front(), llvm::UndefValue::get(), llvm::PointerType::get(), llvm::AllocationInst::getArraySize(), llvm::Function::getBasicBlockList(), llvm::CallSite::getCalledFunction(), llvm::BasicBlock::getInstList(), llvm::CallSite::getInstruction(), llvm::Value::getName(), llvm::Instruction::getOpcode(), llvm::CallGraph::getOrInsertFunction(), llvm::Module::getOrInsertFunction(), llvm::GlobalValue::getParent(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::BasicBlock::getTerminator(), HandleInlinedInvoke(), I, II, M, PHI, llvm::Value::replaceAllUsesWith(), llvm::Type::SByteTy, llvm::User::setOperand(), llvm::Function::size(), llvm::BasicBlock::splitBasicBlock(), UpdateCallGraphAfterInlining(), ValueMap, and llvm::Type::VoidTy.

bool llvm::doConstantPropagation ( BasicBlock::iterator II  ) 

doConstantPropagation - If an instruction references constants, try to fold them together...

Definition at line 34 of file Transforms/Utils/Local.cpp.

References llvm::CallingConv::C, and ConstantFoldInstruction().

Constant* llvm::ConstantFoldInstruction ( Instruction I  ) 

ConstantFoldInstruction - Attempt to constant fold the specified instruction. If successful, the constant result is returned, if not, null is returned. Note that this function can only fail when attempting to fold instructions like loads and stores, which have no constant expression form.

Definition at line 52 of file Transforms/Utils/Local.cpp.

References llvm::CallingConv::C, canConstantFoldCallTo(), llvm::Instruction::Cast, ConstantFoldCall(), llvm::Instruction::ExtractElement, F, llvm::ConstantExpr::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getExtractElement(), llvm::ConstantExpr::getGetElementPtr(), llvm::ConstantExpr::getInsertElement(), llvm::Constant::getNullValue(), llvm::ConstantExpr::getSelect(), llvm::ConstantExpr::getShuffleVector(), llvm::Value::getType(), llvm::Instruction::InsertElement, Op, llvm::Instruction::Select, and llvm::Instruction::ShuffleVector.

Referenced by CleanupConstantGlobalUsers(), ConstantPropUsersOf(), doConstantPropagation(), and FoldCondBranchOnPHI().

bool llvm::ConstantFoldTerminator ( BasicBlock BB  ) 

ConstantFoldTerminator - If a terminator instruction is predicated on a constant value, convert it into an unconditional branch to the constant destination. This is a nontrivial operation because the successors of this basic block must have their PHI nodes updated.

Definition at line 132 of file Transforms/Utils/Local.cpp.

References BB, llvm::BasicBlock::getInstList(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getTerminator(), llvm::BasicBlock::removePredecessor(), and T.

Referenced by MarkAliveBlocks(), and SimplifyCFG().

Constant* llvm::ConstantFoldLoadThroughGEPConstantExpr ( Constant C,
ConstantExpr CE 
)

ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a getelementptr constantexpr, return the constant value being addressed by the constant expression, or null if something is funny and we can't decide.

Definition at line 251 of file Transforms/Utils/Local.cpp.

References llvm::CallingConv::C, CP, E, gep_type_begin(), gep_type_end(), llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::Constant::getOperand(), llvm::ConstantExpr::getOperand(), llvm::Value::getType(), and I.

Referenced by CleanupConstantGlobalUsers(), ComputeLoadResult(), and isSimpleEnoughPointerToCommit().

bool llvm::isInstructionTriviallyDead ( Instruction I  ) 

isInstructionTriviallyDead - Return true if the result produced by the instruction is not used, and the instruction has no side effects.

Definition at line 309 of file Transforms/Utils/Local.cpp.

References F, llvm::Instruction::mayWriteToMemory(), and llvm::Value::use_empty().

Referenced by dceInstruction(), ErasePossiblyDeadInstructionTree(), and SimplifyCFG().

bool llvm::dceInstruction ( BasicBlock::iterator BBI  ) 

dceInstruction - Inspect the instruction at *BBI and figure out if it isTriviallyDead. If so, remove the instruction and update the iterator to point to the instruction that immediately succeeded the original instruction.

Definition at line 329 of file Transforms/Utils/Local.cpp.

References isInstructionTriviallyDead().

FunctionPass* llvm::createLoopSimplifyPass (  ) 

Definition at line 97 of file LoopSimplify.cpp.

bool llvm::isAllocaPromotable ( const AllocaInst AI,
const TargetData TD 
)

isAllocaPromotable - Return true if this alloca is legal for promotion. This is true if there are only loads and stores to the alloca.

Definition at line 35 of file PromoteMemoryToRegister.cpp.

References AI, llvm::Value::use_begin(), and llvm::Value::use_end().

void llvm::PromoteMemToReg ( const std::vector< AllocaInst * > &  Allocas,
DominatorTree DT,
DominanceFrontier DF,
const TargetData TD,
AliasSetTracker AST 
)

PromoteMemToReg - Promote the specified list of alloca instructions into scalar registers, inserting PHI nodes as appropriate. This function makes use of DominanceFrontier information. This function does not modify the CFG of the function at all. All allocas must be from the same function.

If AST is specified, the specified tracker is updated to reflect changes made to the IR.

Definition at line 714 of file PromoteMemoryToRegister.cpp.

References AST, llvm::X86II::DF, DT, RetryList, and TD.

bool llvm::SimplifyCFG ( BasicBlock BB  ) 

SimplifyCFG - This function is used to do simplification of a CFG. For example, it adjusts branches to branches to eliminate the extra hop, it eliminates unreachable basic blocks, and does other "peephole" optimization of the CFG. It returns true if a modification was made, possibly deleting the basic block that was pointed to.

WARNING: The entry node of a method may not be simplified.

Definition at line 1151 of file Utils/SimplifyCFG.cpp.

References llvm::SwitchInst::addCase(), llvm::PHINode::addIncoming(), AddPredecessorToBlock(), llvm::BasicBlock::back(), BB, llvm::BasicBlock::begin(), BlockIsSimpleEnoughToThreadThrough(), llvm::Type::BoolTy, Changed, llvm::BinaryOperator::clone(), ConstantFoldTerminator(), llvm::BinaryOperator::create(), llvm::BinaryOperator::createNot(), DEBUG, E, llvm::BasicBlock::empty(), llvm::BasicBlock::end(), ErasePossiblyDeadInstructionTree(), FoldCondBranchOnPHI(), FoldTwoEntryPHINode(), FoldValueComparisonIntoPredecessors(), llvm::BasicBlock::front(), llvm::Function::front(), GatherValueComparisons(), llvm::ConstantBool::get(), llvm::UndefValue::get(), llvm::PHINode::getBasicBlockIndex(), llvm::PHINode::getIncomingValue(), llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::TargetInstrInfo::getName(), llvm::User::getNumOperands(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getSinglePredecessor(), llvm::BasicBlock::getTerminator(), llvm::Value::hasName(), HoistThenElseCodeToIf(), I, II, isInstructionTriviallyDead(), isValueEqualityComparison(), M, PI, pred_begin(), pred_end(), Preds, llvm::BasicBlock::removePredecessor(), llvm::Value::replaceAllUsesWith(), SafeToMergeTerminators(), SE, llvm::PHINode::setIncomingValue(), llvm::Value::setName(), llvm::User::setOperand(), SimplifyCFG(), SimplifyEqualityComparisonWithOnlyPredecessor(), succ_begin(), succ_end(), TryToSimplifyUncondBranchFromEmptyBlock(), and V.

Referenced by SimplifyCFG().

Pass* llvm::createUnifyFunctionExitNodesPass (  ) 

Definition at line 28 of file UnifyFunctionExitNodes.cpp.

Value* llvm::MapValue ( const Value V,
std::map< const Value *, Value * > &  VM 
)

Definition at line 21 of file ValueMapper.cpp.

References llvm::CallingConv::C, llvm::Instruction::Cast, CP, llvm::Instruction::ExtractElement, llvm::ConstantPacked::get(), llvm::ConstantExpr::get(), llvm::ConstantStruct::get(), llvm::ConstantArray::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getExtractElement(), llvm::ConstantExpr::getGetElementPtr(), llvm::ConstantExpr::getInsertElement(), llvm::User::getNumOperands(), llvm::Constant::getOperand(), llvm::ConstantExpr::getSelect(), llvm::ConstantExpr::getShuffleVector(), Idx, llvm::Instruction::InsertElement, llvm::Instruction::Select, llvm::Instruction::ShuffleVector, and V.

Referenced by CloneModule(), and RemapInstruction().

void llvm::RemapInstruction ( Instruction I,
std::map< const Value *, Value * > &  ValueMap 
)

RemapInstruction - Convert the instruction operands from referencing the current values into those specified by ValueMap.

Definition at line 141 of file ValueMapper.cpp.

References E, llvm::User::getNumOperands(), llvm::User::getOperand(), MapValue(), Op, llvm::User::setOperand(), and V.

Referenced by CloneFunctionInto(), and CloneTraceInto().

Value* llvm::MapValue ( const Value *  V,
ValueMapTy VM 
)

void llvm::RemapInstruction ( Instruction *  I,
ValueMapTy VM 
)

std::ostream& llvm::WriteTypeSymbolic ( std::ostream &  Out,
const Type Ty,
const Module M 
)

WriteTypeSymbolic - This attempts to write the specified type as a symbolic type, iff there is an entry in the modules symbol table for the specified type or one of it's component types. This is slower than a simple x << Type

Definition at line 385 of file AsmWriter.cpp.

References fillTypeNameTable(), llvm::Type::getDescription(), M, printTypeInt(), Ty, and TypeNames.

Referenced by llvm::AsmPrinter::EmitConstantPool(), getCaption(), llvm::DSNode::mergeTypeInfo(), llvm::CachedWriter::operator<<(), ProcessGlobalsWithSameName(), ResolveFunctions(), and ToStr().

std::ostream& llvm::WriteAsOperand ( std::ostream &  Out,
const Value V,
bool  PrintType,
bool  PrintName,
const Module Context 
)

WriteAsOperand - Write the name of the specified value out to the specified ostream. This can be useful when you just want to print int reg126, not the whole instruction that generated it.

Definition at line 603 of file AsmWriter.cpp.

References fillTypeNameTable(), getModuleFromVal(), printTypeInt(), TypeNames, V, and WriteAsOperandInternal().

std::ostream& llvm::WriteAsOperand ( std::ostream &  Out,
const Type Ty,
bool  PrintType,
bool  PrintName,
const Module Context 
)

WriteAsOperand - Write the name of the specified value out to the specified ostream. This can be useful when you just want to print int reg126, not the whole instruction that generated it.

Definition at line 644 of file AsmWriter.cpp.

References fillTypeNameTable(), printTypeInt(), Ty, TypeNames, and WriteAsOperandInternal().

Function* llvm::UpgradeIntrinsicFunction ( Function F  ) 

Remove overloaded intrinsic function names.

This function inspects the Function F to see if it is an old overloaded intrinsic. If it is, the Function's name is changed to add a suffix that indicates the kind of arguments or result that it accepts. In LLVM release 1.7, the overloading of intrinsic functions was replaced with separate functions for each of the various argument sizes. This function implements the auto-upgrade feature from the old overloaded names to the new non-overloaded names.

Parameters:
F The Function to potentially auto-upgrade.
Returns:
A corrected version of F, or 0 if no change necessary

Definition at line 192 of file AutoUpgrade.cpp.

References F, getUpgradedIntrinsic(), and R.

Referenced by UpgradeCallsToIntrinsic().

void llvm::UpgradeIntrinsicCall ( CallInst CI,
Function newF = 0 
)

Get replacement instruction for overloaded intrinsic function call.

In LLVM 1.7, the overloading of intrinsic functions was replaced with separate functions for each of the various argument sizes. This function implements the auto-upgrade feature from old overloaded names to the new non-overloaded names. This function inspects the CallInst CI to see if it is a call to an old overloaded intrinsic. If it is, a new CallInst is created that uses the correct Function and possibly casts the argument and result to an unsigned type.

Parameters:
CI The CallInst to potentially auto-upgrade.

Definition at line 217 of file AutoUpgrade.cpp.

References CastArg(), llvm::Instruction::eraseFromParent(), F, llvm::UndefValue::get(), getArgumentPermutation(), llvm::CallInst::getCalledFunction(), llvm::CallInst::getCallingConv(), llvm::Function::getFunctionType(), llvm::Value::getName(), llvm::User::getNumOperands(), llvm::FunctionType::getNumParams(), llvm::User::getOperand(), llvm::FunctionType::getParamType(), llvm::Function::getReturnType(), llvm::Value::getType(), llvm::CallInst::isTailCall(), llvm::Instruction::moveBefore(), llvm::Value::replaceAllUsesWith(), llvm::CallInst::setCallingConv(), llvm::CallInst::setTailCall(), llvm::Value::use_empty(), V, and llvm::Type::VoidTy.

Referenced by llvm::BytecodeReader::ParseFunctionBody(), and UpgradeCallsToIntrinsic().

bool llvm::UpgradeCallsToIntrinsic ( Function F  ) 

Upgrade both the function and all the calls made to it, if that function needs to be upgraded. This is like a combination of the above two functions, UpgradeIntrinsicFunction and UpgradeIntrinsicCall. Note that the calls are replaced so this should only be used in a post-processing manner (i.e. after all assembly/bytecode has been read).

Definition at line 275 of file AutoUpgrade.cpp.

References F, UpgradeIntrinsicCall(), and UpgradeIntrinsicFunction().

Referenced by PerModuleInfo::ModuleDone().

Constant * llvm::ConstantFoldCastInstruction ( const Constant V,
const Type DestTy 
)

Definition at line 700 of file VMCore/ConstantFolding.cpp.

References llvm::Type::BoolTy, llvm::Type::BoolTyID, llvm::Instruction::Cast, CastConstantPacked(), CP, llvm::Type::DoubleTyID, llvm::Type::FloatTyID, llvm::UndefValue::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), llvm::User::getNumOperands(), llvm::Constant::getOperand(), getSize(), GV, llvm::Type::IntTy, llvm::Type::IntTyID, llvm::Type::isFloatingPoint(), llvm::Type::LongTyID, Op, llvm::Type::PointerTyID, llvm::Type::SByteTyID, llvm::Type::ShortTyID, llvm::ConstantBool::True, llvm::Type::UByteTyID, llvm::Type::UIntTy, llvm::Type::UIntTyID, llvm::Type::ULongTyID, llvm::Type::UShortTyID, and V.

Referenced by llvm::ConstantExpr::getCast().

Constant * llvm::ConstantFoldSelectInstruction ( const Constant Cond,
const Constant V1,
const Constant V2 
)

Definition at line 820 of file VMCore/ConstantFolding.cpp.

References llvm::ConstantBool::False, and llvm::ConstantBool::True.

Referenced by llvm::ConstantExpr::getSelectTy().

Constant * llvm::ConstantFoldExtractElementInstruction ( const Constant Val,
const Constant Idx 
)

Definition at line 835 of file VMCore/ConstantFolding.cpp.

References llvm::UndefValue::get(), llvm::Constant::getNullValue(), Idx, and Val.

Referenced by llvm::ConstantExpr::getExtractElementTy().

Constant * llvm::ConstantFoldInsertElementInstruction ( const Constant Val,
const Constant Elt,
const Constant Idx 
)

Definition at line 854 of file VMCore/ConstantFolding.cpp.

References llvm::ConstantPacked::get(), llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::Value::getType(), llvm::ConstantUInt::getValue(), Idx, llvm::Constant::isNullValue(), Op, and Val.

Referenced by llvm::ConstantExpr::getInsertElementTy().

Constant * llvm::ConstantFoldShuffleVectorInstruction ( const Constant V1,
const Constant V2,
const Constant Mask 
)

Definition at line 911 of file VMCore/ConstantFolding.cpp.

Referenced by llvm::ConstantExpr::getShuffleVectorTy().

Constant * llvm::ConstantFoldBinaryInstruction ( unsigned  Opcode,
const Constant V1,
const Constant V2 
)

Definition at line 1157 of file VMCore/ConstantFolding.cpp.

References llvm::Type::BoolTy, llvm::CallingConv::C, llvm::Instruction::Cast, evaluateRelation(), llvm::ConstantBool::False, llvm::ConstantBool::get(), llvm::UndefValue::get(), llvm::ConstantIntegral::getAllOnesValue(), llvm::ConstantExpr::getNot(), llvm::Constant::getNullValue(), llvm::SetCondInst::getSwappedCondition(), llvm::Instruction::isRelational(), llvm::Instruction::Shl, and llvm::ConstantBool::True.

Referenced by llvm::ConstantExpr::getShiftTy(), and llvm::ConstantExpr::getTy().

Constant * llvm::ConstantFoldGetElementPtr ( const Constant C,
const std::vector< Value * > &  IdxList 
)

Definition at line 1370 of file VMCore/ConstantFolding.cpp.

References llvm::CallingConv::C, llvm::Instruction::Cast, E, gep_type_begin(), gep_type_end(), llvm::ConstantExpr::get(), llvm::ConstantUInt::get(), llvm::ConstantPointerNull::get(), llvm::PointerType::get(), llvm::UndefValue::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getGetElementPtr(), llvm::GetElementPtrInst::getIndexedType(), llvm::ConstantExpr::getMul(), llvm::Value::getType(), I, llvm::Constant::isNullValue(), llvm::Type::LongTy, R, Ty, and llvm::Type::UIntTy.

Referenced by llvm::ConstantExpr::getGetElementPtrTy().

static std::ostream& llvm::operator<< ( std::ostream &  o,
const std::set< BasicBlock * > &  BBs 
) [static]

Definition at line 310 of file Dominators.cpp.

References E, I, and WriteAsOperand().

std::ostream& llvm::operator<< ( std::ostream &  OS,
const Type T 
)

Definition at line 1418 of file Type.cpp.

References llvm::Type::print(), and T.

FunctionPass* llvm::createVerifierPass ( VerifierFailureAction  action  ) 

Definition at line 766 of file Verifier.cpp.

bool llvm::verifyFunction ( const Function f,
VerifierFailureAction  action 
)

Definition at line 772 of file Verifier.cpp.

References F, and V.

bool llvm::verifyModule ( const Module M,
VerifierFailureAction  action 
)

verifyModule - Check a module for errors, printing messages on stderr. Return true if the module is corrupt.

Definition at line 786 of file Verifier.cpp.

References llvm::PassManager::add(), M, llvm::PassManager::run(), and V.


Variable Documentation

IncludeFile llvm::CALLGRAPH_INCLUDE_FILE((void *)&CallGraph::stub) [static]

IncludeFile llvm::DOMINATORS_INCLUDE_FILE((void *)&DominatorSet::stub) [static]

IncludeFile llvm::FIND_USED_TYPES_INCLUDE_FILE((void *)(&FindUsedTypes::stub)) [static]

IncludeFile llvm::LOOP_INFO_INCLUDE_FILE((void *)(&LoopInfo::stub)) [static]

IncludeFile llvm::POST_DOMINATOR_INCLUDE_FILE((void *)&PostDominanceFrontier::stub) [static]

const PassInfo * llvm::PHIEliminationID = X.getPassInfo()

PHIElimination pass - This pass eliminates machine instruction PHI nodes by inserting copy instructions. This destroys SSA information, but is the desired input for some register allocators. This pass is "required" by these register allocator like this: AU.addRequiredID(PHIEliminationID);

Definition at line 65 of file PHIElimination.cpp.

Referenced by llvm::LiveIntervals::getAnalysisUsage().

const PassInfo * llvm::TwoAddressInstructionPassID = X.getPassInfo()

TwoAddressInstruction pass - This pass reduces two-address instructions to use two operands. This destroys SSA information but it is desired by register allocators.

Definition at line 65 of file TwoAddressInstructionPass.cpp.

Referenced by llvm::LiveIntervals::getAnalysisUsage().

const ResourceId llvm::InvalidRID = -1

Definition at line 30 of file SchedGraphCommon.h.

const ResourceId llvm::MachineCCRegsRID = -2

Definition at line 31 of file SchedGraphCommon.h.

const ResourceId llvm::MachineIntRegsRID = -3

Definition at line 32 of file SchedGraphCommon.h.

const ResourceId llvm::MachineFPRegsRID = -4

Definition at line 33 of file SchedGraphCommon.h.

bool llvm::TimePassesIsEnabled = false

This is the storage for the -time-passes option.

If the user specifies the -time-passes argument on an LLVM tool command line then the value of this boolean will be true, otherwise false.

Definition at line 119 of file Pass.cpp.

bool llvm::DebugFlag

Definition at line 30 of file Debug.cpp.

llvm::Alloca

Definition at line 179 of file InstVisitor.h.

Referenced by isUnmovableInstruction(), and TraceThisOpCode().

AllocaInst llvm::HANDLE_MEMORY_INST(24, Load, LoadInst)HANDLE_OTHER_INST(27

AllocaInst llvm::PHI

Definition at line 187 of file InstVisitor.h.

Referenced by ConvertOperandToType(), getConstantEvolvingPHI(), getNextStopPoint(), InlineFunction(), llvm::X86TargetLowering::InsertAtEndOfBasicBlock(), llvm::PPCTargetLowering::InsertAtEndOfBasicBlock(), isUnmovableInstruction(), OperandConvertibleToType(), RecordSchedule(), ResolveDefinitions(), and TraceThisOpCode().

AllocaInst PHINode llvm::Call

Definition at line 189 of file InstVisitor.h.

Referenced by llvm::DOTGraphTraits< const DSGraph * >::addCustomGraphFeatures(), CallPassesValueThoughVararg(), ConstantFold(), ConvertOperandToType(), isUnmovableInstruction(), markIncomplete(), and OperandConvertibleToType().

AllocaInst PHINode CallInst llvm::Select

Definition at line 195 of file InstVisitor.h.

Referenced by ComputeMaskedBits(), ConstantFold(), DecomposeConstantExpr(), and RemapOperand().

AllocaInst PHINode CallInst SelectInst llvm::VAArg

Definition at line 199 of file InstVisitor.h.

AllocaInst PHINode CallInst SelectInst VAArgInst llvm::InsertElement

Definition at line 201 of file InstVisitor.h.

Referenced by CheapToScalarize(), and RemapOperand().

cl::opt<PluginLoader, false, cl::parser<std::string> > llvm::LoadOpt("load", cl::ZeroOrMore, cl::value_desc("pluginfilename"), cl::desc("Load the specified plugin")) [static]

const unsigned llvm::M_NOP_FLAG = 1 << 0

Definition at line 47 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isNop().

const unsigned llvm::M_BRANCH_FLAG = 1 << 1

Definition at line 48 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isBranch().

const unsigned llvm::M_CALL_FLAG = 1 << 2

Definition at line 49 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isCall().

const unsigned llvm::M_RET_FLAG = 1 << 3

Definition at line 50 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isReturn().

const unsigned llvm::M_BARRIER_FLAG = 1 << 4

Definition at line 51 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isBarrier().

const unsigned llvm::M_DELAY_SLOT_FLAG = 1 << 5

Definition at line 52 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::hasDelaySlot().

const unsigned llvm::M_CC_FLAG = 1 << 6

Definition at line 53 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isCCInstr().

const unsigned llvm::M_LOAD_FLAG = 1 << 7

Definition at line 54 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isLoad().

const unsigned llvm::M_STORE_FLAG = 1 << 8

Definition at line 55 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isStore().

const unsigned llvm::M_2_ADDR_FLAG = 1 << 9

Definition at line 58 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isTwoAddrInstr().

const unsigned llvm::M_CONVERTIBLE_TO_3_ADDR = 1 << 10

Definition at line 64 of file TargetInstrInfo.h.

const unsigned llvm::M_COMMUTABLE = 1 << 11

Definition at line 68 of file TargetInstrInfo.h.

const unsigned llvm::M_TERMINATOR_FLAG = 1 << 12

Definition at line 74 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isTerminatorInstr().

const unsigned llvm::M_USES_CUSTOM_DAG_SCHED_INSERTION = 1 << 13

Definition at line 79 of file TargetInstrInfo.h.

Referenced by llvm::ScheduleDAG::EmitNode(), and llvm::TargetInstrInfo::usesCustomDAGSchedInsertionHook().

bool llvm::PrintMachineCode

PrintMachineCode - This flag is enabled when the -print-machineinstrs option is specified on the command line, and should enable debugging output from the code generator.

Definition at line 25 of file TargetMachine.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::AlphaJITInfo::addPassesToJITCompile().

bool llvm::NoFramePointerElim

NoFramePointerElim - This flag is enabled when the -disable-fp-elim is specified on the command line. If the target supports the frame pointer elimination optimization, this option should disable it.

Definition at line 26 of file TargetMachine.cpp.

Referenced by hasFP().

bool llvm::NoExcessFPPrecision

NoExcessFPPrecision - This flag is enabled when the -disable-excess-fp-precision flag is specified on the command line. When this flag is off (the default), the code generator is allowed to produce results that are "more precise" than IEEE allows. This includes use of FMA-like operations and use of the X86 FP registers without rounding all over the place.

Definition at line 27 of file TargetMachine.cpp.

bool llvm::UnsafeFPMath

UnsafeFPMath - This flag is enabled when the -enable-unsafe-fp-math flag is specified on the command line. When this flag is off (the default), the code generator is not allowed to produce results that are "less precise" than IEEE allows. This includes use of X86 instructions like FSIN and FCOS instead of libcalls.

Definition at line 28 of file TargetMachine.cpp.

Referenced by llvm::X86TargetLowering::X86TargetLowering().

const CycleCount_t llvm::HUGE_LATENCY = ~((long long) 1 << (sizeof(CycleCount_t)-2)) [static]

Definition at line 26 of file TargetSchedInfo.h.

Referenced by llvm::SchedPriorities::issuedReadyNodeAt().

const CycleCount_t llvm::INVALID_LATENCY = -HUGE_LATENCY [static]

Definition at line 27 of file TargetSchedInfo.h.

const int llvm::MAX_NUM_SLOTS = 32

Definition at line 70 of file TargetSchedInfo.h.

Referenced by llvm::TargetSchedInfo::initializeResources().

const int llvm::MAX_NUM_CYCLES = 32

Definition at line 71 of file TargetSchedInfo.h.

const PassInfo * llvm::DemoteRegisterToMemoryID = X.getPassInfo()

Definition at line 84 of file Reg2Mem.cpp.

const PassInfo * llvm::BreakCriticalEdgesID = X.getPassInfo()

Definition at line 54 of file BreakCriticalEdges.cpp.

Referenced by llvm::UnifyFunctionExitNodes::getAnalysisUsage().

const PassInfo * llvm::LoopSimplifyID = X.getPassInfo()

Definition at line 96 of file LoopSimplify.cpp.

const PassInfo * llvm::LowerInvokePassID = X.getPassInfo()

Definition at line 92 of file LowerInvoke.cpp.

std::string llvm::CurFilename

Definition at line 305 of file llvmAsmParser.cpp.

Referenced by RunVMAsmParser(), ThrowException(), and yyerror().

std::string llvm::CurFilename

Definition at line 305 of file llvmAsmParser.cpp.

Referenced by RunVMAsmParser(), ThrowException(), and yyerror().

const TargetInstrDescriptor* llvm::TargetInstrDescriptors

Definition at line 25 of file TargetInstrInfo.cpp.

Referenced by operator<<(), llvm::MachineInstr::SetMachineOperandConst(), llvm::TargetInstrInfo::TargetInstrInfo(), and llvm::TargetInstrInfo::~TargetInstrInfo().

const bool llvm::pthread_enabled = static_cast<bool>(pthread_mutex_init) [static]

Definition at line 55 of file Mutex.cpp.

Referenced by llvm::sys::Mutex::acquire(), llvm::sys::Mutex::Mutex(), llvm::sys::Mutex::release(), llvm::sys::Mutex::tryacquire(), and llvm::sys::Mutex::~Mutex().

PPCTargetEnum llvm::PPCTarget = TargetDefault

Definition at line 21 of file PPCSubtarget.cpp.

Referenced by llvm::PPCTargetMachine::addPassesToEmitFile(), and llvm::PPCTargetMachine::PPCTargetMachine().

SchedDebugLevel_t llvm::SchedDebugLevel

Definition at line 29 of file InstrScheduling.cpp.

Referenced by llvm::SchedPriorities::insertReady().

cl::opt<bool> llvm::EnableFillingDelaySlots("sched-fill-delay-slots", cl::Hidden, cl::desc("Fill branch delay slots during local scheduling")) [static]

Referenced by ChooseInstructionsForDelaySlots().

cl::opt<SchedDebugLevel_t, true> llvm::SDL_opt("dsched", cl::Hidden, cl::location(SchedDebugLevel), cl::desc("enable instruction scheduling debugging information"), cl::values(clEnumValN(Sched_NoDebugInfo,"n","disable debug output"),clEnumValN(Sched_PrintMachineCode,"y","print machine code after scheduling"),clEnumValN(Sched_PrintSchedTrace,"t","print trace of scheduling actions"),clEnumValN(Sched_PrintSchedGraphs,"g","print scheduling graphs"),clEnumValEnd)) [static]

const int llvm::SG_LOAD_REF = 0 [static]

Definition at line 220 of file SchedGraph.cpp.

const int llvm::SG_STORE_REF = 1 [static]

Definition at line 221 of file SchedGraph.cpp.

const int llvm::SG_CALL_REF = 2 [static]

Definition at line 222 of file SchedGraph.cpp.

const unsigned int llvm::SG_DepOrderArray[][3] [static]

Initial value:

Definition at line 224 of file SchedGraph.cpp.

SchedDebugLevel_t llvm::SchedDebugLevel

Definition at line 29 of file InstrScheduling.cpp.

Referenced by llvm::SchedPriorities::insertReady().

LiveVarDebugLevel_t llvm::DEBUG_LV

Definition at line 32 of file FunctionLiveVarInfo.cpp.

RegisterAnalysis<FunctionLiveVarInfo> llvm::X("livevar","Live Variable Analysis") [static]

Referenced by llvm::AliasSetTracker::add(), cast(), llvm::DSGraph::cloneInto(), llvm::Trace::contains(), llvm::Trace::getBlockIndex(), llvm::V9LiveRange::insert(), llvm::Mangler::Mangler(), llvm::DSGraph::mergeInGraph(), llvm::mapped_iterator< RootIt, UnaryFunc >::operator!=(), llvm::AllocInfo::operator!=(), operator+(), llvm::mapped_iterator< RootIt, UnaryFunc >::operator-(), llvm::mapped_iterator< RootIt, UnaryFunc >::operator<(), llvm::mapped_iterator< RootIt, UnaryFunc >::operator==(), llvm::AllocInfo::operator==(), llvm::DSGraph::removeDeadNodes(), llvm::DSGraph::removeTriviallyDeadNodes(), and llvm::BUDataStructures::runOnModule().

LiveVarDebugLevel_t llvm::DEBUG_LV

Definition at line 32 of file FunctionLiveVarInfo.cpp.

cl::opt<LiveVarDebugLevel_t, true> llvm::DEBUG_LV_opt("dlivevar", cl::Hidden, cl::location(DEBUG_LV), cl::desc("enable live-variable debugging information"), cl::values(clEnumValN(LV_DEBUG_None,"n","disable debug output"), clEnumValN(LV_DEBUG_Normal,"y","enable debug output"), clEnumValN(LV_DEBUG_Instr,"i","print live-var sets before/after ""every machine instrn"), clEnumValN(LV_DEBUG_Verbose,"v","print def, use sets for every instrn also"),clEnumValEnd)) [static]

Statistic llvm::ValidLoops("modulosched-validLoops","Number of candidate loops modulo-scheduled")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::JumboBB("modulosched-jumboBB","Basic Blocks with more then 100 instructions")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::LoopsWithCalls("modulosched-loopCalls","Loops with calls")

Statistic llvm::LoopsWithCondMov("modulosched-loopCondMov","Loops with conditional moves")

Statistic llvm::InvalidLoops("modulosched-invalidLoops","Loops with unknown trip counts or loop invariant trip counts")

Statistic llvm::SingleBBLoops("modulosched-singeBBLoops","Number of single basic block loops")

Statistic llvm::MSLoops("modulosched-schedLoops","Number of loops successfully modulo-scheduled")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::NoSched("modulosched-noSched","No schedule")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::SameStage("modulosched-sameStage","Max stage is 0")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::ResourceConstraint("modulosched-resourceConstraint","Loops constrained by resources")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::RecurrenceConstraint("modulosched-recurrenceConstraint","Loops constrained by recurrences")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::FinalIISum("modulosched-finalIISum","Sum of all final II")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::IISum("modulosched-IISum","Sum of all theoretical II")

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

Statistic llvm::NumLoops("moduloschedSB-numLoops","Total Number of Loops")

Statistic llvm::NumSB("moduloschedSB-numSuperBlocks","Total Number of SuperBlocks")

Statistic llvm::BBWithCalls("modulosched-BBCalls","Basic Blocks rejected due to calls")

Statistic llvm::BBWithCondMov("modulosched-loopCondMov","Basic Blocks rejected due to conditional moves")

Statistic llvm::SBResourceConstraint("modulosched-resourceConstraint","Loops constrained by resources")

Referenced by llvm::ModuloSchedulingSBPass::runOnFunction().

Statistic llvm::SBRecurrenceConstraint("modulosched-recurrenceConstraint","Loops constrained by recurrences")

Referenced by llvm::ModuloSchedulingSBPass::runOnFunction().

Statistic llvm::SBFinalIISum("modulosched-finalIISum","Sum of all final II")

Referenced by llvm::ModuloSchedulingSBPass::runOnFunction().

Statistic llvm::SBIISum("modulosched-IISum","Sum of all theoretical II")

Referenced by llvm::ModuloSchedulingSBPass::runOnFunction().

Statistic llvm::SBMSLoops("modulosched-schedLoops","Number of loops successfully modulo-scheduled")

Referenced by llvm::ModuloSchedulingSBPass::runOnFunction().

Statistic llvm::SBNoSched("modulosched-noSched","No schedule")

Referenced by llvm::ModuloSchedulingSBPass::runOnFunction().

Statistic llvm::SBSameStage("modulosched-sameStage","Max stage is 0")

Referenced by llvm::ModuloSchedulingSBPass::runOnFunction().

Statistic llvm::SBBLoops("modulosched-SBBLoops","Number single basic block loops")

Statistic llvm::SBInvalid("modulosched-SBInvalid","Number invalid superblock loops")

Statistic llvm::SBValid("modulosched-SBValid","Number valid superblock loops")

Statistic llvm::SBSize("modulosched-SBSize","Total size of all valid superblocks")

Statistic llvm::RASpills("regalloc-spills","Number of registers spilled")

RegAllocDebugLevel_t llvm::DEBUG_RA

Definition at line 56 of file PhyRegAlloc.cpp.

Referenced by llvm::LiveRangeInfo::coalesceLRs(), llvm::RegClass::colorAllRegs(), llvm::SparcV9FloatRegClass::colorIGNode(), llvm::SparcV9IntRegClass::colorIGNode(), llvm::LiveRangeInfo::constructLiveRanges(), llvm::InterferenceGraph::InterferenceGraph(), llvm::InterferenceGraph::mergeIGNodesOfLRs(), llvm::RegClass::RegClass(), and llvm::InterferenceGraph::setInterference().

cl::opt<RegAllocDebugLevel_t, true> llvm::DRA_opt("dregalloc", cl::Hidden, cl::location(DEBUG_RA), cl::desc("enable register allocation debugging information"), cl::values(clEnumValN(RA_DEBUG_None,"n","disable debug output"),clEnumValN(RA_DEBUG_Results,"y","debug output for allocation results"),clEnumValN(RA_DEBUG_Coloring,"c","debug output for graph coloring step"),clEnumValN(RA_DEBUG_Interference,"ig","debug output for interference graphs"),clEnumValN(RA_DEBUG_LiveRanges,"lr","debug output for live ranges"),clEnumValN(RA_DEBUG_Verbose,"v","extra debug output"),clEnumValEnd)) [static]

PhyRegAlloc::SavedStateMapTy llvm::ExportedFnAllocState

The reoptimizer wants to be able to grovel through the register allocator's state after it has done its job. This is a hack.

Definition at line 73 of file PhyRegAlloc.cpp.

bool llvm::SaveRegAllocState = false

Definition at line 74 of file PhyRegAlloc.cpp.

bool llvm::SaveStateToModule = true

Definition at line 75 of file PhyRegAlloc.cpp.

cl::opt<bool, true> llvm::SaveRegAllocStateOpt("save-ra-state", cl::Hidden, cl::location(SaveRegAllocState), cl::init(false), cl::desc("write reg. allocator state into module")) [static]

RegAllocDebugLevel_t llvm::DEBUG_RA

Definition at line 56 of file PhyRegAlloc.cpp.

Referenced by llvm::LiveRangeInfo::coalesceLRs(), llvm::RegClass::colorAllRegs(), llvm::SparcV9IntRegClass::colorIGNode(), llvm::SparcV9FloatRegClass::colorIGNode(), llvm::LiveRangeInfo::constructLiveRanges(), llvm::InterferenceGraph::InterferenceGraph(), llvm::InterferenceGraph::mergeIGNodesOfLRs(), llvm::RegClass::RegClass(), and llvm::InterferenceGraph::setInterference().

cl::opt<SelectDebugLevel_t> llvm::SelectDebugLevel("dselect", cl::Hidden, cl::desc("enable instruction selection debug information"), cl::values(clEnumValN(Select_NoDebugInfo,"n","disable debug output"),clEnumValN(Select_PrintMachineCode,"y","print generated machine code"),clEnumValN(Select_DebugInstTrees,"i","print debugging info for instruction selection"),clEnumValN(Select_DebugBurgTrees,"b","print burg trees"),clEnumValEnd)) [static]

const uint32_t llvm::MAXLO = (1 << 10) - 1 [static]

Definition at line 513 of file SparcV9BurgISel.cpp.

const uint32_t llvm::MAXSIMM = (1 << 12) - 1 [static]

Definition at line 514 of file SparcV9BurgISel.cpp.

const TargetInstrDescriptor llvm::SparcV9MachineInstrDesc

Definition at line 36 of file SparcV9TargetMachine.cpp.

const char* const llvm::IntRegNames[] [static]

Initial value:

 {
  "o0", "o1", "o2", "o3", "o4", "o5",       "o7",
  "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
  "i0", "i1", "i2", "i3", "i4", "i5",
  "i6", "i7",
  "g0", "g1", "g2", "g3", "g4", "g5",  "g6", "g7",
  "o6"
}

Definition at line 81 of file SparcV9RegInfo.cpp.

Referenced by llvm::SparcV9IntRegClass::getRegName().

const char* const llvm::FloatRegNames[] [static]

Initial value:

 {
  "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",  "f8",  "f9",
  "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19",
  "f20", "f21", "f22", "f23", "f24", "f25", "f26", "f27", "f28", "f29",
  "f30", "f31", "f32", "f33", "f34", "f35", "f36", "f37", "f38", "f39",
  "f40", "f41", "f42", "f43", "f44", "f45", "f46", "f47", "f48", "f49",
  "f50", "f51", "f52", "f53", "f54", "f55", "f56", "f57", "f58", "f59",
  "f60", "f61", "f62", "f63"
}

Definition at line 95 of file SparcV9RegInfo.cpp.

Referenced by llvm::SparcV9FloatRegClass::getRegName().

const char* const llvm::IntCCRegNames[] [static]

Initial value:

 {
  "xcc",  "icc",  "ccr"
}

Definition at line 110 of file SparcV9RegInfo.cpp.

Referenced by llvm::SparcV9IntCCRegClass::getRegName().

const char* const llvm::FloatCCRegNames[] [static]

Initial value:

 {
  "fcc0", "fcc1",  "fcc2",  "fcc3"
}

Definition at line 119 of file SparcV9RegInfo.cpp.

Referenced by llvm::SparcV9FloatCCRegClass::getRegName().

const char* const llvm::SpecialRegNames[] [static]

Initial value:

 {
  "fsr"
}

Definition at line 128 of file SparcV9RegInfo.cpp.

Referenced by llvm::SparcV9SpecialRegClass::getRegName().

const unsigned llvm::IR[] [static]

Initial value:

Definition at line 37 of file SparcV9RegisterInfo.cpp.

const MVT::ValueType llvm::IRVTs[] = { MVT::i64, MVT::Other } [static]

Definition at line 46 of file SparcV9RegisterInfo.cpp.

{ ... } ::IRClass llvm::IRInstance [static]

const unsigned llvm::FR[] [static]

Initial value:

Definition at line 53 of file SparcV9RegisterInfo.cpp.

Referenced by llvm::X86TargetLowering::LowerOperation(), llvm::PPCTargetLowering::LowerOperation(), llvm::IA64TargetLowering::LowerOperation(), and llvm::AlphaTargetLowering::LowerOperation().

const MVT::ValueType llvm::FRVTs[] = { MVT::f32, MVT::Other } [static]

Definition at line 71 of file SparcV9RegisterInfo.cpp.

{ ... } ::FRClass llvm::FRInstance [static]

const unsigned llvm::ICCR[] [static]

Initial value:

Definition at line 82 of file SparcV9RegisterInfo.cpp.

const MVT::ValueType llvm::ICCRVTs[] = { MVT::i1, MVT::Other } [static]

Definition at line 85 of file SparcV9RegisterInfo.cpp.

{ ... } ::ICCRClass llvm::ICCRInstance [static]

const unsigned llvm::FCCR[] [static]

Initial value:

Definition at line 92 of file SparcV9RegisterInfo.cpp.

const MVT::ValueType llvm::FCCRVTs[] = { MVT::i1, MVT::Other } [static]

Definition at line 95 of file SparcV9RegisterInfo.cpp.

{ ... } ::FCCRClass llvm::FCCRInstance [static]

const unsigned llvm::SR[] [static]

Initial value:

Definition at line 102 of file SparcV9RegisterInfo.cpp.

Referenced by DIGetTypesVisitor::Apply(), DISerializeVisitor::Apply(), and StatRecord::operator<().

const MVT::ValueType llvm::SRVTs[] = { MVT::i64, MVT::Other } [static]

Definition at line 105 of file SparcV9RegisterInfo.cpp.

{ ... } ::SRClass llvm::SRInstance [static]

const TargetRegisterClass* const llvm::RegisterClasses[] [static]

Initial value:

Definition at line 112 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::Empty_AliasSet[] = { 0 } [static]

Definition at line 126 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::fcc3_AliasSet[] = { SparcV9::fsr, 0 } [static]

Definition at line 127 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::fcc2_AliasSet[] = { SparcV9::fsr, 0 } [static]

Definition at line 128 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::fcc1_AliasSet[] = { SparcV9::fsr, 0 } [static]

Definition at line 129 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::fcc0_AliasSet[] = { SparcV9::fsr, 0 } [static]

Definition at line 130 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::fsr_AliasSet[] [static]

Initial value:

Definition at line 131 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::xcc_AliasSet[] = { SparcV9::ccr, 0 } [static]

Definition at line 133 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::icc_AliasSet[] = { SparcV9::ccr, 0 } [static]

Definition at line 134 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::ccr_AliasSet[] = { SparcV9::xcc, SparcV9::icc, 0 } [static]

Definition at line 135 of file SparcV9RegisterInfo.cpp.

const TargetRegisterDesc llvm::RegisterDescriptors[] [static]

Definition at line 137 of file SparcV9RegisterInfo.cpp.

Referenced by llvm::AlphaRegisterInfo::getPrettyName().

bool llvm::EmitMappingInfo = false

Definition at line 598 of file SparcV9TargetMachine.cpp.

const TargetInstrDescriptor* llvm::TargetInstrDescriptors = 0

Definition at line 25 of file TargetInstrInfo.cpp.

Referenced by operator<<(), llvm::MachineInstr::SetMachineOperandConst(), llvm::TargetInstrInfo::TargetInstrInfo(), and llvm::TargetInstrInfo::~TargetInstrInfo().

bool llvm::PrintMachineCode

PrintMachineCode - This flag is enabled when the -print-machineinstrs option is specified on the command line, and should enable debugging output from the code generator.

Definition at line 25 of file TargetMachine.cpp.

Referenced by llvm::AlphaTargetMachine::addPassesToEmitFile(), llvm::IA64TargetMachine::addPassesToEmitFile(), llvm::PPCTargetMachine::addPassesToEmitFile(), llvm::SparcTargetMachine::addPassesToEmitFile(), llvm::X86TargetMachine::addPassesToEmitFile(), llvm::AlphaJITInfo::addPassesToJITCompile(), llvm::PPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

bool llvm::NoFramePointerElim

NoFramePointerElim - This flag is enabled when the -disable-fp-elim is specified on the command line. If the target supports the frame pointer elimination optimization, this option should disable it.

Definition at line 26 of file TargetMachine.cpp.

Referenced by hasFP().

bool llvm::NoExcessFPPrecision

NoExcessFPPrecision - This flag is enabled when the -disable-excess-fp-precision flag is specified on the command line. When this flag is off (the default), the code generator is allowed to produce results that are "more precise" than IEEE allows. This includes use of FMA-like operations and use of the X86 FP registers without rounding all over the place.

Definition at line 27 of file TargetMachine.cpp.

bool llvm::UnsafeFPMath

UnsafeFPMath - This flag is enabled when the -enable-unsafe-fp-math flag is specified on the command line. When this flag is off (the default), the code generator is not allowed to produce results that are "less precise" than IEEE allows. This includes use of X86 instructions like FSIN and FCOS instead of libcalls.

Definition at line 28 of file TargetMachine.cpp.

Referenced by llvm::X86TargetLowering::X86TargetLowering().

Reloc::Model llvm::RelocationModel

Definition at line 29 of file TargetMachine.cpp.

Referenced by llvm::TargetMachine::getRelocationModel(), and llvm::TargetMachine::setRelocationModel().

Statistic llvm::EmittedInsts

Referenced by llvm::X86IntelAsmPrinter::printMachineInstruction(), and llvm::X86ATTAsmPrinter::printMachineInstruction().

RegisterOpt<EmitFunctionTable> llvm::X("emitfuncs","Emit a function table for the reoptimizer") [static]

cl::opt<enum PassDebugLevel> llvm::PassDebugging("debug-pass", cl::Hidden, cl::desc("Print PassManager debugging information"), cl::values(clEnumVal(None,"disable debug output"),clEnumVal(Arguments,"print pass arguments to pass to 'opt'"),clEnumVal(Structure,"print pass structure before run()"),clEnumVal(Executions,"print pass name before it is executed"),clEnumVal(Details,"print pass details when it is executed"),clEnumValEnd)) [static]

Referenced by llvm::PassManagerT< llvm::BBTraits >::addPass(), llvm::PMDebug::PerformPassStartupStuff(), llvm::PMDebug::PrintAnalysisSetInfo(), and llvm::PMDebug::PrintPassInformation().

TimingInfo* llvm::TheTimeInfo [static]

Definition at line 124 of file PassManagerT.h.

Referenced by llvm::TimingInfo::createTheTimeInfo().