LLVM API Documentation

Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

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
struct  ipo_iterator
class  ReversePostOrderTraversal
class  scc_iterator
class  SetVector
 A vector that has set insertion semantics. More...
class  StatisticBase
class  Statistic
struct  bitwise_or
struct  less_ptr
struct  greater_ptr
class  mapped_iterator
class  Tree
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
class  DSScalarMap
struct  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  DominatorTree
struct  GraphTraits< DominatorTree * >
struct  DominanceFrontierBase
struct  DominanceFrontier
struct  ExprType
struct  FindUnsafePointerTypes
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  PostDominatorSet
struct  ImmediatePostDominators
struct  PostDominatorTree
struct  PostDominanceFrontier
class  ProfileInfo
class  ProfileInfoLoader
class  SCEV
struct  SCEVCouldNotCompute
class  SCEVHandle
struct  simplify_type< const SCEVHandle >
struct  simplify_type< SCEVHandle >
class  ScalarEvolution
class  SCEVConstant
class  SCEVTruncateExpr
class  SCEVZeroExtendExpr
class  SCEVCommutativeExpr
class  SCEVAddExpr
class  SCEVMulExpr
class  SCEVUDivExpr
class  SCEVAddRecExpr
class  SCEVUnknown
struct  SCEVVisitor
class  Trace
struct  ValueNumbering
class  Argument
struct  AssemblyAnnotationWriter
class  CachedWriter
struct  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  IntrinsicLowering
struct  DefaultIntrinsicLowering
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
class  MachineConstantPool
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  MachineRelocation
class  SchedGraphNodeCommon
class  SchedGraphEdge
class  SchedGraphCommon
class  SGPredIterator
class  SGSuccIterator
class  SelectionDAG
class  SelectionDAGReducedValue
class  SelectionDAGNode
struct  SelectionDAGTargetBuilder
struct  ReducedValue
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  SourceFileInfo
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  ExecutionEngine
union  GenericValue
struct  ilist_traits< BasicBlock >
struct  ilist_traits< Argument >
class  Function
class  GlobalValue
class  GlobalVariable
class  TerminatorInst
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  VANextInst
class  VAArgInst
class  PHINode
class  ReturnInst
class  BranchInst
class  SwitchInst
class  InvokeInst
class  UnwindInst
class  UnreachableInst
class  IntrinsicInst
struct  DbgInfoIntrinsic
struct  DbgStopPointInst
struct  MemIntrinsic
struct  MemCpyInst
struct  MemMoveInst
struct  MemSetInst
struct  ilist_traits< Function >
struct  ilist_traits< GlobalVariable >
class  Module
class  ModuleProvider
struct  ExistingModuleProvider
class  Pass
class  ModulePass
class  ImmutablePass
class  FunctionPass
struct  BasicBlockPass
class  AnalysisUsage
struct  AnalysisResolver
class  PassManager
class  FunctionPassManager
class  PassInfo
struct  RegisterPassBase
struct  RegisterPass
struct  RegisterOpt
struct  RegisterAnalysis
struct  RegisterLLC
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  FDHandle
class  FileRemover
class  generic_gep_type_iterator
class  GraphWriter
class  InstIterator
class  InstVisitor
struct  LeakDetector
class  Mangler
class  PassNameParser
struct  FilteredPassNameParser
struct  PluginLoader
class  SlowOperationInformer
class  StableBasicBlockNumbering
struct  Mutex
class  MutexLocker
class  Timer
class  TimeRegion
struct  NamedRegionTimer
class  TimerGroup
class  ToolExecutionError
class  GCC
struct  AbstractInterpreter
class  CBE
class  LLC
struct  is_class
struct  TypeInfo
class  SymbolTable
class  SymbolTableListTraits
struct  MRegisterDesc
class  TargetRegisterClass
class  MRegisterInfo
struct  VirtReg2IndexFunctor
class  TargetData
class  StructLayout
class  TargetFrameInfo
class  TargetInstrDescriptor
class  TargetInstrInfo
class  TargetJITInfo
class  TargetMachine
struct  TargetMachineRegistry
struct  RegisterTarget
class  TargetRegistrationListener
class  TargetNameParser
struct  CPUResource
struct  InstrClassRUsage
struct  InstrRUsageDelta
struct  InstrIssueDelta
struct  InstrRUsage
class  TargetSchedInfo
struct  UnifyFunctionExitNodes
class  Type
struct  GraphTraits< Type * >
struct  GraphTraits< const Type * >
class  Use
struct  ilist_traits< Use >
struct  simplify_type< Use >
struct  simplify_type< const Use >
struct  UseListIteratorWrapper
struct  UseListConstIteratorWrapper
class  User
class  Value
struct  DOTGraphTraits< const Function * >
class  Dependence
class  DepGraphNode
class  DependenceGraph
struct  DSCallSiteIterator
class  DSGraphPrintHelper
class  ModRefInfo
class  FunctionModRefInfo
class  IPModRef
struct  ModRefTable
class  ModRefInfoBuilder
class  MemoryDepAnalysis
class  DepIterState
class  PDGIterator
class  PgmDependenceGraph
struct  DOTGraphTraits< const DSGraph * >
struct  ValID
class  ArchiveMemberHeader
 Archive File Member Header. More...
class  BytecodeReader
 Forward declare the handler interfaceBytecode Reader interface. More...
class  SlotCalculator
class  SlotTable
 Abstract data type for slot numbers. More...
class  BytecodeWriter
class  BytecodeBlock
struct  LiveRange
struct  LiveInterval
class  LiveIntervals
struct  DOTGraphTraits< const MachineFunction * >
class  PhysRegTracker
struct  SelectionDAGBuilder
class  VirtRegMap
struct  Spiller
class  AllocaHolder
class  AllocaHolderHandle
struct  ExecutionContext
class  Interpreter
class  JIT
struct  CTargetMachine
class  PowerPCFrameInfo
class  PowerPCJITInfo
class  PowerPCTargetMachine
class  PPC32InstrInfo
class  PPC32JITInfo
class  PPC32RegisterInfo
class  PPC32TargetMachine
class  PPC64InstrInfo
class  PPC64JITInfo
class  PPC64RegisterInfo
class  PPC64TargetMachine
class  SkeletonInstrInfo
class  SkeletonJITInfo
struct  SkeletonRegisterInfo
class  SkeletonTargetMachine
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  DOTGraphTraits< MSchedGraph * >
struct  MSNodeAttributes
class  ModuloSchedulingPass
struct  MSchedGraphEdge
class  MSchedGraphNode
class  MSchedGraphNodeIterator
class  MSchedGraph
struct  GraphTraits< MSchedGraph * >
struct  GraphTraits< const MSchedGraph * >
struct  GraphTraits< Inverse< MSchedGraph * > >
struct  GraphTraits< Inverse< const MSchedGraph * > >
class  MSSchedule
struct  AllocInfo
class  IGNode
class  InterferenceGraph
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  X86AddressMode
class  X86InstrInfo
class  X86JITInfo
struct  X86RegisterInfo
class  X86TargetMachine
struct  compare_nodes
class  Node
class  Edge
struct  graphListElement
struct  BBSort
struct  NodeListSort
struct  EdgeCompare2
class  Graph
class  getEdgeCode
struct  ProfilePaths
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
class  PassManagerT
class  PassManagerTraits< BasicBlock >
class  PassManagerTraits< Function >
class  PassManagerTraits< Module >
struct  GraphTraits< TypePromotionGraph >
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  cl
namespace  DataStructureAnalysis
namespace  dont_use
namespace  DOT
namespace  DS
namespace  ELF
namespace  Intrinsic
namespace  ISD
namespace  MVT
namespace  PatternMatch
namespace  PPC
namespace  PPCII
namespace  SparcV9
namespace  sys
namespace  V9
namespace  X86
namespace  X86II

Typedefs

typedef IntervalIterator<
BasicBlock, Function
function_interval_iterator
typedef IntervalIterator<
Interval, IntervalPartition
interval_part_interval_iterator
typedef short MachineOpCode
typedef int ResourceId
typedef ReducedValue< int,
ISD::FrameIndex_i32_Slot > 
ReducedValue_FrameIndex_i32
typedef ReducedValue< int,
ISD::FrameIndex_i64_Slot > 
ReducedValue_FrameIndex_i64
typedef ReducedValue< MachineBasicBlock *,
ISD::BasicBlock_i32_Slot > 
ReducedValue_BasicBlock_i32
typedef ReducedValue< MachineBasicBlock *,
ISD::BasicBlock_i64_Slot > 
ReducedValue_BasicBlock_i64
typedef ReducedValue< bool,
ISD::Constant_i1_Slot > 
ReducedValue_Constant_i1
typedef ReducedValue< unsigned
char, ISD::Constant_i8_Slot > 
ReducedValue_Constant_i8
typedef ReducedValue< unsigned
short, ISD::Constant_i16_Slot > 
ReducedValue_Constant_i16
typedef ReducedValue< unsigned,
ISD::Constant_i32_Slot > 
ReducedValue_Constant_i32
typedef ReducedValue< uint64_t,
ISD::Constant_i64_Slot > 
ReducedValue_Constant_i64
typedef ReducedValue< float,
ISD::Constant_f32_Slot > 
ReducedValue_Constant_f32
typedef ReducedValue< double,
ISD::Constant_f64_Slot > 
ReducedValue_Constant_f64
typedef std::set< const Value * > ValueSet
typedef uintptr_t PointerTy
typedef std::vector< std::pair<
std::string, bool > > 
LinkItemList
 A list of string/bool pairs.
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 unsigned InstrSchedClass
typedef long long cycles_t
typedef unsigned resourceId_t
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 hash_map< const Value *,
LiveRange * > 
LiveRangeMapType
typedef std::map< BasicBlock *,
BasicBlock * > 
BBMap
typedef std::map< const Value *,
const Type * > 
ValueTypeCache
typedef std::map< const Value *,
Value * > 
ValueMapTy

Enumerations

enum  SCEVTypes {
  scConstant, scTruncate, scZeroExtend, scAddExpr,
  scMulExpr, scUDivExpr, scAddRecExpr, scUnknown,
  scCouldNotCompute
}
enum  VerifierFailureAction { AbortProcessAction, ThrowExceptionAction, PrintMessageAction, ReturnStatusAction }
 An enumeration to specify the action to be taken if errors found. More...
enum  DependenceType {
  NoDependence = 0x0, TrueDependence = 0x1, AntiDependence = 0x2, OutputDependence = 0x4,
  ControlDependence = 0x8, IncomingFlag = 0x10
}
enum  PDGIteratorFlags {
  MemoryDeps = 0x1, SSADeps = 0x2, ControlDeps = 0x0, AllDataDeps = MemoryDeps | SSADeps,
  AllDeps = MemoryDeps | SSADeps | ControlDeps
}
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  X86VectorEnum { NoSSE, SSE, SSE2, SSE3 }
enum  Color { WHITE, GREY, BLACK }
enum  Color { WHITE, GREY, BLACK }
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< T > df_begin (T G)
template<class T>
df_iterator< T > df_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< T > idf_begin (T G)
template<class T>
idf_iterator< T > idf_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< T > po_begin (T G)
template<class T>
po_iterator< T > po_end (T G)
template<class T>
ipo_iterator< T > ipo_begin (T G, bool Reverse=false)
template<class T>
ipo_iterator< T > ipo_end (T G)
template<class T>
scc_iterator< T > scc_begin (T G)
template<class T>
scc_iterator< T > scc_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<class InputIt, class Function>
bool apply_until (InputIt First, InputIt Last, Function Func)
template<class InputIt, class Function, class ValueType>
ValueType reduce (InputIt First, InputIt Last, Function Func, ValueType Value)
template<class InputIt, class Function, class ValueType, class TransFunc>
ValueType reduce_apply (InputIt First, InputIt Last, Function Func, ValueType Value, TransFunc XForm)
template<class InputIt, class Function>
bool reduce_apply_bool (InputIt First, InputIt Last, Function Func)
template<class InIt, class OutIt, class Functor>
OutIt mapto (InIt Begin, InIt End, OutIt Dest, Functor F)
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)
std::string getToken (std::string &Source, const char *Delimiters=" \t\n\v\f\r")
template<typename T>
std::vector< T > make_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)
FunctionPasscreateCFGPrinterPass ()
FunctionPasscreateCFGOnlyPrinterPass ()
constant_iterator constant_begin (const Function *F)
constant_iterator constant_end (const Function *F)
static DSNodedereference (DSNode *N)
static const DSNodedereferenceC (const DSNode *N)
ExprType ClassifyExpr (Value *Expr)
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)
interval_part_interval_iterator intervals_begin (IntervalPartition &IP, bool DeleteIntervals=true)
interval_part_interval_iterator intervals_end (IntervalPartition &IP)
FunctionPasscreateLoadValueNumberingPass ()
PasscreateGlobalsModRefPass ()
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)
ModuleParseAssemblyFile (const std::string &Filename)
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 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 ()
FunctionPasscreateIterativeScanRegisterAllocator ()
FunctionPasscreatePrologEpilogCodeInserter ()
FunctionPasscreateBranchFoldingPass ()
FunctionPasscreateMachineCodeDeleter ()
FunctionPassgetRegisterAllocator (TargetMachine &T)
FunctionPasscreateModuloSchedulingPass (TargetMachine &targ)
std::ostream & operator<< (std::ostream &os, const SchedGraphNodeCommon &node)
std::ostream & operator<< (std::ostream &os, const SchedGraphEdge &edge)
std::ostream & operator<< (std::ostream &out, RAV Val)
void printSet (const ValueSet &S)
unsigned GetPageSize ()
GenericValue PTOGV (void *P)
void * GVTOP (const GenericValue &GV)
ModuleLinkItems (const char *progname, const LinkItemList &Items, const std::vector< std::string > &LibPaths, bool Verbose, bool Native)
void BuildLinkItems (LinkItemList &OutList, const cl::list< std::string > &Files, const cl::list< std::string > &Libs)
bool LinkModules (Module *Dest, Module *Src, std::string *ErrorMsg)
 Link two modules together.
bool LinkFiles (const char *progname, Module *HeadModule, const std::vector< std::string > &Files, bool Verbose)
bool LinkInArchive (Module *HeadModule, const std::string &Filename, std::string *ErrorMsg, bool Verbose)
 Link in one archive.
void LinkLibraries (const char *progname, Module *HeadModule, const std::vector< std::string > &Libraries, const std::vector< std::string > &LibPaths, bool Verbose, bool Native)
 Link libraries into a module.
void GetAllDefinedSymbols (Module *M, std::set< std::string > &DefinedSymbols)
void GetAllUndefinedSymbols (Module *M, std::set< std::string > &UndefinedSymbols)
std::string FindLib (const std::string &Filename, const std::vector< std::string > &Paths, bool SharedObjectOnly=false)
std::ostream & operator<< (std::ostream &O, const Module *M)
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)
bool CheckMagic (const std::string &FN, const std::string &Magic)
bool IsArchive (const std::string &FN)
bool IsBytecode (const std::string &FN)
bool IsSharedObject (const std::string &FN)
bool FileOpenable (const std::string &Filename)
bool DiffFiles (const std::string &FileA, const std::string &FileB, std::string *Error=0)
bool CopyFile (const std::string &Dest, const std::string &Src)
void MoveFileOverIfUpdated (const std::string &New, const std::string &Old)
void removeFile (const std::string &Filename)
std::string getUniqueFilename (const std::string &FilenameBase)
bool MakeFileExecutable (const std::string &Filename)
bool MakeFileReadable (const std::string &Filename)
long long getFileSize (const std::string &Filename)
unsigned long long getFileTimestamp (const std::string &Filename)
void * ReadFileIntoAddressSpace (const std::string &Filename, unsigned &Length)
void UnmapFileFromAddressSpace (void *Buffer, unsigned Length)
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(32
AllocaInst PHINode CallInst
VANextInst 
HANDLE_OTHER_INST (33, VAArg, VAArgInst) HANDLE_OTHER_INST(34
AllocaInst PHINode CallInst
VANextInst SelectInst 
HANDLE_OTHER_INST (35, UserOp1, Instruction) class TerminatorInst
unsigned log2 (uint64_t C)
unsigned log2 (unsigned C)
bool isPowerOf2 (int64_t C, unsigned &getPow)
int IsNAN (float f)
int IsNAN (double d)
int IsInf (float f)
int IsInf (double d)
bool isExecutableFile (const std::string &ExeFileName)
bool isStandardOutAConsole ()
std::string FindExecutable (const std::string &ExeName, const std::string &ProgramPath)
int RunProgramWithTimeout (const std::string &ProgramPath, const char **Args, const std::string &StdInFile="", const std::string &StdOutFile="", const std::string &StdErrFile="", unsigned NumSeconds=0)
int ExecWait (const char *const argv[], const char *const envp[])
void * AllocateRWXMemory (unsigned NumBytes)
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)
ModulePasscreateLoopInstrumentationPass ()
FunctionPasscreateCombineBranchesPass ()
FunctionPasscreateEmitFunctionTablePass ()
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 ()
ModulePasscreateDeadArgEliminationPass ()
ModulePasscreateDeadArgHackingPass ()
ModulePasscreateArgumentPromotionPass ()
ModulePasscreateIPConstantPropagationPass ()
ModulePasscreateSingleLoopExtractorPass ()
ModulePasscreateBlockExtractorPass (std::vector< BasicBlock * > &BTNE)
FunctionPasscreateRaisePointerReferencesPass ()
FunctionPasscreateConstantPropagationPass ()
FunctionPasscreateSCCPPass ()
FunctionPasscreateDeadInstEliminationPass ()
FunctionPasscreateDeadCodeEliminationPass ()
FunctionPasscreateDeadStoreEliminationPass ()
FunctionPasscreateAggressiveDCEPass ()
FunctionPasscreateScalarReplAggregatesPass ()
FunctionPasscreateGCSEPass ()
FunctionPasscreateIndVarSimplifyPass ()
FunctionPasscreateInstructionCombiningPass ()
FunctionPasscreateLICMPass ()
FunctionPasscreateLoopStrengthReducePass ()
FunctionPasscreateLoopUnswitchPass ()
FunctionPasscreateLoopUnrollPass ()
FunctionPasscreatePromoteMemoryToRegister ()
FunctionPasscreateReassociatePass ()
FunctionPasscreateCorrelatedExpressionEliminationPass ()
FunctionPasscreateTailDuplicationPass ()
FunctionPasscreateCFGSimplificationPass ()
FunctionPasscreateBreakCriticalEdgesPass ()
FunctionPasscreateLoopSimplifyPass ()
FunctionPasscreateTailCallEliminationPass ()
FunctionPasscreateLowerAllocationsPass ()
FunctionPasscreateLowerSwitchPass ()
FunctionPasscreateLowerSelectPass (bool OnlyFP=false)
FunctionPasscreateLowerPackedPass ()
FunctionPasscreateLowerInvokePass ()
FunctionPasscreateLowerGCPass ()
FunctionPasscreateLowerConstantExpressionsPass ()
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)
ModuleCloneModule (const Module *M)
BasicBlockCloneBasicBlock (const BasicBlock *BB, std::map< const Value *, Value * > &ValueMap, const char *NameSuffix="", Function *F=0)
FunctionCloneFunction (const Function *F, std::map< const Value *, Value * > &ValueMap)
FunctionCloneFunction (const Function *F)
void CloneFunctionInto (Function *NewFunc, const Function *OldFunc, std::map< const Value *, Value * > &ValueMap, std::vector< ReturnInst * > &Returns, const char *NameSuffix="")
void CloneTraceInto (Function *NewFunc, Trace &T, std::map< const Value *, Value * > &ValueMap, const char *NameSuffix)
bool InlineFunction (CallInst *C)
bool InlineFunction (InvokeInst *II)
bool InlineFunction (CallSite CS)
std::vector< BasicBlock * > CloneTrace (const std::vector< BasicBlock * > &origTrace)
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)
bool canConstantFoldCallTo (Function *F)
ConstantConstantFoldCall (Function *F, const std::vector< Constant * > &Operands)
bool isInstructionTriviallyDead (Instruction *I)
bool dceInstruction (BasicBlock::iterator &BBI)
ValuehasConstantValue (PHINode *PN)
bool SimplifyCFG (BasicBlock *BB)
AllocaInstDemoteRegToStack (Instruction &X)
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< 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)
void BasicAAStub ()
void BasicAAStub ()
FunctionPasscreateCFGPrinterPass ()
FunctionPasscreateCFGOnlyPrinterPass ()
static RegisterAnalysis< MemoryDepAnalysisZ ("memdep","Memory Dependence Analysis")
static RegisterAnalysis< PgmDependenceGraphZ ("pgmdep","Enumerate Program Dependence Graph (data and control)")
ExprType ClassifyExpr (Value *Expr)
 HANDLE_MEMORY_INST (21, Malloc, MallocInst) HANDLE_MEMORY_INST(23
AllocaInst HANDLE_MEMORY_INST (24, Load, LoadInst) HANDLE_OTHER_INST(27
AllocaInst PHINode HANDLE_OTHER_INST (28, Cast, CastInst) HANDLE_OTHER_INST(29
AllocaInst PHINode CallInst HANDLE_OTHER_INST (30, Shl, ShiftInst) HANDLE_OTHER_INST(32
AllocaInst PHINode CallInst
VANextInst 
HANDLE_OTHER_INST (33, VAArg, VAArgInst) HANDLE_OTHER_INST(34
AllocaInst PHINode CallInst
VANextInst SelectInst 
HANDLE_OTHER_INST (35, UserOp1, Instruction) class InstCount
static RegisterAnalysis< IntervalPartitionX ("intervals","Interval Partition Construction", true)
PasscreateGlobalsModRefPass ()
FunctionPasscreateLoadValueNumberingPass ()
PasscreateProfileLoaderPass (const std::string &Filename)
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)
ModuleParseAssemblyFile (const std::string &Filename)
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)
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)
std::ostream & operator<< (std::ostream &os, const LiveInterval &li)
bool operator< (unsigned V, const LiveRange &LR)
FunctionPasscreateMachineFunctionPrinterPass (std::ostream *OS, const std::string &Banner)
FunctionPasscreateMachineCodeDeleter ()
FunctionPasscreateRegisterAllocator ()
FunctionPasscreatePrologEpilogCodeInserter ()
FunctionPasscreateIterativeScanRegisterAllocator ()
FunctionPasscreateLinearScanRegisterAllocator ()
FunctionPasscreateLocalRegisterAllocator ()
FunctionPasscreateSimpleRegisterAllocator ()
FunctionPasscreateUnreachableBlockEliminationPass ()
llvm::SpillercreateSpiller ()
std::ostream & operator<< (std::ostream &OS, const VirtRegMap &VRM)
std::string FindLib (const std::string &Filename, const std::vector< std::string > &Paths, bool SharedObjectOnly)
void GetAllDefinedSymbols (Module *M, std::set< std::string > &DefinedSymbols)
void GetAllUndefinedSymbols (Module *M, std::set< std::string > &UndefinedSymbols)
bool LinkInArchive (Module *M, const std::string &Filename, std::string *ErrorMessage, bool Verbose)
 Link in one archive.
bool LinkFiles (const char *progname, Module *HeadModule, const std::vector< std::string > &Files, bool Verbose)
void LinkLibraries (const char *progname, Module *HeadModule, const std::vector< std::string > &Libraries, const std::vector< std::string > &LibPaths, bool Verbose, bool Native)
 Link libraries into a module.
ModuleLinkItems (const char *progname, const LinkItemList &Items, const std::vector< std::string > &LibPaths, bool Verbose, bool Native)
void BuildLinkItems (LinkItemList &Items, const cl::list< std::string > &Files, const cl::list< std::string > &Libraries)
bool LinkModules (Module *Dest, Module *Src, std::string *ErrorMsg)
 Link two modules together.
bool isCurrentDebugType (const char *DebugType)
bool CheckMagic (const std::string &FN, const std::string &Magic)
bool IsArchive (const std::string &FN)
bool IsBytecode (const std::string &FN)
bool IsSharedObject (const std::string &FN)
bool FileOpenable (const std::string &Filename)
bool DiffFiles (const std::string &FileA, const std::string &FileB, std::string *Error)
bool CopyFile (const std::string &Dest, const std::string &Src)
void MoveFileOverIfUpdated (const std::string &New, const std::string &Old)
void removeFile (const std::string &Filename)
std::string getUniqueFilename (const std::string &FilenameBase)
bool MakeFileExecutable (const std::string &Filename)
bool MakeFileReadable (const std::string &Filename)
long long getFileSize (const std::string &Filename)
unsigned long long getFileTimestamp (const std::string &Filename)
void * ReadFileIntoAddressSpace (const std::string &Filename, unsigned &Length)
void UnmapFileFromAddressSpace (void *Buffer, unsigned Length)
std::ostream * GetLibSupportInfoOutputFile ()
std::string getToken (std::string &Source, const char *Delimiters)
bool isExecutableFile (const std::string &ExeFileName)
bool isStandardOutAConsole ()
std::string FindExecutable (const std::string &ExeName, const std::string &ProgramPath)
int RunProgramWithTimeout (const std::string &ProgramPath, const char **Args, const std::string &StdInFile, const std::string &StdOutFile, const std::string &StdErrFile, unsigned NumSeconds)
int ExecWait (const char *const old_argv[], const char *const old_envp[])
void * AllocateRWXMemory (unsigned NumBytes)
std::ostream * GetLibSupportInfoOutputFile ()
static bool IsLibrary (Path &path, const std::string &basename)
unsigned GetPageSizeOnce ()
static void RegisterHandler ()
FunctionPasscreatePPCBranchSelectionPass ()
FunctionPasscreatePPC32ISelSimple (TargetMachine &TM)
FunctionPasscreatePPC64ISelSimple (TargetMachine &TM)
FunctionPasscreateDarwinAsmPrinter (std::ostream &OS, TargetMachine &TM)
FunctionPasscreateAIXAsmPrinter (std::ostream &OS, TargetMachine &TM)
FunctionPasscreateDarwinAsmPrinter (std::ostream &o, TargetMachine &tm)
FunctionPasscreateAIXAsmPrinter (std::ostream &o, TargetMachine &tm)
FunctionPasscreatePPCBranchSelectionPass ()
const MachineInstrBuilderaddFrameReference (const MachineInstrBuilder &MIB, int FI, int Offset=0, bool mem=true)
const MachineInstrBuilderaddConstantPoolReference (const MachineInstrBuilder &MIB, unsigned CPI, int Offset=0)
FunctionPasscreatePPC32ISelSimple (TargetMachine &TM)
FunctionPasscreatePPC64ISelSimple (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 cycles_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 RegisterAnalysis< FunctionLiveVarInfoX ("livevar","Live Variable Analysis")
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)
FunctionPasscreateModuloSchedulingPass (TargetMachine &targ)
std::ostream & operator<< (std::ostream &os, const MSchedGraphNode &node)
static MSchedGraphNodegetSecond (std::pair< const MachineInstr *const, MSchedGraphNode * > &Pair)
static std::ostream & operator<< (std::ostream &OS, AllocInfo &S)
static void assertIGNode (const InterferenceGraph *IG, const IGNode *Node)
bool InterferesWithColor (const LiveRange &LR, unsigned color)
bool InterfsPreventCoalescing (const LiveRange &LROfDef, const LiveRange &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, bool isSigned=false)
static void CreateSETSWConst (int32_t C, Instruction *dest, std::vector< MachineInstr * > &mvec)
static void CreateSETXConst (uint64_t C, Instruction *tmpReg, Instruction *dest, std::vector< MachineInstr * > &mvec)
static void CreateSETUWLabel (Value *val, Instruction *dest, std::vector< MachineInstr * > &mvec)
static void CreateSETXLabel (Value *val, Instruction *tmpReg, Instruction *dest, std::vector< MachineInstr * > &mvec)
static void CreateUIntSetInstruction (uint64_t C, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
static void CreateIntSetInstruction (int64_t C, Instruction *dest, std::vector< MachineInstr * > &mvec, MachineCodeForInstruction &mcfi)
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 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 ()
FunctionPasscreateX86SimpleInstructionSelector (TargetMachine &TM)
FunctionPasscreateX86SSAPeepholeOptimizerPass ()
FunctionPasscreateX86PeepholeOptimizerPass ()
FunctionPasscreateX86FloatingPointKillerPass ()
FunctionPasscreateX86FloatingPointStackifierPass ()
FunctionPasscreateX86CodePrinterPass (std::ostream &o, TargetMachine &tm)
FunctionPasscreateEmitX86CodeToMemory ()
FunctionPasscreateX86CodePrinterPass (std::ostream &o, TargetMachine &tm)
FunctionPasscreateX86FloatingPointStackifierPass ()
const MachineInstrBuilderaddDirectMem (const MachineInstrBuilder &MIB, unsigned Reg)
const MachineInstrBuilderaddRegOffset (const MachineInstrBuilder &MIB, unsigned Reg, int Offset)
const MachineInstrBuilderaddFullAddress (const MachineInstrBuilder &MIB, const X86AddressMode &AM)
const MachineInstrBuilderaddFrameReference (const MachineInstrBuilder &MIB, int FI, int Offset=0)
FunctionPasscreateX86SimpleInstructionSelector (TargetMachine &TM)
FunctionPasscreateX86PeepholeOptimizerPass ()
FunctionPasscreateX86SSAPeepholeOptimizerPass ()
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)
RegisterOpt< EmitFunctionTable > X ("emitfuncs","Emit a function table for the reoptimizer")
static char doDFS (BasicBlock *node, std::map< BasicBlock *, Color > &color)
static char hasBackEdge (Function *F)
RegisterOpt< CombineBranches > X ("branch-combine","Multiple backedges going to same target are merged")
static void getTriggerCode (Module *M, BasicBlock *BB, int MethNo, Value *pathNo, Value *cnt, Instruction *rInst)
void insertInTopBB (BasicBlock *front, int k, Instruction *rVar, Value *threshold)
void insertBB (Edge ed, getEdgeCode *edgeCode, Instruction *rInst, Value *countInst, int numPaths, int Methno, Value *threshold)
const graphListElementfindNodeInList (const Graph::nodeList &NL, Node *N)
graphListElementfindNodeInList (Graph::nodeList &NL, Node *N)
static void printNode (Node *nd)
void printEdge (Edge ed)
void processGraph (Graph &g, Instruction *rInst, Value *countInst, std::vector< Edge > &be, std::vector< Edge > &stDummy, std::vector< Edge > &exDummy, int n, int MethNo, Value *threshold)
void printGraph (Graph &g)
void addDummyEdges (std::vector< Edge > &stDummy, std::vector< Edge > &exDummy, Graph &g, std::vector< Edge > &be)
int valueAssignmentToEdges (Graph &g, std::map< Node *, int > nodePriority, std::vector< Edge > &be)
void getBBtrace (std::vector< BasicBlock * > &vBB, int pathNo, Function *M)
static bool edgesEqual (Edge ed1, Edge ed2)
static void getChords (vector< Edge > &chords, Graph &g, Graph st)
static void removeTreeEdges (Graph &g, Graph &t)
int valueAssignmentToEdges (Graph &g, map< Node *, int > nodePriority, vector< Edge > &be)
static int inc_Dir (Edge e, Edge f)
static void inc_DFS (Graph &g, Graph &t, map< Edge, int, EdgeCompare2 > &Increment, int events, Node *v, Edge e)
static map< Edge, int, EdgeCompare2getEdgeIncrements (Graph &g, Graph &t, vector< Edge > &be)
static void getCodeInsertions (Graph &g, map< Edge, getEdgeCode *, EdgeCompare2 > &instr, vector< Edge > &chords, map< Edge, int, EdgeCompare2 > &edIncrements)
void addDummyEdges (vector< Edge > &stDummy, vector< Edge > &exDummy, Graph &g, vector< Edge > &be)
static void moveDummyCode (vector< Edge > &stDummy, vector< Edge > &exDummy, vector< Edge > &be, map< Edge, getEdgeCode *, EdgeCompare2 > &insertions, Graph &g)
void processGraph (Graph &g, Instruction *rInst, Value *countInst, vector< Edge > &be, vector< Edge > &stDummy, vector< Edge > &exDummy, int numPaths, int MethNo, Value *threshold)
RegisterOpt< InstLoops > X ("instloops","Instrument backedges for profiling")
static RegisterOpt< ProfilePathsX ("paths","Profile Paths")
static NodefindBB (std::vector< Node * > &st, BasicBlock *BB)
void getPathFrmNode (Node *n, vector< BasicBlock * > &vBB, int pathNo, Graph &g, vector< Edge > &stDummy, vector< Edge > &exDummy, vector< Edge > &be, double strand)
void getBBtrace (vector< BasicBlock * > &vBB, int pathNo, Function *M)
void InsertProfilingInitCall (Function *MainFn, const char *FnName, GlobalValue *Array)
void IncrementCounterInBlock (BasicBlock *BB, unsigned CounterNum, GlobalValue *CounterArray)
FunctionPasscreateTraceValuesPassForFunction ()
 Just trace functions.
FunctionPasscreateTraceValuesPassForBasicBlocks ()
 Trace BB's and functions.
ModulePasscreateArgumentPromotionPass ()
ModulePasscreateConstantMergePass ()
ModulePasscreateDeadArgEliminationPass ()
ModulePasscreateDeadArgHackingPass ()
ModulePasscreateDeadTypeEliminationPass ()
ModulePasscreateFunctionExtractionPass (Function *F, bool deleteFn)
ModulePasscreateFunctionResolvingPass ()
ModulePasscreateGlobalDCEPass ()
ModulePasscreateGlobalOptimizerPass ()
ModulePasscreateFunctionInliningPass ()
ModulePasscreateInternalizePass ()
ModulePasscreateIPConstantPropagationPass ()
ModulePasscreateSingleLoopExtractorPass ()
ModulePasscreateBlockExtractorPass (std::vector< BasicBlock * > &BTNE)
ModulePasscreateLowerSetJmpPass ()
ModulePasscreatePruneEHPass ()
ModulePasscreateRaiseAllocationsPass ()
ModulePasscreateStripSymbolsPass (bool OnlyDebugInfo)
FunctionPasscreateRaisePointerReferencesPass ()
FunctionPasscreateAggressiveDCEPass ()
FunctionPasscreateConstantPropagationPass ()
FunctionPasscreateCorrelatedExpressionEliminationPass ()
FunctionPasscreateDeadInstEliminationPass ()
FunctionPasscreateDeadCodeEliminationPass ()
FunctionPasscreateDeadStoreEliminationPass ()
FunctionPasscreateGCSEPass ()
FunctionPasscreateIndVarSimplifyPass ()
FunctionPasscreateInstructionCombiningPass ()
FunctionPasscreateLICMPass ()
FunctionPasscreateLoopSimplifyPass ()
FunctionPasscreateLoopStrengthReducePass ()
FunctionPasscreateLoopUnrollPass ()
FunctionPasscreateLowerAllocationsPass ()
FunctionPasscreateLowerGCPass ()
FunctionPasscreateLowerInvokePass ()
FunctionPasscreateLowerPackedPass ()
FunctionPasscreateLowerSelectPass (bool OnlyFP)
FunctionPasscreateLowerSwitchPass ()
FunctionPasscreatePromoteMemoryToRegister ()
FunctionPasscreateReassociatePass ()
FunctionPasscreateScalarReplAggregatesPass ()
FunctionPasscreateSCCPPass ()
FunctionPasscreateCFGSimplificationPass ()
FunctionPasscreateTailDuplicationPass ()
FunctionPasscreateTailCallEliminationPass ()
const TypegetStructOffsetType (const Type *Ty, unsigned &Offset, std::vector< Value * > &Indices, const TargetData &TD, bool StopEarly)
const TypeConvertibleToGEP (const Type *Ty, Value *OffsetVal, std::vector< Value * > &Indices, const TargetData &TD, BasicBlock::iterator *BI)
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)
void CloneFunctionInto (Function *NewFunc, const Function *OldFunc, std::map< const Value *, Value * > &ValueMap, std::vector< ReturnInst * > &Returns, const char *NameSuffix)
FunctionCloneFunction (const Function *F, std::map< const Value *, Value * > &ValueMap)
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 InlineFunction (CallInst *CI)
bool InlineFunction (InvokeInst *II)
bool InlineFunction (CallSite CS)
bool doConstantPropagation (BasicBlock::iterator &II)
ConstantConstantFoldInstruction (Instruction *I)
bool ConstantFoldTerminator (BasicBlock *BB)
bool canConstantFoldCallTo (Function *F)
ConstantConstantFoldCall (Function *F, const std::vector< Constant * > &Operands)
bool isInstructionTriviallyDead (Instruction *I)
bool dceInstruction (BasicBlock::iterator &BBI)
ValuehasConstantValue (PHINode *PN)
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)
ConstantConstantFoldCastInstruction (const Constant *V, const Type *DestTy)
ConstantConstantFoldSelectInstruction (const Constant *Cond, const Constant *V1, const Constant *V2)
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)
function_interval_iterator intervals_end (Function *)
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 VANext
AllocaInst PHINode CallInst
VANextInst 
Select
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 << 10
const unsigned M_STORE_FLAG = 1 << 12
const unsigned M_2_ADDR_FLAG = 1 << 15
const unsigned M_TERMINATOR_FLAG = 1 << 16
bool PrintMachineCode
bool NoFramePointerElim
static const cycles_t HUGE_LATENCY = ~((long long) 1 << (sizeof(cycles_t)-2))
static const cycles_t INVALID_LATENCY = -HUGE_LATENCY
const int MAX_NUM_SLOTS = 32
const int MAX_NUM_CYCLES = 32
const PassInfoBreakCriticalEdgesID = X.getPassInfo()
const PassInfoLoopSimplifyID = X.getPassInfo()
const PassInfoLowerInvokePassID = X.getPassInfo()
static RegisterAnalysis< IPModRefZ ("ipmodref","Interprocedural mod/ref analysis")
Statistic TotalInsts ("instcount","Number of instructions (of all types)")
Statistic TotalBlocks ("instcount","Number of basic blocks")
Statistic TotalFuncs ("instcount","Number of non-external functions")
RegisterAnalysis< InstCount > X ("instcount","Counts the various types of Instructions")
std::string CurFilename
const TargetInstrDescriptorTargetInstrDescriptors = 0
cl::opt< bool > AIX ("aix", cl::desc("Generate AIX/xcoff instead of Darwin/MachO"), cl::Hidden)
SchedDebugLevel_t SchedDebugLevel
static cl::opt< bool > EnableFillingDelaySlots ("sched-fill-delay-slots", 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]
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 MSLoops ("modulosched-schedLoops","Number of loops successfully modulo-scheduled")
Statistic IncreasedII ("modulosched-increasedII","Number of times we had to increase II")
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"))
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 []
llvm:: { ... } ::IRClass IRInstance
const unsigned FR []
llvm:: { ... } ::FRClass FRInstance
const unsigned ICCR []
llvm:: { ... } ::ICCRClass ICCRInstance
const unsigned FCCR []
llvm:: { ... } ::FCCRClass FCCRInstance
const unsigned SR []
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 MRegisterDesc RegisterDescriptors []
bool EmitMappingInfo = false
X86VectorEnum X86Vector = NoSSE
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

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

Declarations of data and functions created by BURG


Typedef Documentation

typedef const PassInfo* llvm::AnalysisID
 

Definition at line 48 of file Pass.h.

typedef std::map<BasicBlock *, BasicBlock *> llvm::BBMap [static]
 

Definition at line 38 of file InstLoops.cpp.

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 long long llvm::cycles_t
 

Definition at line 25 of file TargetSchedInfo.h.

typedef IntervalIterator<BasicBlock, Function> llvm::function_interval_iterator
 

Definition at line 235 of file IntervalIterator.h.

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

Definition at line 77 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 unsigned llvm::InstrSchedClass
 

Definition at line 38 of file TargetInstrInfo.h.

typedef IntervalIterator<Interval, IntervalPartition> llvm::interval_part_interval_iterator
 

Definition at line 236 of file IntervalIterator.h.

typedef std::vector<std::pair<std::string,bool> > llvm::LinkItemList
 

A list of string/bool pairs.

This type is used to pass the linkage items (libraries and files) to the LinkItems function. It is composed of string/bool pairs. The string provides the name of the file or library (as with the -l option). The bool should be true for libraries, false for files, signifying "isLibrary".

Definition at line 24 of file Linker.h.

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

Definition at line 41 of file LiveRangeInfo.h.

typedef short llvm::MachineOpCode
 

Definition at line 32 of file MachineInstr.h.

typedef uintptr_t llvm::PointerTy
 

Definition at line 22 of file GenericValue.h.

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

Definition at line 76 of file CFG.h.

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

Definition at line 74 of file CFG.h.

typedef ReducedValue<MachineBasicBlock*, ISD::BasicBlock_i32_Slot > llvm::ReducedValue_BasicBlock_i32
 

Definition at line 357 of file SelectionDAG.h.

typedef ReducedValue<MachineBasicBlock*, ISD::BasicBlock_i64_Slot > llvm::ReducedValue_BasicBlock_i64
 

Definition at line 358 of file SelectionDAG.h.

typedef ReducedValue<float , ISD::Constant_f32_Slot> llvm::ReducedValue_Constant_f32
 

Definition at line 365 of file SelectionDAG.h.

typedef ReducedValue<double , ISD::Constant_f64_Slot> llvm::ReducedValue_Constant_f64
 

Definition at line 366 of file SelectionDAG.h.

typedef ReducedValue<bool , ISD::Constant_i1_Slot > llvm::ReducedValue_Constant_i1
 

Definition at line 360 of file SelectionDAG.h.

typedef ReducedValue<unsigned short, ISD::Constant_i16_Slot> llvm::ReducedValue_Constant_i16
 

Definition at line 362 of file SelectionDAG.h.

typedef ReducedValue<unsigned , ISD::Constant_i32_Slot> llvm::ReducedValue_Constant_i32
 

Definition at line 363 of file SelectionDAG.h.

typedef ReducedValue<uint64_t , ISD::Constant_i64_Slot> llvm::ReducedValue_Constant_i64
 

Definition at line 364 of file SelectionDAG.h.

typedef ReducedValue<unsigned char , ISD::Constant_i8_Slot > llvm::ReducedValue_Constant_i8
 

Definition at line 361 of file SelectionDAG.h.

typedef ReducedValue<int, ISD::FrameIndex_i32_Slot > llvm::ReducedValue_FrameIndex_i32
 

Definition at line 355 of file SelectionDAG.h.

typedef ReducedValue<int, ISD::FrameIndex_i64_Slot > llvm::ReducedValue_FrameIndex_i64
 

Definition at line 356 of file SelectionDAG.h.

typedef int llvm::ResourceId
 

Definition at line 25 of file SchedGraphCommon.h.

typedef unsigned llvm::resourceId_t
 

Definition at line 39 of file TargetSchedInfo.h.

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

Definition at line 191 of file SchedGraph.h.

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

Definition at line 189 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 SGSuccIterator<SchedGraphNode, SchedGraphEdge, SchedGraphNode::iterator> llvm::sg_succ_iterator
 

Definition at line 212 of file SchedGraph.h.

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

Definition at line 140 of file CFG.h.

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

Definition at line 138 of file CFG.h.

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

Definition at line 22 of file ValueMapper.h.

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

Definition at line 64 of file Interpreter.h.

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

Definition at line 34 of file ValueSet.h.

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

Definition at line 91 of file TransformInternals.h.


Enumeration Type Documentation

anonymous enum
 

Enumerator:
BadRegClass 

Definition at line 35 of file SparcV9RegInfo.cpp.

enum llvm::Color
 

Enumerator:
WHITE 
GREY 
BLACK 

Definition at line 31 of file InstLoops.cpp.

enum llvm::Color
 

Enumerator:
WHITE 
GREY 
BLACK 

Definition at line 189 of file Graph.h.

enum llvm::DependenceType
 

enum DependenceType - The standard data dependence types

Enumerator:
NoDependence 
TrueDependence 
AntiDependence 
OutputDependence 
ControlDependence 
IncomingFlag 

Definition at line 44 of file DependenceGraph.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::PassDebugLevel
 

Enumerator:
None 
Arguments 
Structure 
Executions 
Details 

Definition at line 42 of file PassManagerT.h.

enum llvm::PDGIteratorFlags
 

enum PDGIteratorFlags - specify which dependences incident on a statement are to be enumerated: Memory deps, SSA deps, Control deps, or any combination thereof.

Enumerator:
MemoryDeps 
SSADeps 
ControlDeps 
AllDataDeps 
AllDeps 

Definition at line 59 of file PgmDependenceGraph.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::SCEVTypes
 

Enumerator:
scConstant 
scTruncate 
scZeroExtend 
scAddExpr 
scMulExpr 
scUDivExpr 
scAddRecExpr 
scUnknown 
scCouldNotCompute 

Definition at line 23 of file ScalarEvolutionExpressions.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::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 34 of file SparcV9Internals.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.

enum llvm::X86VectorEnum
 

Enumerator:
NoSSE 
SSE 
SSE2 
SSE3 

Definition at line 26 of file X86.h.


Function Documentation

static void llvm::Add3OperandInstr unsigned  Opcode,
InstructionNode Node,
std::vector< MachineInstr * > &  mvec
[inline, static]
 

Definition at line 1579 of file SparcV9BurgISel.cpp.

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 48 of file PowerPCInstrBuilder.h.

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

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 59 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addReg(), llvm::MachineInstrBuilder::addSImm(), and llvm::MachineInstrBuilder::addZImm().

void llvm::addDummyEdges vector< Edge > &  stDummy,
vector< Edge > &  exDummy,
Graph &  g,
vector< Edge > &  be
 

Definition at line 390 of file GraphAuxiliary.cpp.

References llvm::Graph::addEdgeForce(), first, llvm::Graph::getExit(), llvm::Edge::getFirst(), llvm::Edge::getRandId(), llvm::Graph::getRoot(), llvm::Edge::getSecond(), llvm::Edge::getWeight(), llvm::Graph::removeEdge(), and second.

void llvm::addDummyEdges std::vector< Edge > &  stDummy,
std::vector< Edge > &  exDummy,
Graph &  g,
std::vector< Edge > &  be
 

Referenced by getBBtrace(), and llvm::ProfilePaths::runOnFunction().

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 99 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addFrameIndex(), llvm::MachineInstrBuilder::addReg(), llvm::MachineInstrBuilder::addSImm(), and llvm::MachineInstrBuilder::addZImm().

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 33 of file PowerPCInstrBuilder.h.

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

Referenced by llvm::X86RegisterInfo::loadRegFromStackSlot(), llvm::PPC64RegisterInfo::loadRegFromStackSlot(), llvm::PPC32RegisterInfo::loadRegFromStackSlot(), MakeMIInst(), MakeMInst(), MakeMRIInst(), MakeMRInst(), MakeRMIInst(), MakeRMInst(), llvm::X86RegisterInfo::storeRegToStackSlot(), llvm::PPC64RegisterInfo::storeRegToStackSlot(), and llvm::PPC32RegisterInfo::storeRegToStackSlot().

const MachineInstrBuilder& llvm::addFullAddress const MachineInstrBuilder &  MIB,
const X86AddressMode &  AM
[inline]
 

Definition at line 76 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::FrameIndexBase, llvm::X86AddressMode::GV, llvm::X86AddressMode::IndexReg, llvm::X86AddressMode::RegBase, and llvm::X86AddressMode::Scale.

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

Definition at line 79 of file IntervalIterator.h.

References llvm::Interval::Nodes.

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

Definition at line 68 of file IntervalIterator.h.

References llvm::Interval::Nodes.

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 71 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addReg(), llvm::MachineInstrBuilder::addSImm(), and llvm::MachineInstrBuilder::addZImm().

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

void* llvm::AllocateRWXMemory unsigned  NumBytes  ) 
 

AllocateRWXMemory - Allocate a slab of memory with read/write/execute permissions. This is typically used for JIT applications where we want to emit code to the memory then jump to it. Getting this type of memory is very OS specific.

Definition at line 295 of file SystemUtils.cpp.

References abort(), and GetPageSize().

void* llvm::AllocateRWXMemory unsigned  NumBytes  ) 
 

AllocateRWXMemory - Allocate a slab of memory with read/write/execute permissions. This is typically used for JIT applications where we want to emit code to the memory then jump to it. Getting this type of memory is very OS specific.

Definition at line 295 of file SystemUtils.cpp.

References abort(), and GetPageSize().

bool llvm::AllUsesAreBranches const Instruction I  )  [inline]
 

AllUsesAreBranches - Returns true if all the uses of I are Branch instructions, false otherwise.

Definition at line 2786 of file SparcV9BurgISel.cpp.

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 314 of file ReaderWrappers.cpp.

References createBytecodeAnalyzerHandler(), and getBytecodeBufferModuleProvider().

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 314 of file ReaderWrappers.cpp.

References createBytecodeAnalyzerHandler(), and getBytecodeBufferModuleProvider().

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 295 of file ReaderWrappers.cpp.

References createBytecodeAnalyzerHandler(), and 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  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 295 of file ReaderWrappers.cpp.

References createBytecodeAnalyzerHandler(), and getBytecodeModuleProvider().

void llvm::AppendInstructions std::vector< MachineInstr * > &  IAft,
MachineBasicBlock &  MBB,
MachineBasicBlock::iterator &  MII,
const std::string &  msg
[inline]
 

Definition at line 368 of file PhyRegAlloc.cpp.

References InsertAfter().

template<class InputIt, class Function>
bool llvm::apply_until InputIt  First,
InputIt  Last,
Function  Func
 

Definition at line 200 of file STLExtras.h.

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().

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 llvm::IGNode::getIndex().

Referenced by llvm::InterferenceGraph::getInterference(), llvm::InterferenceGraph::mergeIGNodesOfLRs(), and llvm::InterferenceGraph::setInterference().

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

Definition at line 568 of file InstrScheduling.cpp.

Referenced by ChooseOneGroup().

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

Definition at line 812 of file Lexer.cpp.

References ThrowException().

void llvm::BasicAAStub  ) 
 

Definition at line 29 of file BasicAliasAnalysis.cpp.

void llvm::BasicAAStub  ) 
 

Definition at line 29 of file BasicAliasAnalysis.cpp.

void llvm::BasicAAStub  ) 
 

Definition at line 29 of file BasicAliasAnalysis.cpp.

void llvm::BasicValueNumberingStub  ) 
 

Definition at line 198 of file ValueNumbering.cpp.

void llvm::BasicValueNumberingStub  ) 
 

Definition at line 198 of file ValueNumbering.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 2160 of file SparcV9BurgISel.cpp.

void llvm::BuildLinkItems LinkItemList OutList,
const cl::list< std::string > &  Files,
const cl::list< std::string > &  Libs
 

This function provides some utility for tools that need to build the list of link items from a triplet of command line options: Files, Libraries, and LibraryPaths. The command line ordering is preserved by this function even though the options are split into three separate cl::list<std::string>. The resulting OutList is suitable for use with LinkItems.

See also:
LinkItems
Exceptions:
nothing 
Parameters:
Files  List of files to put in list
Libraries  List of libraries to put in list

Definition at line 128 of file LinkItems.cpp.

References llvm::cl::list< DataType, Storage, ParserClass >::getPosition().

void llvm::BuildLinkItems LinkItemList OutList,
const cl::list< std::string > &  Files,
const cl::list< std::string > &  Libs
 

This function provides some utility for tools that need to build the list of link items from a triplet of command line options: Files, Libraries, and LibraryPaths. The command line ordering is preserved by this function even though the options are split into three separate cl::list<std::string>. The resulting OutList is suitable for use with LinkItems.

See also:
LinkItems
Exceptions:
nothing 
Parameters:
Files  List of files to put in list
Libs  List of libraries to put in list

Definition at line 128 of file LinkItems.cpp.

References llvm::cl::list< DataType, Storage, ParserClass >::getPosition().

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 201 of file MachineInstrBuilder.h.

References BuildMI(), and llvm::MachineBasicBlock::end().

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 190 of file MachineInstrBuilder.h.

References BuildMI(), and llvm::MachineBasicBlock::end().

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 178 of file MachineInstrBuilder.h.

References llvm::MachineBasicBlock::insert().

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 165 of file MachineInstrBuilder.h.

References llvm::MachineBasicBlock::insert().

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 151 of file MachineInstrBuilder.h.

References llvm::MachineInstrBuilder::addReg().

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 143 of file MachineInstrBuilder.h.

Referenced by BuildMI(), llvm::X86RegisterInfo::copyRegToReg(), llvm::PPC64RegisterInfo::copyRegToReg(), llvm::PPC32RegisterInfo::copyRegToReg(), llvm::SparcV9RegInfo::cpMem2RegMI(), llvm::SparcV9RegInfo::cpReg2MemMI(), llvm::SparcV9RegInfo::cpReg2RegMI(), llvm::SparcV9RegInfo::cpValue2Value(), llvm::X86RegisterInfo::eliminateCallFramePseudoInstr(), llvm::PPC64RegisterInfo::eliminateCallFramePseudoInstr(), llvm::PPC32RegisterInfo::eliminateCallFramePseudoInstr(), llvm::PPC64RegisterInfo::eliminateFrameIndex(), llvm::PPC32RegisterInfo::eliminateFrameIndex(), llvm::X86RegisterInfo::emitEpilogue(), llvm::PPC64RegisterInfo::emitEpilogue(), llvm::PPC32RegisterInfo::emitEpilogue(), llvm::X86RegisterInfo::emitPrologue(), llvm::PPC64RegisterInfo::emitPrologue(), llvm::PPC32RegisterInfo::emitPrologue(), llvm::X86InstrInfo::insertGoto(), llvm::X86RegisterInfo::loadRegFromStackSlot(), llvm::PPC64RegisterInfo::loadRegFromStackSlot(), llvm::PPC32RegisterInfo::loadRegFromStackSlot(), MakeMIInst(), MakeMInst(), MakeMRIInst(), MakeMRInst(), MakeRMIInst(), MakeRMInst(), llvm::X86InstrInfo::reverseBranchCondition(), llvm::X86RegisterInfo::storeRegToStackSlot(), llvm::PPC64RegisterInfo::storeRegToStackSlot(), and llvm::PPC32RegisterInfo::storeRegToStackSlot().

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

Definition at line 171 of file PassSupport.h.

bool llvm::canConstantFoldCallTo Function F  ) 
 

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

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

References llvm::Function::getIntrinsicID(), llvm::Value::getName(), and llvm::Intrinsic::isunordered.

Referenced by CanConstantFold(), and ConstantFoldInstruction().

bool llvm::canConstantFoldCallTo Function F  ) 
 

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

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

References llvm::Function::getIntrinsicID(), llvm::Value::getName(), and llvm::Intrinsic::isunordered.

Referenced by CanConstantFold(), and ConstantFoldInstruction().

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.

bool llvm::CheckMagic const std::string &  FN,
const std::string &  Magic
 

CheckMagic - Returns true IFF the file named FN begins with Magic. FN must name a readable file.

Definition at line 32 of file FileUtilities.cpp.

Referenced by IsArchive(), IsBytecode(), and IsSharedObject().

bool llvm::CheckMagic const std::string &  FN,
const std::string &  Magic
 

CheckMagic - Returns true IFF the file named FN begins with Magic. FN must name a readable file.

Definition at line 32 of file FileUtilities.cpp.

Referenced by IsArchive(), IsBytecode(), and IsSharedObject().

static MachineOpCode llvm::ChooseAddInstruction const InstructionNode instrNode  )  [inline, static]
 

Definition at line 2075 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseAddInstructionByType const Type resultType  )  [inline, static]
 

Definition at line 909 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseBccInstruction const InstructionNode instrNode,
const Type *&  setCCType
[inline, static]
 

Definition at line 1874 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseBFpccInstruction const InstructionNode instrNode,
const BinaryOperator setCCInstr
[inline, static]
 

Definition at line 1823 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseBpccInstruction const InstructionNode instrNode,
const BinaryOperator setCCInstr
[inline, static]
 

Definition at line 1787 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseBprInstruction const InstructionNode instrNode  )  [inline, static]
 

Definition at line 1764 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseConvertFPToIntInstr const TargetMachine target,
const Type destType,
const Type opType
[inline, static]
 

Definition at line 1989 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseConvertToFloatInstr const TargetMachine target,
OpLabel  vopCode,
const Type opType
[inline, static]
 

Definition at line 1962 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 2370 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseFcmpInstruction const InstructionNode instrNode  )  [inline, static]
 

Definition at line 2144 of file SparcV9BurgISel.cpp.

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(), ReplaceNopsWithUsefulInstr(), llvm::ISD::Ret, and llvm::MachineCodeForInstruction::size().

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 868 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 1894 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 1918 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 1945 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseMulInstructionByType const Type resultType  )  [inline, static]
 

Definition at line 2171 of file SparcV9BurgISel.cpp.

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

Definition at line 932 of file InstrScheduling.cpp.

References AssignInstructionsToSlots(), 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().

MachineOperand::MachineOperandType llvm::ChooseRegOrImmed Value val,
MachineOpCode  opCode,
const TargetMachine target,
bool  canUseImmed,
unsigned int &  getMachineRegNum,
int64_t &  getImmedValue
 

Definition at line 1360 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 1337 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 890 of file SparcV9BurgISel.cpp.

static MachineOpCode llvm::ChooseSubInstructionByType const Type resultType  )  [inline, static]
 

Definition at line 2107 of file SparcV9BurgISel.cpp.

ExprType llvm::ClassifyExpr Value Expr  ) 
 

ClassifyExpr - Analyze an expression to determine the complexity of the expression, and which other values it depends on.

Definition at line 246 of file Expressions.cpp.

References Add(), C, llvm::Instruction::Cast, ClassifyExpr(), llvm::ExprType::Constant, llvm::ExprType::ExprTy, llvm::ConstantExpr::getCast(), llvm::ExprType::getExprType(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::Value::getType(), getUnsignedConstant(), handleAddition(), I, llvm::Type::isFloatingPoint(), llvm::Type::isLosslesslyConvertibleTo(), Mul(), negate(), llvm::ExprType::Offset, llvm::ExprType::Scale, llvm::Instruction::Shl, llvm::Type::UByteTy, llvm::Type::ULongTy, and llvm::ExprType::Var.

Referenced by ClassifyExpr(), ConvertMallocToType(), and MallocConvertibleToType().

ExprType llvm::ClassifyExpr Value Expr  ) 
 

ClassifyExpr - Analyze an expression to determine the complexity of the expression, and which other values it depends on.

Definition at line 246 of file Expressions.cpp.

References Add(), C, llvm::Instruction::Cast, ClassifyExpr(), llvm::ExprType::Constant, llvm::ExprType::ExprTy, llvm::ConstantExpr::getCast(), llvm::ExprType::getExprType(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::Value::getType(), getUnsignedConstant(), handleAddition(), I, llvm::Type::isFloatingPoint(), llvm::Type::isLosslesslyConvertibleTo(), Mul(), negate(), llvm::ExprType::Offset, llvm::ExprType::Scale, llvm::Instruction::Shl, llvm::Type::UByteTy, llvm::Type::ULongTy, and llvm::ExprType::Var.

Referenced by ClassifyExpr(), ConvertMallocToType(), and MallocConvertibleToType().

BasicBlock* llvm::CloneBasicBlock const BasicBlock BB,
std::map< const Value *, Value * > &  ValueMap,
const char *  NameSuffix = "",
Function F = 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.

Definition at line 24 of file CloneFunction.cpp.

References llvm::ISD::BasicBlock, llvm::BasicBlock::begin(), llvm::BasicBlock::end(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::Value::hasName(), llvm::Instruction::setName(), and llvm::BasicBlock::setName().

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

BasicBlock* llvm::CloneBasicBlock const BasicBlock BB,
std::map< const Value *, Value * > &  ValueMap,
const char *  NameSuffix = "",
Function F = 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.

Definition at line 24 of file CloneFunction.cpp.

References llvm::ISD::BasicBlock, llvm::BasicBlock::begin(), llvm::BasicBlock::end(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::Value::hasName(), llvm::BasicBlock::setName(), and llvm::Instruction::setName().

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

Function* llvm::CloneFunction const Function F,
std::map< const Value *, Value * > &  ValueMap
 

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 91 of file CloneFunction.cpp.

References llvm::Function::abegin(), llvm::Function::aend(), CloneFunctionInto(), E, llvm::FunctionType::get(), llvm::Function::getFunctionType(), llvm::GlobalValue::getLinkage(), llvm::Value::getName(), llvm::FunctionType::getReturnType(), I, and llvm::FunctionType::isVarArg().

Referenced by CloneFunction().

Function* llvm::CloneFunction const Function *  F  )  [inline]
 

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

Definition at line 82 of file Cloning.h.

References CloneFunction().

Function* llvm::CloneFunction const Function F,
std::map< const Value *, Value * > &  ValueMap
 

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 91 of file CloneFunction.cpp.

References llvm::Function::abegin(), llvm::Function::aend(), CloneFunctionInto(), E, llvm::FunctionType::get(), llvm::Function::getFunctionType(), llvm::GlobalValue::getLinkage(), llvm::Value::getName(), llvm::FunctionType::getReturnType(), I, and llvm::FunctionType::isVarArg().

Referenced by CloneFunction().

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

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 45 of file CloneFunction.cpp.

References llvm::Function::abegin(), llvm::Function::aend(), llvm::Function::begin(), CloneBasicBlock(), E, llvm::Function::end(), llvm::BasicBlock::getTerminator(), I, and RemapInstruction().

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

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

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 45 of file CloneFunction.cpp.

References llvm::Function::abegin(), llvm::Function::aend(), llvm::Function::begin(), CloneBasicBlock(), E, llvm::Function::end(), llvm::BasicBlock::getTerminator(), I, and RemapInstruction().

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

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::Function::abegin(), llvm::Module::addTypeName(), llvm::Module::begin(), CloneFunctionInto(), E, llvm::Module::end(), llvm::GlobalValue::ExternalLinkage, F, llvm::Module::gbegin(), llvm::Module::gend(), llvm::Module::getEndianness(), llvm::Module::getModuleIdentifier(), llvm::Module::getPointerSize(), llvm::Module::getSymbolTable(), I, MapValue(), llvm::Module::setEndianness(), llvm::GlobalVariable::setInitializer(), llvm::GlobalValue::setLinkage(), llvm::Module::setPointerSize(), llvm::SymbolTable::type_begin(), and llvm::SymbolTable::type_end().

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::Function::abegin(), llvm::Module::addTypeName(), llvm::Module::begin(), CloneFunctionInto(), E, llvm::Module::end(), llvm::GlobalValue::ExternalLinkage, F, llvm::Module::gbegin(), llvm::Module::gend(), llvm::Module::getEndianness(), llvm::Module::getModuleIdentifier(), llvm::Module::getPointerSize(), llvm::Module::getSymbolTable(), I, MapValue(), llvm::Module::setEndianness(), llvm::GlobalVariable::setInitializer(), llvm::GlobalValue::setLinkage(), llvm::Module::setPointerSize(), llvm::SymbolTable::type_begin(), and llvm::SymbolTable::type_end().

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 llvm::BasicBlock::begin(), CloneBasicBlock(), E, llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), I, and V.

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 llvm::BasicBlock::begin(), CloneBasicBlock(), E, llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), I, and V.

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 llvm::Trace::begin(), CloneBasicBlock(), llvm::Function::end(), llvm::Trace::end(), llvm::Trace::getEntryBasicBlock(), and RemapInstruction().

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 llvm::Trace::begin(), CloneBasicBlock(), llvm::Trace::end(), llvm::Function::end(), llvm::Trace::getEntryBasicBlock(), and RemapInstruction().

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 2799 of file SparcV9BurgISel.cpp.

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().

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

Definition at line 84 of file ConstantsScanner.h.

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

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

Definition at line 88 of file ConstantsScanner.h.

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

Constant * llvm::ConstantFoldBinaryInstruction unsigned  Opcode,
const Constant V1,
const Constant V2
 

Definition at line 811 of file ConstantFolding.cpp.

References Add(), llvm::ISD::And, llvm::Type::BoolTy, C, llvm::Instruction::Cast, evaluateRelation(), llvm::ConstantBool::False, llvm::ConstantBool::get(), llvm::UndefValue::get(), llvm::ConstantExpr::get(), llvm::ConstantIntegral::getAllOnesValue(), llvm::Constant::getNullValue(), llvm::SetCondInst::getSwappedCondition(), llvm::Instruction::isRelational(), Mul(), llvm::ISD::Or, llvm::ISD::SetEQ, llvm::ISD::SetGE, llvm::ISD::SetGT, llvm::ISD::SetLE, llvm::ISD::SetLT, llvm::ISD::SetNE, llvm::Instruction::Shl, llvm::ConstantBool::True, and llvm::ISD::Xor.

Referenced by llvm::ConstantExpr::getShiftTy(), and llvm::ConstantExpr::getTy().

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 261 of file Transforms/Utils/Local.cpp.

References ConstantFoldFP(), llvm::ConstantBool::get(), llvm::ConstantFP::get(), llvm::Value::getName(), llvm::Function::getReturnType(), IsNAN(), and V.

Referenced by ConstantFold(), and ConstantFoldInstruction().

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 261 of file Transforms/Utils/Local.cpp.

References ConstantFoldFP(), llvm::ConstantFP::get(), llvm::ConstantBool::get(), llvm::Value::getName(), llvm::Function::getReturnType(), IsNAN(), and V.

Referenced by ConstantFold(), and ConstantFoldInstruction().

Constant * llvm::ConstantFoldCastInstruction const Constant V,
const Type DestTy
 

Definition at line 524 of file ConstantFolding.cpp.

References llvm::Type::BoolTy, llvm::Type::BoolTyID, llvm::Instruction::Cast, llvm::Type::DoubleTyID, llvm::Type::FloatTyID, llvm::UndefValue::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), getSize(), llvm::Value::getType(), llvm::Type::IntTy, llvm::Type::IntTyID, llvm::Type::isFloatingPoint(), llvm::Type::LongTyID, llvm::Type::PointerTyID, llvm::Type::SByteTyID, llvm::Type::ShortTyID, llvm::ConstantBool::True, llvm::Type::UByteTyID, llvm::Type::UIntTy, llvm::Type::UIntTyID, llvm::Type::ULongTyID, and llvm::Type::UShortTyID.

Referenced by llvm::ConstantExpr::getCast().

Constant * llvm::ConstantFoldGetElementPtr const Constant C,
const std::vector< Value * > &  IdxList
 

Definition at line 1023 of file ConstantFolding.cpp.

References Add(), 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::Type::getPrimitiveSize(), llvm::Value::getType(), I, llvm::Constant::isNullValue(), llvm::Type::LongTy, R, and llvm::Type::UIntTy.

Referenced by llvm::ConstantExpr::getGetElementPtrTy().

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 49 of file Transforms/Utils/Local.cpp.

References C, canConstantFoldCallTo(), llvm::Instruction::Cast, ConstantFoldCall(), F, llvm::ConstantExpr::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), llvm::ConstantExpr::getSelect(), llvm::Value::getType(), and llvm::Instruction::Select.

Referenced by ConstantPropUsersOf(), and doConstantPropagation().

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 49 of file Transforms/Utils/Local.cpp.

References C, canConstantFoldCallTo(), llvm::Instruction::Cast, ConstantFoldCall(), F, llvm::ConstantExpr::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), llvm::ConstantExpr::getSelect(), llvm::Value::getType(), and llvm::Instruction::Select.

Referenced by ConstantPropUsersOf(), and doConstantPropagation().

Constant * llvm::ConstantFoldSelectInstruction const Constant Cond,
const Constant V1,
const Constant V2
 

Definition at line 613 of file ConstantFolding.cpp.

References llvm::ConstantBool::False, and llvm::ConstantBool::True.

Referenced by llvm::ConstantExpr::getSelectTy().

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 119 of file Transforms/Utils/Local.cpp.

References llvm::BasicBlock::getInstList(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getTerminator(), llvm::BasicBlock::removePredecessor(), and llvm::ISD::SetEQ.

Referenced by MarkAliveBlocks(), and SimplifyCFG().

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 119 of file Transforms/Utils/Local.cpp.

References llvm::BasicBlock::getInstList(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getTerminator(), llvm::BasicBlock::removePredecessor(), and llvm::ISD::SetEQ.

Referenced by MarkAliveBlocks(), and SimplifyCFG().

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 842 of file SparcV9BurgISel.cpp.

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 C, llvm::Instruction::Cast, llvm::TargetMachine::getTargetData(), llvm::TargetData::getTypeSize(), llvm::Type::isIntegral(), llvm::Type::isSigned(), and U.

Value * llvm::ConvertExpressionToType Value V,
const Type Ty,
ValueMapCache VMC,
const TargetData TD
 

Definition at line 331 of file ExprTypeConvert.cpp.

References Add(), llvm::PHINode::addIncoming(), llvm::Instruction::Call, llvm::Instruction::Cast, ConvertibleToGEP(), ConvertMallocToType(), 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::Instruction::getOpcode(), llvm::Constant::getOperand(), llvm::User::getOperand(), llvm::Instruction::getParent(), llvm::GetElementPtrInst::getPointerOperand(), llvm::LoadInst::getPointerOperand(), llvm::GetElementPtrInst::getType(), llvm::Value::getType(), I, llvm::GetElementPtrInst::idx_begin(), llvm::GetElementPtrInst::idx_end(), llvm::Type::isFirstClassType(), llvm::FunctionType::isVarArg(), llvm::Instruction::Load, llvm::Instruction::Malloc, llvm::ValueMapCache::NewCasts, llvm::FunctionType::param_begin(), llvm::FunctionType::param_end(), llvm::Instruction::PHI, llvm::PHINode::removeIncomingValue(), llvm::Type::SByteTy, llvm::Instruction::setName(), llvm::User::setOperand(), llvm::Instruction::Shl, llvm::Value::use_begin(), llvm::Value::use_size(), and llvm::Type::VoidTy.

Referenced by ConvertOperandToType().

const Type * llvm::ConvertibleToGEP const Type Ty,
Value V,
std::vector< Value * > &  Indices,
const TargetData TD,
BasicBlock::iterator *  BI = 0
 

Definition at line 99 of file TransformInternals.cpp.

Referenced by ConvertExpressionToType(), ConvertOperandToType(), ExpressionConvertibleToType(), HandleCastToPointer(), OperandConvertibleToType(), and PeepholeOptimizeAddCast().

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 930 of file SparcV9BurgISel.cpp.

void llvm::ConvertValueToNewType Value V,
Value NewVal,
ValueMapCache VMC,
const TargetData TD
 

Definition at line 897 of file ExprTypeConvert.cpp.

References ConvertOperandToType(), llvm::Value::use_begin(), and llvm::Value::use_size().

Referenced by ConvertOperandToType().

bool llvm::CopyFile const std::string &  Dest,
const std::string &  Src
 

CopyFile - Copy the specified source file to the specified destination, overwriting destination if it exists. This returns true on failure.

Definition at line 118 of file FileUtilities.cpp.

References FR, and llvm::FileRemover::releaseFile().

bool llvm::CopyFile const std::string &  Dest,
const std::string &  Src
 

CopyFile - Copy the specified source file to the specified destination, overwriting destination if it exists. This returns true on failure.

Definition at line 118 of file FileUtilities.cpp.

References FR, and llvm::FileRemover::releaseFile().

static MachineInstr* llvm::CreateAddConstInstruction const InstructionNode instrNode  )  [inline, static]
 

Definition at line 2088 of file SparcV9BurgISel.cpp.

FunctionPass* llvm::createAggressiveDCEPass  ) 
 

Definition at line 109 of file ADCE.cpp.

FunctionPass* llvm::createAggressiveDCEPass  ) 
 

Definition at line 109 of file ADCE.cpp.

FunctionPass* llvm::createAIXAsmPrinter std::ostream &  o,
TargetMachine 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 305 of file PowerPCAsmPrinter.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly().

FunctionPass* llvm::createAIXAsmPrinter std::ostream &  o,
TargetMachine 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 305 of file PowerPCAsmPrinter.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly().

ModulePass* llvm::createArgumentPromotionPass  ) 
 

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

Definition at line 78 of file ArgumentPromotion.cpp.

ModulePass* llvm::createArgumentPromotionPass  ) 
 

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

Definition at line 78 of file ArgumentPromotion.cpp.

FunctionPass * llvm::createAsmPrinterPass std::ostream &  Out,
TargetMachine TM
 

Writes out assembly code for the module, one function at a time

Definition at line 788 of file SparcV9AsmPrinter.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 1206 of file SparcV9BurgISel.cpp.

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

Definition at line 153 of file LoopExtractor.cpp.

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

Definition at line 153 of file LoopExtractor.cpp.

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::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::createBreakCriticalEdgesPass  ) 
 

Definition at line 51 of file BreakCriticalEdges.cpp.

FunctionPass* llvm::createBreakCriticalEdgesPass  ) 
 

Definition at line 51 of file BreakCriticalEdges.cpp.

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

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

Definition at line 726 of file Analyzer.cpp.

Referenced by AnalyzeBytecodeBuffer(), and AnalyzeBytecodeFile().

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

getBytecodeAsmPrinterPass - Emits final LLVM bytecode to assembly file.

Definition at line 112 of file EmitBytecodeToAssembly.cpp.

FunctionPass* llvm::createCFGOnlyPrinterPass  ) 
 

Definition at line 179 of file CFGPrinter.cpp.

FunctionPass* llvm::createCFGOnlyPrinterPass  ) 
 

Definition at line 179 of file CFGPrinter.cpp.

FunctionPass* llvm::createCFGPrinterPass  ) 
 

Definition at line 175 of file CFGPrinter.cpp.

FunctionPass* llvm::createCFGPrinterPass  ) 
 

Definition at line 175 of file CFGPrinter.cpp.

FunctionPass* llvm::createCFGSimplificationPass  ) 
 

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

FunctionPass* llvm::createCFGSimplificationPass  ) 
 

Definition at line 42 of file Scalar/SimplifyCFG.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 2320 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 2573 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 2501 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 2031 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 1164 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 1266 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 1062 of file SparcV9BurgISel.cpp.

FunctionPass * llvm::createCombineBranchesPass  ) 
 

Definition at line 184 of file CombineBranch.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::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.

FunctionPass* llvm::createConstantPropagationPass  ) 
 

Definition at line 45 of file ConstantProp.cpp.

FunctionPass* llvm::createConstantPropagationPass  ) 
 

Definition at line 45 of file ConstantProp.cpp.

static MachineInstr* llvm::CreateConvertFPToIntInstr const TargetMachine target,
Value srcVal,
Value destVal,
const Type destType
[static]
 

Definition at line 2013 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 1386 of file SparcV9BurgISel.cpp.

FunctionPass* llvm::createCorrelatedExpressionEliminationPass  ) 
 

Definition at line 288 of file CorrelatedExprs.cpp.

FunctionPass* llvm::createCorrelatedExpressionEliminationPass  ) 
 

Definition at line 288 of file CorrelatedExprs.cpp.

FunctionPass* llvm::createDarwinAsmPrinter std::ostream &  o,
TargetMachine 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 297 of file PowerPCAsmPrinter.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly().

FunctionPass* llvm::createDarwinAsmPrinter std::ostream &  o,
TargetMachine 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 297 of file PowerPCAsmPrinter.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly().

ModulePass* llvm::createDeadArgEliminationPass  ) 
 

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

Definition at line 109 of file DeadArgumentElimination.cpp.

ModulePass* llvm::createDeadArgEliminationPass  ) 
 

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

Definition at line 109 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 110 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 110 of file DeadArgumentElimination.cpp.

FunctionPass* llvm::createDeadCodeEliminationPass  ) 
 

Definition at line 126 of file DCE.cpp.

FunctionPass* llvm::createDeadCodeEliminationPass  ) 
 

Definition at line 126 of file DCE.cpp.

FunctionPass* llvm::createDeadInstEliminationPass  ) 
 

Definition at line 56 of file DCE.cpp.

FunctionPass* llvm::createDeadInstEliminationPass  ) 
 

Definition at line 56 of file DCE.cpp.

FunctionPass* llvm::createDeadStoreEliminationPass  ) 
 

Definition at line 60 of file DeadStoreElimination.cpp.

FunctionPass* llvm::createDeadStoreEliminationPass  ) 
 

Definition at line 60 of file DeadStoreElimination.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::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.

FunctionPass * llvm::createDecomposeMultiDimRefsPass  ) 
 

Definition at line 51 of file DecomposeMultiDimRefs.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 2390 of file SparcV9BurgISel.cpp.

ModulePass * llvm::createEmitFunctionTablePass  ) 
 

Definition at line 120 of file EmitFunctions.cpp.

FunctionPass* llvm::createEmitX86CodeToMemory  ) 
 

createX86EmitCodeToMemory - Returns a pass that converts a register allocated function into raw machine code in a dynamically allocated chunk of memory.

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.

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.

ModulePass* llvm::createFunctionInliningPass  ) 
 

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

Definition at line 70 of file InlineSimple.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 70 of file InlineSimple.cpp.

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 48 of file FunctionResolution.cpp.

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 48 of file FunctionResolution.cpp.

FunctionPass* llvm::createGCSEPass  ) 
 

Definition at line 58 of file GCSE.cpp.

FunctionPass* llvm::createGCSEPass  ) 
 

Definition at line 58 of file GCSE.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::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 56 of file GlobalOpt.cpp.

ModulePass* llvm::createGlobalOptimizerPass  ) 
 

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

Definition at line 56 of file GlobalOpt.cpp.

Pass* llvm::createGlobalsModRefPass  ) 
 

Definition at line 141 of file GlobalsModRef.cpp.

Pass* llvm::createGlobalsModRefPass  ) 
 

Definition at line 141 of file GlobalsModRef.cpp.

FunctionPass* llvm::createIndVarSimplifyPass  ) 
 

Definition at line 332 of file IndVarSimplify.cpp.

FunctionPass* llvm::createIndVarSimplifyPass  ) 
 

Definition at line 332 of file IndVarSimplify.cpp.

FunctionPass* llvm::createInstructionCombiningPass  ) 
 

Definition at line 4315 of file InstructionCombining.cpp.

FunctionPass* llvm::createInstructionCombiningPass  ) 
 

Definition at line 4315 of file InstructionCombining.cpp.

FunctionPass * llvm::createInstructionSchedulingWithSSAPass const TargetMachine &  TM  ) 
 

Definition at line 1494 of file InstrScheduling.cpp.

ModulePass * llvm::createInternalGlobalMapperPass  ) 
 

Definition at line 34 of file InternalGlobalMapper.cpp.

ModulePass* llvm::createInternalizePass  ) 
 

createInternalizePass - This pass loops over all of the functions in the input module, looking for a main function. If a main function is found, all other functions are marked as internal.

Definition at line 120 of file Internalize.cpp.

ModulePass* llvm::createInternalizePass  ) 
 

createInternalizePass - This pass loops over all of the functions in the input module, looking for a main function. If a main function is found, all other functions are marked as internal.

Definition at line 120 of file Internalize.cpp.

static MachineInstr* llvm::CreateIntNegInstruction const TargetMachine target,
Value vreg
[inline, static]
 

Definition at line 2187 of file SparcV9BurgISel.cpp.

static void llvm::CreateIntSetInstruction int64_t  C,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi
[inline, static]
 

CreateIntSetInstruction - Create code to Set a signed constant in the register `dest'. Really the same as CreateUIntSetInstruction.

Definition at line 781 of file SparcV9BurgISel.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::createIPConstantPropagationPass  ) 
 

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

Definition at line 44 of file IPConstantPropagation.cpp.

FunctionPass* llvm::createIterativeScanRegisterAllocator  ) 
 

IterativeScanRegisterAllocation Pass - This pass implements the iterative scan register allocation algorithm, a global register allocator.

Definition at line 490 of file RegAllocIterativeScan.cpp.

Referenced by createRegisterAllocator().

FunctionPass* llvm::createIterativeScanRegisterAllocator  ) 
 

IterativeScanRegisterAllocation Pass - This pass implements the iterative scan register allocation algorithm, a global register allocator.

Definition at line 490 of file RegAllocIterativeScan.cpp.

Referenced by createRegisterAllocator().

FunctionPass* llvm::createLICMPass  ) 
 

Definition at line 201 of file LICM.cpp.

FunctionPass* llvm::createLICMPass  ) 
 

Definition at line 201 of file LICM.cpp.

FunctionPass* llvm::createLinearScanRegisterAllocator  ) 
 

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

Definition at line 621 of file RegAllocLinearScan.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 621 of file RegAllocLinearScan.cpp.

Referenced by createRegisterAllocator().

FunctionPass* llvm::createLoadValueNumberingPass  ) 
 

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

Definition at line 90 of file LoadValueNumbering.cpp.

FunctionPass* llvm::createLoadValueNumberingPass  ) 
 

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

Definition at line 90 of file LoadValueNumbering.cpp.

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 673 of file RegAllocLocal.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 673 of file RegAllocLocal.cpp.

Referenced by createRegisterAllocator().

FunctionPass * llvm::createLoopInstrumentationPass  ) 
 

Definition at line 179 of file InstLoops.cpp.

FunctionPass* llvm::createLoopSimplifyPass  ) 
 

Definition at line 91 of file LoopSimplify.cpp.

FunctionPass* llvm::createLoopSimplifyPass  ) 
 

Definition at line 91 of file LoopSimplify.cpp.

FunctionPass* llvm::createLoopStrengthReducePass  ) 
 

Definition at line 67 of file LoopStrengthReduce.cpp.

FunctionPass* llvm::createLoopStrengthReducePass  ) 
 

Definition at line 67 of file LoopStrengthReduce.cpp.

FunctionPass* llvm::createLoopUnrollPass  ) 
 

Definition at line 63 of file LoopUnroll.cpp.

FunctionPass* llvm::createLoopUnrollPass  ) 
 

Definition at line 63 of file LoopUnroll.cpp.

FunctionPass* llvm::createLoopUnswitchPass  ) 
 

Definition at line 71 of file LoopUnswitch.cpp.

FunctionPass* llvm::createLowerAllocationsPass  ) 
 

Definition at line 52 of file LowerAllocations.cpp.

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

FunctionPass* llvm::createLowerAllocationsPass  ) 
 

Definition at line 52 of file LowerAllocations.cpp.

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

FunctionPass * llvm::createLowerConstantExpressionsPass  ) 
 

Definition at line 166 of file LowerConstantExprs.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), and llvm::PowerPCJITInfo::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 65 of file LowerGC.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::CTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::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 65 of file LowerGC.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::CTargetMachine::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86JITInfo::addPassesToJITCompile(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLowerInvokePass  ) 
 

Definition at line 82 of file LowerInvoke.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::CTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLowerInvokePass  ) 
 

Definition at line 82 of file LowerInvoke.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::CTargetMachine::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86JITInfo::addPassesToJITCompile(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLowerPackedPass  ) 
 

Definition at line 102 of file LowerPacked.cpp.

FunctionPass* llvm::createLowerPackedPass  ) 
 

Definition at line 102 of file LowerPacked.cpp.

FunctionPass* llvm::createLowerSelectPass bool  OnlyFP  ) 
 

Definition at line 55 of file LowerSelect.cpp.

FunctionPass* llvm::createLowerSelectPass bool  OnlyFP = false  ) 
 

Definition at line 55 of file LowerSelect.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 522 of file LowerSetJmp.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 522 of file LowerSetJmp.cpp.

FunctionPass* llvm::createLowerSwitchPass  ) 
 

Definition at line 63 of file LowerSwitch.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createLowerSwitchPass  ) 
 

Definition at line 63 of file LowerSwitch.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86JITInfo::addPassesToJITCompile(), and llvm::PowerPCJITInfo::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 83 of file MachineFunction.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::SkeletonTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PPC32TargetMachine::addPassesToEmitMachineCode(), and llvm::X86TargetMachine::addPassesToEmitMachineCode().

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 83 of file MachineFunction.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::SkeletonTargetMachine::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitMachineCode(), and llvm::PPC32TargetMachine::addPassesToEmitMachineCode().

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 63 of file MachineFunction.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::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 63 of file MachineFunction.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86JITInfo::addPassesToJITCompile(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createModuloSchedulingPass TargetMachine targ  ) 
 

Create ModuloSchedulingPass

Definition at line 42 of file ModuloScheduling.cpp.

References DEBUG.

FunctionPass* llvm::createModuloSchedulingPass TargetMachine targ  ) 
 

Create ModuloSchedulingPass

Definition at line 42 of file ModuloScheduling.cpp.

References DEBUG.

static MachineInstr* llvm::CreateMovFloatInstruction const InstructionNode instrNode,
const Type resultType
[inline, static]
 

Definition at line 2080 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 2243 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 2346 of file SparcV9BurgISel.cpp.

FunctionPass * llvm::createPeepholeOptsPass const TargetMachine &  TM  ) 
 

Peephole optimization pass operating on machine code

Definition at line 159 of file SparcV9PeepholeOpts.cpp.

FunctionPass* llvm::createPPC32ISelSimple TargetMachine TM  ) 
 

createPPC32ISelSimple - This pass converts an LLVM function into a machine code representation is a very simple peep-hole fashion.

Definition at line 3937 of file PPC32ISelSimple.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createPPC32ISelSimple TargetMachine TM  ) 
 

createPPC32ISelSimple - This pass converts an LLVM function into a machine code representation is a very simple peep-hole fashion.

Definition at line 3937 of file PPC32ISelSimple.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createPPC64ISelSimple TargetMachine TM  ) 
 

createPPC64ISelSimple - This pass converts an LLVM function into a machine code representation is a very simple peep-hole fashion.

Definition at line 2946 of file PPC64ISelSimple.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly().

FunctionPass* llvm::createPPC64ISelSimple TargetMachine TM  ) 
 

createPPC64ISelSimple - This pass converts an LLVM function into a machine code representation is a very simple peep-hole fashion.

Definition at line 2946 of file PPC64ISelSimple.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly().

FunctionPass* llvm::createPPCBranchSelectionPass  ) 
 

createPPCBranchSelectionPass - returns an instance of the Branch Selection Pass

Definition at line 131 of file PowerPCBranchSelector.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createPPCBranchSelectionPass  ) 
 

createPPCBranchSelectionPass - returns an instance of the Branch Selection Pass

Definition at line 131 of file PowerPCBranchSelector.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createPreSelectionPass const TargetMachine TM  ) 
 

createPreSelectionPass - Public entry point for the PreSelection pass

Definition at line 281 of file SparcV9PreSelection.cpp.

FunctionPass* llvm::createPreSelectionPass const TargetMachine TM  ) 
 

createPreSelectionPass - Public entry point for the PreSelection pass

Definition at line 281 of file SparcV9PreSelection.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 61 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 61 of file ProfileInfoLoaderPass.cpp.

FunctionPass* llvm::createPrologEpilogCodeInserter  ) 
 

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

Definition at line 88 of file PrologEpilogInserter.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::SkeletonTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCJITInfo::addPassesToJITCompile(), llvm::SkeletonJITInfo::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 88 of file PrologEpilogInserter.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::SkeletonTargetMachine::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::SkeletonJITInfo::addPassesToJITCompile(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass * llvm::createPrologEpilogInsertionPass  ) 
 

getPrologEpilogInsertionPass - Inserts prolog/epilog code.

Definition at line 180 of file SparcV9PrologEpilogInserter.cpp.

FunctionPass* llvm::createPromoteMemoryToRegister  ) 
 

Definition at line 79 of file Mem2Reg.cpp.

FunctionPass* llvm::createPromoteMemoryToRegister  ) 
 

Definition at line 79 of file Mem2Reg.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 42 of file PruneEH.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 42 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::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.

FunctionPass* llvm::createRaisePointerReferencesPass  ) 
 

Definition at line 86 of file LevelRaise.cpp.

FunctionPass* llvm::createRaisePointerReferencesPass  ) 
 

Definition at line 86 of file LevelRaise.cpp.

FunctionPass* llvm::createReassociatePass  ) 
 

Definition at line 63 of file Reassociate.cpp.

FunctionPass* llvm::createReassociatePass  ) 
 

Definition at line 63 of file Reassociate.cpp.

FunctionPass* llvm::createRegisterAllocator  ) 
 

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

Definition at line 37 of file Passes.cpp.

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

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::SkeletonTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCJITInfo::addPassesToJITCompile(), llvm::SkeletonJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createRegisterAllocator  ) 
 

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

Definition at line 37 of file Passes.cpp.

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

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::SkeletonTargetMachine::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86JITInfo::addPassesToJITCompile(), llvm::SkeletonJITInfo::addPassesToJITCompile(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createScalarReplAggregatesPass  ) 
 

Definition at line 68 of file ScalarReplAggregates.cpp.

FunctionPass* llvm::createScalarReplAggregatesPass  ) 
 

Definition at line 68 of file ScalarReplAggregates.cpp.

FunctionPass* llvm::createSCCPPass  ) 
 

Definition at line 818 of file SCCP.cpp.

FunctionPass* llvm::createSCCPPass  ) 
 

Definition at line 818 of file SCCP.cpp.

static void llvm::CreateSETSWConst int32_t  C,
Instruction dest,
std::vector< MachineInstr * > &  mvec
[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 662 of file SparcV9BurgISel.cpp.

static void llvm::CreateSETUWConst uint32_t  C,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
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::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 705 of file SparcV9BurgISel.cpp.

static void llvm::CreateSETXConst uint64_t  C,
Instruction tmpReg,
Instruction dest,
std::vector< MachineInstr * > &  mvec
[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 680 of file SparcV9BurgISel.cpp.

static void llvm::CreateSETXLabel Value val,
Instruction tmpReg,
Instruction dest,
std::vector< MachineInstr * > &  mvec
[inline, static]
 

CreateSETXLabel - Set a 64-bit constant (given by a symbolic label) in the register `dest'.

Definition at line 724 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 2201 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 1234 of file SparcV9BurgISel.cpp.

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 237 of file RegAllocSimple.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 237 of file RegAllocSimple.cpp.

Referenced by createRegisterAllocator().

ModulePass* 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 129 of file LoopExtractor.cpp.

ModulePass* 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 129 of file LoopExtractor.cpp.

FunctionPass * llvm::createSparcV9BurgInstSelector TargetMachine TM  ) 
 

createSparcV9BurgInstSelector - Creates and returns a new SparcV9 BURG-based instruction selection pass.

Definition at line 4530 of file SparcV9BurgISel.cpp.

FunctionPass* llvm::createSparcV9MachineCodeDestructionPass  ) 
 

Definition at line 685 of file SparcV9TargetMachine.cpp.

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

FunctionPass* llvm::createSparcV9MachineCodeDestructionPass  ) 
 

Definition at line 685 of file SparcV9TargetMachine.cpp.

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

Spiller * llvm::createSpiller  ) 
 

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

Definition at line 561 of file VirtRegMap.cpp.

References SpillerOpt.

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.

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.

ModulePass* llvm::createStripSymbolsPass bool  OnlyDebugInfo  ) 
 

Definition at line 49 of file StripSymbols.cpp.

ModulePass* llvm::createStripSymbolsPass bool  OnlyDebugInfo = false  ) 
 

Definition at line 49 of file StripSymbols.cpp.

static MachineInstr* llvm::CreateSubConstInstruction const InstructionNode instrNode  )  [inline, static]
 

Definition at line 2124 of file SparcV9BurgISel.cpp.

FunctionPass* llvm::createTailCallEliminationPass  ) 
 

Definition at line 74 of file TailRecursionElimination.cpp.

FunctionPass* llvm::createTailCallEliminationPass  ) 
 

Definition at line 74 of file TailRecursionElimination.cpp.

FunctionPass* llvm::createTailDuplicationPass  ) 
 

Definition at line 53 of file TailDuplication.cpp.

FunctionPass* llvm::createTailDuplicationPass  ) 
 

Definition at line 53 of file TailDuplication.cpp.

FunctionPass* llvm::createTraceValuesPassForBasicBlocks  ) 
 

Trace BB's and functions.

Definition at line 117 of file TraceValues.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.

FunctionPass* llvm::createTraceValuesPassForFunction  ) 
 

Just trace functions.

Definition at line 112 of file TraceValues.cpp.

static void llvm::CreateUIntSetInstruction uint64_t  C,
Instruction dest,
std::vector< MachineInstr * > &  mvec,
MachineCodeForInstruction mcfi
[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 760 of file SparcV9BurgISel.cpp.

Pass* llvm::createUnifyFunctionExitNodesPass  ) 
 

Definition at line 28 of file UnifyFunctionExitNodes.cpp.

Pass* llvm::createUnifyFunctionExitNodesPass  ) 
 

Definition at line 28 of file UnifyFunctionExitNodes.cpp.

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 40 of file UnreachableBlockElim.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCJITInfo::addPassesToJITCompile(), and llvm::X86JITInfo::addPassesToJITCompile().

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 40 of file UnreachableBlockElim.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86JITInfo::addPassesToJITCompile(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

FunctionPass* llvm::createVerifierPass VerifierFailureAction  action  ) 
 

Definition at line 753 of file Verifier.cpp.

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

FunctionPass* llvm::createX86CodePrinterPass std::ostream &  o,
TargetMachine 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 601 of file X86AsmPrinter.cpp.

References AsmWriterFlavor.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86CodePrinterPass std::ostream &  o,
TargetMachine 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 601 of file X86AsmPrinter.cpp.

References AsmWriterFlavor.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86FloatingPointKillerPass  ) 
 

createX86FloatingPointKiller - This function returns a pass which kills every floating point register at the end of each basic block because our FloatingPointStackifier cannot handle them.

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 154 of file X86FloatingPoint.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), 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 154 of file X86FloatingPoint.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86PeepholeOptimizerPass  ) 
 

createX86PeepholeOptimizer - Create a pass to perform X86 specific peephole optimizations.

Definition at line 39 of file X86PeepholeOpt.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86PeepholeOptimizerPass  ) 
 

createX86PeepholeOptimizer - Create a pass to perform X86 specific peephole optimizations.

Definition at line 39 of file X86PeepholeOpt.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86SimpleInstructionSelector TargetMachine TM  ) 
 

createX86SimpleInstructionSelector - This pass converts an LLVM function into a machine code representation is a very simple peep-hole fashion. The generated code sucks but the implementation is nice and simple.

Definition at line 4045 of file X86ISelSimple.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86SimpleInstructionSelector TargetMachine TM  ) 
 

createX86SimpleInstructionSelector - This pass converts an LLVM function into a machine code representation is a very simple peep-hole fashion. The generated code sucks but the implementation is nice and simple.

Definition at line 4045 of file X86ISelSimple.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86SSAPeepholeOptimizerPass  ) 
 

createX86SSAPeepholeOptimizerPass - Create a pass to perform SSA-based X86 specific peephole optimizations.

Definition at line 344 of file X86PeepholeOpt.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

FunctionPass* llvm::createX86SSAPeepholeOptimizerPass  ) 
 

createX86SSAPeepholeOptimizerPass - Create a pass to perform SSA-based X86 specific peephole optimizations.

Definition at line 344 of file X86PeepholeOpt.cpp.

Referenced by llvm::X86TargetMachine::addPassesToEmitAssembly(), and llvm::X86JITInfo::addPassesToJITCompile().

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 1250 of file SparcV9BurgISel.cpp.

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 330 of file Transforms/Utils/Local.cpp.

References isInstructionTriviallyDead().

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 330 of file Transforms/Utils/Local.cpp.

References isInstructionTriviallyDead().

bool llvm::DecomposeArrayRef GetElementPtrInst GEP  ) 
 

Definition at line 82 of file DecomposeMultiDimRefs.cpp.

References 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, and llvm::Value::replaceAllUsesWith().

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(), llvm::TargetInstrInfo::getNumDelaySlots(), and prior().

Referenced by RemoveUselessCopies().

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

Definition at line 76 of file STLExtras.h.

AllocaInst* llvm::DemoteRegToStack Instruction I  ) 
 

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 31 of file DemoteRegToStack.cpp.

References llvm::BasicBlock::begin(), F, llvm::Function::getEntryBlock(), llvm::Value::getName(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::Value::getType(), U, llvm::Value::use_back(), llvm::Value::use_empty(), and V.

Referenced by InsertPHINodesForUsesOutsideLoop(), and Cilkifier::visitCallInst().

AllocaInst* llvm::DemoteRegToStack Instruction I  ) 
 

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 31 of file DemoteRegToStack.cpp.

References llvm::BasicBlock::begin(), F, llvm::Function::getEntryBlock(), llvm::Value::getName(), llvm::Instruction::getParent(), llvm::BasicBlock::getParent(), llvm::Value::getType(), U, llvm::Value::use_back(), llvm::Value::use_empty(), and V.

Referenced by InsertPHINodesForUsesOutsideLoop(), and Cilkifier::visitCallInst().

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.

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

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

Definition at line 164 of file DepthFirstIterator.h.

Referenced by PathExistsToClonedNode().

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

Definition at line 169 of file DepthFirstIterator.h.

Referenced by PathExistsToClonedNode().

template<class T, class SetTy>
df_ext_iterator<T, SetTy> llvm::df_ext_begin 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 G,
SetTy S
 

Definition at line 186 of file DepthFirstIterator.h.

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

bool llvm::DiffFiles const std::string &  FileA,
const std::string &  FileB,
std::string *  Error
 

DiffFiles - Compare the two files specified, returning true if they are different or if there is a file error. 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 89 of file FileUtilities.cpp.

Referenced by MoveFileOverIfUpdated().

bool llvm::DiffFiles const std::string &  FileA,
const std::string &  FileB,
std::string *  Error
 

DiffFiles - Compare the two files specified, returning true if they are different or if there is a file error. 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 89 of file FileUtilities.cpp.

Referenced by MoveFileOverIfUpdated().

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().

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

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

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

References C, and ConstantFoldInstruction().

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

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

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

References C, and ConstantFoldInstruction().

static char llvm::doDFS BasicBlock node,
std::map< BasicBlock *, Color > &  color
[static]
 

Definition at line 46 of file EmitFunctions.cpp.

References BLACK, GREY, succ_begin(), and succ_end().

Referenced by hasBackEdge().

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.

static bool llvm::edgesEqual Edge  ed1,
Edge  ed2
[static]
 

Definition at line 30 of file GraphAuxiliary.cpp.

References llvm::Edge::getWeight().

Referenced by inc_DFS().

int llvm::ExecWait const char *const   argv[],
const char *const   envp[]
 

ExecWait - Execute a program with the given arguments and environment and wait for it to terminate.

Definition at line 247 of file SystemUtils.cpp.

int llvm::ExecWait const char *const   argv[],
const char *const   envp[]
 

ExecWait - Execute a program with the given arguments and environment and wait for it to terminate.

Definition at line 247 of file SystemUtils.cpp.

bool llvm::ExpressionConvertibleToType Value V,
const Type Ty,
ValueTypeCache Map,
const TargetData TD
 

Definition at line 142 of file ExprTypeConvert.cpp.

References Add(), llvm::Instruction::Call, llvm::Instruction::Cast, ConvertibleToGEP(), 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::LoadInst::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(), llvm::Type::isSized(), llvm::FunctionType::isVarArg(), llvm::Instruction::Load, llvm::Instruction::Malloc, MallocConvertibleToType(), OperandConvertibleToType(), llvm::FunctionType::param_begin(), llvm::FunctionType::param_end(), llvm::Instruction::PHI, llvm::Type::SByteTy, llvm::Instruction::Shl, llvm::Value::use_begin(), and llvm::Value::use_end().

Referenced by OperandConvertibleToType().

Function* llvm::ExtractBasicBlock BasicBlock BB,
bool  AggregateArgs
 

ExtractBasicBlock - slurp a basic block into a brand new function

Definition at line 744 of file CodeExtractor.cpp.

Function* llvm::ExtractBasicBlock BasicBlock BB,
bool  AggregateArgs
 

ExtractBasicBlock - slurp a basic block into a brand new function

Definition at line 744 of file CodeExtractor.cpp.

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 730 of file CodeExtractor.cpp.

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 730 of file CodeExtractor.cpp.

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

ExtractBasicBlock - slurp a natural loop into a brand new function

Definition at line 738 of file CodeExtractor.cpp.

References llvm::Loop::getBlocks().

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

ExtractBasicBlock - slurp a natural loop into a brand new function

Definition at line 738 of file CodeExtractor.cpp.

References llvm::Loop::getBlocks().

bool llvm::FileOpenable const std::string &  Filename  ) 
 

FileOpenable - Returns true IFF Filename names an existing regular file which we can successfully open.

Definition at line 71 of file FileUtilities.cpp.

Referenced by FindLib(), llvm::SourceFileInfo::getSourceText(), and LinkFiles().

bool llvm::FileOpenable const std::string &  Filename  ) 
 

FileOpenable - Returns true IFF Filename names an existing regular file which we can successfully open.

Definition at line 71 of file FileUtilities.cpp.

Referenced by FindLib(), llvm::SourceFileInfo::getSourceText(), and LinkFiles().

static Node * llvm::findBB std::vector< Node * > &  st,
BasicBlock *  BB
[static]
 

Definition at line 59 of file ProfilePaths.cpp.

Referenced by getBBtrace(), and llvm::ProfilePaths::runOnFunction().

std::string llvm::FindExecutable const std::string &  ExeName,
const std::string &  ProgramPath
 

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 70 of file SystemUtils.cpp.

References isExecutableFile().

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

std::string llvm::FindExecutable const std::string &  ExeName,
const std::string &  ProgramPath
 

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 70 of file SystemUtils.cpp.

References isExecutableFile().

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

std::string llvm::FindLib const std::string &  Filename,
const std::vector< std::string > &  Paths,
bool  SharedObjectOnly
 

FindLib - Try to convert Filename into the name of a file that we can open, if it does not already name a file we can open, by first trying to open Filename, then libFilename.[suffix] for each of a set of several common library suffixes, in each of the directories in Paths and the directory named by the value of the environment variable LLVM_LIB_SEARCH_PATH. Returns an empty string if no matching file can be found.

Definition at line 45 of file LinkArchives.cpp.

References FileOpenable(), and LTDL_SHLIB_EXT.

Referenced by LinkOneLibrary().

std::string llvm::FindLib const std::string &  Filename,
const std::vector< std::string > &  Paths,
bool  SharedObjectOnly
 

FindLib - Try to convert Filename into the name of a file that we can open, if it does not already name a file we can open, by first trying to open Filename, then libFilename.[suffix] for each of a set of several common library suffixes, in each of the directories in Paths and the directory named by the value of the environment variable LLVM_LIB_SEARCH_PATH. Returns an empty string if no matching file can be found.

Definition at line 45 of file LinkArchives.cpp.

References FileOpenable(), and LTDL_SHLIB_EXT.

Referenced by LinkOneLibrary().

graphListElement * llvm::findNodeInList Graph::nodeList &  NL,
Node *  N
 

Definition at line 33 of file Graph.cpp.

const graphListElement * llvm::findNodeInList const Graph::nodeList &  NL,
Node *  N
 

Definition at line 24 of file Graph.cpp.

Referenced by llvm::Graph::addEdge(), llvm::Graph::getPredNodes(), llvm::Graph::hasEdge(), and llvm::Graph::setWeight().

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().

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().

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 1444 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 1600 of file SparcV9BurgISel.cpp.

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

Definition at line 973 of file InstrScheduling.cpp.

References 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 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 2740 of file SparcV9BurgISel.cpp.

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

Definition at line 100 of file StringExtras.h.

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

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

Definition at line 96 of file GetElementPtrTypeIterator.h.

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

Definition at line 86 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_begin const User *  GEP  )  [inline]
 

Definition at line 79 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(), GetGEPGlobalInitializer(), llvm::TargetData::getIndexedOffset(), llvm::BytecodeReader::ParseConstantValue(), and llvm::Interpreter::visitGetElementPtrInst().

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

Definition at line 102 of file GetElementPtrTypeIterator.h.

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

Definition at line 90 of file GetElementPtrTypeIterator.h.

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

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

Definition at line 83 of file GetElementPtrTypeIterator.h.

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

Referenced by ConstantFoldGetElementPtr(), GetGEPGlobalInitializer(), llvm::BytecodeReader::ParseConstantValue(), and llvm::Interpreter::visitGetElementPtrInst().

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

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::GetAllDefinedSymbols Module M,
std::set< std::string > &  DefinedSymbols
 

GetAllDefinedSymbols - Modifies its parameter DefinedSymbols to contain the name of each externally-visible symbol defined in M.

Definition at line 85 of file LinkArchives.cpp.

References llvm::Module::begin(), E, llvm::Module::end(), llvm::Module::gbegin(), llvm::Module::gend(), and I.

void llvm::GetAllDefinedSymbols Module M,
std::set< std::string > &  DefinedSymbols
 

GetAllDefinedSymbols - Modifies its parameter DefinedSymbols to contain the name of each externally-visible symbol defined in M.

Definition at line 85 of file LinkArchives.cpp.

References llvm::Module::begin(), E, llvm::Module::end(), llvm::Module::gbegin(), llvm::Module::gend(), and I.

void llvm::GetAllUndefinedSymbols Module M,
std::set< std::string > &  UndefinedSymbols
 

GetAllUndefinedSymbols - calculates the set of undefined symbols that still exist in an LLVM module. This is a bit tricky because there may be two symbols with the same name but different LLVM types that will be resolved to each other but aren't currently (thus we need to treat it as resolved).

Inputs: M - The module in which to find undefined symbols.

Outputs: UndefinedSymbols - A set of C++ strings containing the name of all undefined symbols.

Definition at line 108 of file LinkArchives.cpp.

References llvm::Module::begin(), E, llvm::Module::end(), llvm::Module::gbegin(), llvm::Module::gend(), and I.

Referenced by LinkInArchive().

void llvm::GetAllUndefinedSymbols Module M,
std::set< std::string > &  UndefinedSymbols
 

GetAllUndefinedSymbols - calculates the set of undefined symbols that still exist in an LLVM module. This is a bit tricky because there may be two symbols with the same name but different LLVM types that will be resolved to each other but aren't currently (thus we need to treat it as resolved).

Inputs: M - The module in which to find undefined symbols.

Outputs: UndefinedSymbols - A set of C++ strings containing the name of all undefined symbols.

Definition at line 108 of file LinkArchives.cpp.

References llvm::Module::begin(), E, llvm::Module::end(), llvm::Module::gbegin(), llvm::Module::gend(), and I.

Referenced by LinkInArchive().

void llvm::getBBtrace vector< BasicBlock * > &  vBB,
int  pathNo,
Function *  M
 

Definition at line 130 of file RetracePath.cpp.

References addDummyEdges(), llvm::Function::begin(), E, llvm::Function::end(), findBB(), llvm::Function::front(), llvm::Graph::getBackEdges(), llvm::CallInst::getCalledFunction(), llvm::Value::getName(), getPathFrmNode(), I, llvm::Function::size(), succ_begin(), succ_end(), and valueAssignmentToEdges().

void llvm::getBBtrace std::vector< BasicBlock * > &  vBB,
int  pathNo,
Function *  M
 

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 248 of file ReaderWrappers.cpp.

References CheckVarargs().

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

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 248 of file ReaderWrappers.cpp.

References CheckVarargs().

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

bool llvm::GetBytecodeDependentLibraries const std::string &  fname,
Module::LibraryListType deplibs
 

Definition at line 334 of file ReaderWrappers.cpp.

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

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

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 273 of file ReaderWrappers.cpp.

References CheckVarargs().

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

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 273 of file ReaderWrappers.cpp.

References CheckVarargs().

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

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 394 of file ReaderWrappers.cpp.

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

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 374 of file ReaderWrappers.cpp.

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

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 394 of file ReaderWrappers.cpp.

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

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 374 of file ReaderWrappers.cpp.

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

static void llvm::getChords vector< Edge > &  chords,
Graph &  g,
Graph  st
[static]
 

Definition at line 35 of file GraphAuxiliary.cpp.

References llvm::Graph::getAllNodes(), llvm::Graph::getNodeList(), and llvm::Graph::hasEdgeAndWt().

Referenced by processGraph().

static void llvm::getCodeInsertions Graph &  g,
map< Edge, getEdgeCode *, EdgeCompare2 > &  instr,
vector< Edge > &  chords,
map< Edge, int, EdgeCompare2 > &  edIncrements
[static]
 

Definition at line 276 of file GraphAuxiliary.cpp.

References llvm::Graph::getAllNodes(), llvm::Graph::getExit(), llvm::Graph::getNodeList(), llvm::Graph::getNumberOfIncomingEdges(), llvm::Graph::getNumberOfOutgoingEdges(), llvm::Graph::getRoot(), llvm::Edge::getWeight(), llvm::getEdgeCode::setCond(), llvm::getEdgeCode::setInc(), and llvm::Node::weight.

Referenced by processGraph().

static int64_t llvm::getConstantValue const ConstantInt *  CPI  )  [inline, static]
 

Definition at line 27 of file TransformInternals.h.

Referenced by ConvertMallocToType(), and MallocConvertibleToType().

static map<Edge, int, EdgeCompare2> llvm::getEdgeIncrements Graph &  g,
Graph &  t,
vector< Edge > &  be
[static]
 

Definition at line 225 of file GraphAuxiliary.cpp.

References llvm::Graph::getAllNodes(), llvm::Graph::getRoot(), llvm::Graph::getSortedNodeList(), llvm::Edge::getWeight(), llvm::Graph::hasEdgeAndWt(), and inc_DFS().

Referenced by processGraph().

long long llvm::getFileSize const std::string &  Filename  ) 
 

getFileSize - Return the size of the specified file in bytes, or -1 if the file cannot be read or does not exist.

Definition at line 254 of file FileUtilities.cpp.

Referenced by ReadFileIntoAddressSpace().

long long llvm::getFileSize const std::string &  Filename  ) 
 

getFileSize - Return the size of the specified file in bytes, or -1 if the file cannot be read or does not exist.

Definition at line 254 of file FileUtilities.cpp.

Referenced by ReadFileIntoAddressSpace().

unsigned long long llvm::getFileTimestamp const std::string &  Filename  ) 
 

getFileTimestamp - Get the last modified time for the specified file in an unspecified format. This is useful to allow checking to see if a file was updated since that last time the timestampt was aquired. If the file does not exist or there is an error getting the time-stamp, zero is returned.

Definition at line 265 of file FileUtilities.cpp.

Referenced by llvm::ProgramInfo::ProgramInfo().

unsigned long long llvm::getFileTimestamp const std::string &  Filename  ) 
 

getFileTimestamp - Get the last modified time for the specified file in an unspecified format. This is useful to allow checking to see if a file was updated since that last time the timestampt was aquired. If the file does not exist or there is an error getting the time-stamp, zero is returned.

Definition at line 265 of file FileUtilities.cpp.

Referenced by llvm::ProgramInfo::ProgramInfo().

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 1682 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 2866 of file SparcV9BurgISel.cpp.

std::ostream* llvm::GetLibSupportInfoOutputFile  ) 
 

Definition at line 294 of file Timer.cpp.

References getLibSupportInfoOutputFilename().

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

std::ostream * llvm::GetLibSupportInfoOutputFile  ) 
 

Definition at line 294 of file Timer.cpp.

References getLibSupportInfoOutputFilename().

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

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 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 1728 of file SparcV9BurgISel.cpp.

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

Definition at line 50 of file IntervalIterator.h.

References llvm::Interval::getHeaderNode().

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

Definition at line 49 of file IntervalIterator.h.

unsigned llvm::GetPageSize  ) 
 

GetPageSize - wrapper to return page size in bytes for various architecture/OS combinations

Definition at line 32 of file pagesize.h.

Referenced by llvm::sys::Memory::AllocateRWX(), AllocateRWXMemory(), llvm::sys::MappedFile::map(), and llvm::sys::MappedFile::size().

unsigned llvm::GetPageSizeOnce  )  [inline]
 

Definition at line 27 of file Win32/Process.cpp.

void llvm::getPathFrmNode Node *  n,
vector< BasicBlock * > &  vBB,
int  pathNo,
Graph &  g,
vector< Edge > &  stDummy,
vector< Edge > &  exDummy,
vector< Edge > &  be,
double  strand
 

Definition at line 28 of file RetracePath.cpp.

References llvm::Node::element, llvm::Node::getElement(), llvm::Graph::getExit(), llvm::Graph::getNodeList(), llvm::Graph::getRoot(), and llvm::Node::weight.

Referenced by getBBtrace().

static const CompositeType* llvm::getPointedToComposite const Type *  Ty  )  [inline, static]
 

Definition at line 35 of file TransformInternals.h.

References llvm::SequentialType::getElementType().

Referenced by PeepholeOptimizeAddCast().

FunctionPass * llvm::getRegisterAllocator TargetMachine &  T  ) 
 

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

Definition at line 80 of file PhyRegAlloc.cpp.

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

Definition at line 214 of file MSchedGraph.h.

Referenced by 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 MSchedGraph * > >::nodes_end(), llvm::GraphTraits< Inverse< MSchedGraph * > >::nodes_end(), llvm::GraphTraits< const MSchedGraph * >::nodes_end(), and llvm::GraphTraits< MSchedGraph * >::nodes_end().

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

Definition at line 59 of file IntervalIterator.h.

References llvm::IntervalPartition::getBlockInterval().

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

Definition at line 56 of file IntervalIterator.h.

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

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(), llvm::SparcV9FrameInfo::MinStackFrameSize, and llvm::SparcV9FrameInfo::StackFrameSizeAlignment.

const Type * llvm::getStructOffsetType const Type Ty,
unsigned &  Offset,
std::vector< Value * > &  Offsets,
const TargetData TD,
bool  StopEarly = true
 

Definition at line 55 of file TransformInternals.cpp.

References llvm::ConstantSInt::get(), getStructOffsetStep(), llvm::TargetData::getTypeSize(), llvm::Type::IntTy, llvm::ConstantSInt::isValueValidForType(), and llvm::Type::LongTy.

Referenced by ConvertOperandToType(), and OperandConvertibleToType().

static TmpInstruction* llvm::GetTmpForCC Value boolVal,
const Function F,
const Type ccType,
MachineCodeForInstruction mcfi
[static]
 

Definition at line 1850 of file SparcV9BurgISel.cpp.

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().

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().

static void llvm::getTriggerCode Module *  M,
BasicBlock *  BB,
int  MethNo,
Value *  pathNo,
Value *  cnt,
Instruction *  rInst
[static]
 

Definition at line 31 of file EdgeCode.cpp.

References llvm::ConstantSInt::get(), llvm::PointerType::get(), llvm::BasicBlock::getInstList(), llvm::Constant::getNullValue(), llvm::Module::getOrInsertFunction(), llvm::Type::IntTy, llvm::Type::LongTy, and llvm::Type::VoidTy.

Referenced by insertBB().

std::string llvm::getUniqueFilename const std::string &  FilenameBase  ) 
 

getUniqueFilename - Return a filename with the specified prefix. If the file does not exist yet, return it, otherwise add a suffix to make it unique.

Definition at line 174 of file FileUtilities.cpp.

Referenced by llvm::GCC::ExecuteProgram(), llvm::GCC::MakeSharedObject(), llvm::LLC::OutputAsm(), llvm::CBE::OutputC(), and ProcessFailure().

std::string llvm::getUniqueFilename const std::string &  FilenameBase  ) 
 

getUniqueFilename - Return a filename with the specified prefix. If the file does not exist yet, return it, otherwise add a suffix to make it unique.

Definition at line 174 of file FileUtilities.cpp.

Referenced by llvm::GCC::ExecuteProgram(), llvm::GCC::MakeSharedObject(), llvm::LLC::OutputAsm(), llvm::CBE::OutputC(), and ProcessFailure().

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

Definition at line 47 of file GenericValue.h.

References llvm::GenericValue::PointerVal.

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().

AllocaInst llvm::@0::HANDLE_MEMORY_INST 24  ,
Load  ,
LoadInst 
[static]
 

llvm::@0::HANDLE_MEMORY_INST 21  ,
Malloc  ,
MallocInst 
[static]
 

llvm::HANDLE_MEMORY_INST 21  ,
Malloc  ,
MallocInst 
 

AllocaInst PHINode CallInst VANextInst SelectInst llvm::@0::HANDLE_OTHER_INST 35  ,
UserOp1  ,
Instruction 
[static]
 

Definition at line 163 of file InstCount.cpp.

AllocaInst PHINode CallInst VANextInst llvm::@0::HANDLE_OTHER_INST 33  ,
VAArg  ,
VAArgInst 
[static]
 

AllocaInst PHINode CallInst llvm::@0::HANDLE_OTHER_INST 30  ,
Shl  ,
ShiftInst 
[static]
 

AllocaInst PHINode llvm::@0::HANDLE_OTHER_INST 28  ,
Cast  ,
CastInst 
[static]
 

AllocaInst PHINode CallInst VANextInst SelectInst llvm::HANDLE_OTHER_INST 35  ,
UserOp1  ,
Instruction 
 

AllocaInst PHINode CallInst VANextInst llvm::HANDLE_OTHER_INST 33  ,
VAArg  ,
VAArgInst 
 

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

AllocaInst PHINode llvm::HANDLE_OTHER_INST 28  ,
Cast  ,
CastInst 
 

static char llvm::hasBackEdge Function F  )  [static]
 

Definition at line 69 of file EmitFunctions.cpp.

References llvm::Function::begin(), and doDFS().

Value* llvm::hasConstantValue PHINode PN  ) 
 

hasConstantValue - If the specified PHI node always merges together the same value, return the value, otherwise return null.

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

References llvm::UndefValue::get(), llvm::PHINode::getIncomingValue(), llvm::PHINode::getNumIncomingValues(), and llvm::Value::getType().

Referenced by FindPHIToPartitionLoops().

Value* llvm::hasConstantValue PHINode PN  ) 
 

hasConstantValue - If the specified PHI node always merges together the same value, return the value, otherwise return null.

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

References llvm::UndefValue::get(), llvm::PHINode::getIncomingValue(), llvm::PHINode::getNumIncomingValues(), and llvm::Value::getType().

Referenced by FindPHIToPartitionLoops().

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

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

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

Definition at line 824 of file Lexer.cpp.

References C, and ThrowException().

Referenced by HexToFP().

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

Definition at line 847 of file Lexer.cpp.

References HexIntToVal().

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

Definition at line 200 of file DepthFirstIterator.h.

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

Definition at line 205 of file DepthFirstIterator.h.

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

Definition at line 219 of file DepthFirstIterator.h.

Referenced by llvm::PostDominatorSet::runOnFunction().

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

Definition at line 224 of file DepthFirstIterator.h.

Referenced by llvm::PostDominatorSet::runOnFunction().

static void llvm::inc_DFS Graph &  g,
Graph &  t,
map< Edge, int, EdgeCompare2 > &  Increment,
int  events,
Node *  v,
Edge  e
[static]
 

Definition at line 171 of file GraphAuxiliary.cpp.

References edgesEqual(), llvm::Graph::getAllNodes(), llvm::Edge::getFirst(), llvm::Graph::getNodeList(), llvm::Edge::getSecond(), llvm::Edge::getWeight(), llvm::Graph::hasEdgeAndWt(), and inc_Dir().

Referenced by getEdgeIncrements().

static int llvm::inc_Dir Edge  e,
Edge  f
[static]
 

Definition at line 151 of file GraphAuxiliary.cpp.

References llvm::Edge::getFirst(), llvm::Edge::getSecond(), and llvm::Edge::isNull().

Referenced by inc_DFS().

void llvm::IncrementCounterInBlock BasicBlock *  BB,
unsigned  CounterNum,
GlobalValue *  CounterArray
 

Definition at line 88 of file ProfilingUtils.cpp.

References Add(), llvm::BasicBlock::begin(), llvm::BinaryOperator::create(), llvm::ConstantInt::get(), llvm::ConstantSInt::get(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), llvm::Type::IntTy, and llvm::Type::UIntTy.

bool llvm::InlineFunction CallSite  CS  ) 
 

Definition at line 39 of file InlineFunction.cpp.

References llvm::Function::abegin(), llvm::PHINode::addIncoming(), llvm::Function::aend(), llvm::CallSite::arg_begin(), llvm::CallSite::arg_end(), llvm::Function::back(), llvm::BasicBlock::begin(), llvm::Function::begin(), llvm::ISD::Br, CloneFunctionInto(), E, llvm::Function::end(), llvm::BasicBlock::eraseFromParent(), llvm::Function::front(), llvm::UndefValue::get(), llvm::Function::getBasicBlockList(), llvm::CallSite::getCalledFunction(), llvm::Function::getFunctionType(), llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), llvm::CallSite::getInstruction(), llvm::Value::getName(), llvm::Instruction::getOpcode(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::Function::getReturnType(), llvm::ReturnInst::getReturnValue(), llvm::BasicBlock::getTerminator(), llvm::Value::getType(), I, llvm::Function::isExternal(), llvm::FunctionType::isVarArg(), PHI, llvm::BasicBlock::removePredecessor(), llvm::Value::replaceAllUsesWith(), llvm::User::setOperand(), and llvm::BasicBlock::splitBasicBlock().

bool llvm::InlineFunction InvokeInst II  ) 
 

Definition at line 28 of file InlineFunction.cpp.

References InlineFunction().

bool llvm::InlineFunction CallInst C  ) 
 

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.

Definition at line 27 of file InlineFunction.cpp.

References InlineFunction().

bool llvm::InlineFunction CallSite  CS  ) 
 

Definition at line 39 of file InlineFunction.cpp.

References llvm::Function::abegin(), llvm::PHINode::addIncoming(), llvm::Function::aend(), llvm::CallSite::arg_begin(), llvm::CallSite::arg_end(), llvm::Function::back(), llvm::Function::begin(), llvm::BasicBlock::begin(), llvm::ISD::Br, CloneFunctionInto(), E, llvm::Function::end(), llvm::BasicBlock::eraseFromParent(), llvm::Function::front(), llvm::UndefValue::get(), llvm::Function::getBasicBlockList(), llvm::CallSite::getCalledFunction(), llvm::Function::getFunctionType(), llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), llvm::CallSite::getInstruction(), llvm::Value::getName(), llvm::Instruction::getOpcode(), llvm::Instruction::getParent(), llvm::BasicBlock::getParent(), llvm::Function::getReturnType(), llvm::ReturnInst::getReturnValue(), llvm::BasicBlock::getTerminator(), llvm::Value::getType(), I, llvm::Function::isExternal(), llvm::FunctionType::isVarArg(), PHI, llvm::BasicBlock::removePredecessor(), llvm::Value::replaceAllUsesWith(), llvm::User::setOperand(), and llvm::BasicBlock::splitBasicBlock().

bool llvm::InlineFunction InvokeInst II  ) 
 

Definition at line 28 of file InlineFunction.cpp.

bool llvm::InlineFunction CallInst C  ) 
 

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.

Definition at line 27 of file InlineFunction.cpp.

Referenced by InlineCallIfPossible(), and InlineFunction().

void llvm::InsertAfter MachineInstr *  newMI,
MachineBasicBlock &  MBB,
MachineBasicBlock::iterator &  MII
[inline]
 

Definition at line 343 of file PhyRegAlloc.cpp.

References llvm::MachineBasicBlock::insert().

Referenced by AppendInstructions().

void llvm::insertBB Edge  ed,
getEdgeCode *  edgeCode,
Instruction *  rInst,
Value *  countInst,
int  n,
int  Methno,
Value *  threshold
 

check if trigger!=null, then add value corresponding to it too!

Definition at line 283 of file EdgeCode.cpp.

References llvm::PHINode::addIncoming(), llvm::ISD::BasicBlock, llvm::BasicBlock::begin(), llvm::BasicBlock::end(), llvm::PHINode::getBasicBlockIndex(), llvm::getEdgeCode::getCode(), llvm::Node::getElement(), llvm::Edge::getFirst(), llvm::PHINode::getIncomingValue(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::GlobalValue::getParent(), llvm::BasicBlock::getParent(), llvm::Edge::getSecond(), llvm::BranchInst::getSuccessor(), llvm::BasicBlock::getTerminator(), getTriggerCode(), llvm::BranchInst::isUnconditional(), llvm::PHINode::setIncomingBlock(), llvm::ISD::SetLE, llvm::BranchInst::setSuccessor(), and llvm::BranchInst::setUnconditionalDest().

Referenced by processGraph().

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 336 of file PhyRegAlloc.cpp.

References llvm::MachineBasicBlock::insert().

Referenced by PrependInstructions().

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 1320 of file SparcV9BurgISel.cpp.

void llvm::insertInTopBB BasicBlock *  front,
int  k,
Instruction *  rVar,
Value *  threshold
 

Definition at line 254 of file EdgeCode.cpp.

References llvm::BasicBlock::begin(), and llvm::BasicBlock::getInstList().

Referenced by llvm::ProfilePaths::runOnFunction().

void llvm::InsertProfilingInitCall Function *  MainFn,
const char *  FnName,
GlobalValue *  Arr = 0
 

Definition at line 23 of file ProfilingUtils.cpp.

References llvm::Function::abegin(), llvm::Function::asize(), 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(), llvm::Type::IntTy, M, llvm::Type::SByteTy, llvm::User::setOperand(), and llvm::Type::UIntTy.

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

Definition at line 138 of file InstIterator.h.

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

Definition at line 136 of file InstIterator.h.

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

Definition at line 130 of file InstIterator.h.

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

Definition at line 128 of file InstIterator.h.

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

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

Definition at line 141 of file InstIterator.h.

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

Definition at line 137 of file InstIterator.h.

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

Definition at line 133 of file InstIterator.h.

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

Definition at line 129 of file InstIterator.h.

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

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().

bool llvm::InterferesWithColor const LiveRange &  LR,
unsigned  color
[inline]
 

Definition at line 279 of file LiveRangeInfo.cpp.

References llvm::IGNode::getAdjIGNode(), llvm::IGNode::getNumOfNeighbors(), and llvm::IGNode::getParentLR().

Referenced by InterfsPreventCoalescing().

bool llvm::InterfsPreventCoalescing const LiveRange &  LROfDef,
const LiveRange &  LROfUse
[inline]
 

Definition at line 298 of file LiveRangeInfo.cpp.

References InterferesWithColor().

Referenced by llvm::LiveRangeInfo::coalesceLRs().

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

Definition at line 248 of file IntervalIterator.h.

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

Definition at line 239 of file IntervalIterator.h.

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

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

Definition at line 252 of file IntervalIterator.h.

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

Definition at line 102 of file PostOrderIterator.h.

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

Definition at line 107 of file PostOrderIterator.h.

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

Definition at line 113 of file Casting.h.

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

Definition at line 51 of file Casting.h.

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

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

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

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

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

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

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

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

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 36 of file PromoteMemoryToRegister.cpp.

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

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 36 of file PromoteMemoryToRegister.cpp.

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

bool llvm::IsArchive const std::string &  FN  ) 
 

IsArchive - Returns true IFF the file named FN appears to be a "ar" library archive. The file named FN must exist.

Definition at line 43 of file FileUtilities.cpp.

References CheckMagic().

Referenced by LinkFiles(), and LinkOneLibrary().

bool llvm::IsArchive const std::string &  FN  ) 
 

IsArchive - Returns true IFF the file named FN appears to be a "ar" library archive. The file named FN must exist.

Definition at line 43 of file FileUtilities.cpp.

References CheckMagic().

Referenced by LinkFiles(), and LinkOneLibrary().

bool llvm::IsBytecode const std::string &  FN  ) 
 

IsBytecode - Returns true IFF the file named FN appears to be an LLVM bytecode file. The file named FN must exist.

Definition at line 52 of file FileUtilities.cpp.

References CheckMagic().

Referenced by LinkFiles().

bool llvm::IsBytecode const std::string &  FN  ) 
 

IsBytecode - Returns true IFF the file named FN appears to be an LLVM bytecode file. The file named FN must exist.

Definition at line 52 of file FileUtilities.cpp.

References CheckMagic().

Referenced by LinkFiles().

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 81 of file BreakCriticalEdges.cpp.

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

Referenced by SplitCriticalEdge().

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 81 of file BreakCriticalEdges.cpp.

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

Referenced by SplitCriticalEdge().

bool llvm::isCurrentDebugType const char *  DebugType  ) 
 

Definition at line 59 of file Debug.cpp.

References CurrentDebugType.

bool llvm::isCurrentDebugType const char *  Type  ) 
 

Definition at line 59 of file Debug.cpp.

References CurrentDebugType.

bool llvm::isExecutableFile const std::string &  ExeFileName  ) 
 

isExecutableFile - This function returns true if the filename specified exists and is executable.

Definition at line 36 of file SystemUtils.cpp.

Referenced by FindExecutable().

bool llvm::isExecutableFile const std::string &  ExeFileName  ) 
 

isExecutableFile - This function returns true if the filename specified exists and is executable.

Definition at line 36 of file SystemUtils.cpp.

Referenced by FindExecutable().

int llvm::IsInf double  d  ) 
 

Definition at line 39 of file IsInf.cpp.

int llvm::IsInf float  f  ) 
 

Definition at line 38 of file IsInf.cpp.

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 321 of file Transforms/Utils/Local.cpp.

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

Referenced by dceInstruction(), and ErasePossiblyDeadInstructionTree().

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 321 of file Transforms/Utils/Local.cpp.

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

Referenced by dceInstruction(), and ErasePossiblyDeadInstructionTree().

static bool llvm::IsLibrary Path &  path,
const std::string &  basename
[inline, static]
 

Definition at line 50 of file Unix/Path.cpp.

References llvm::sys::Path::appendFile(), llvm::sys::Path::appendSuffix(), llvm::sys::Path::clear(), llvm::sys::Path::elideFile(), llvm::sys::Path::elideSuffix(), llvm::sys::Path::GetDLLSuffix(), and llvm::sys::Path::readable().

int llvm::IsNAN double  d  ) 
 

Definition at line 32 of file IsNAN.cpp.

int llvm::IsNAN float  f  ) 
 

Definition at line 31 of file IsNAN.cpp.

Referenced by ConstantFoldCall().

bool llvm::isPowerOf2 int64_t  C,
unsigned &  getPow
[inline]
 

Definition at line 39 of file MathExtras.h.

References log2().

bool llvm::IsSharedObject const std::string &  FN  ) 
 

IsSharedObject - Returns trus IFF the file named FN appears to be a shared object with an ELF header. The file named FN must exist.

Definition at line 61 of file FileUtilities.cpp.

References CheckMagic().

bool llvm::IsSharedObject const std::string &  FN  ) 
 

IsSharedObject - Returns trus IFF the file named FN appears to be a shared object with an ELF header. The file named FN must exist.

Definition at line 61 of file FileUtilities.cpp.

References CheckMagic().

bool llvm::isStandardOutAConsole  ) 
 

isStandardOutAConsole - Return true if we can tell that the standard output stream goes to a terminal window or console.

Definition at line 54 of file SystemUtils.cpp.

bool llvm::isStandardOutAConsole  ) 
 

isStandardOutAConsole - Return true if we can tell that the standard output stream goes to a terminal window or console.

Definition at line 54 of file SystemUtils.cpp.

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(), and llvm::MachineOperand::MO_SignExtendedImmed.

Referenced by RemoveUselessCopies().

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().

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().

static bool llvm::IsZero Value idx  )  [inline, static]
 

IsZero - Check for a constant 0.

Definition at line 1588 of file SparcV9BurgISel.cpp.

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

Definition at line 93 of file StringExtras.h.

References utostr().

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

Definition at line 86 of file StringExtras.h.

References utostr().

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< MSchedGraph * >::getEdgeSourceLabel(), llvm::ValID::getName(), getValNonImprovising(), llvm::Debugger::nextProgram(), llvm::BytecodeReader::ParseVersionInfo(), ResolveDefinitions(), ResolveTypes(), and llvm::Debugger::stepProgram().

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().

bool llvm::LinkFiles const char *  progname,
Module HeadModule,
const std::vector< std::string > &  Files,
bool  Verbose
 

LinkFiles - takes a module and a list of files and links them all together. It locates the file either in the current directory, as its absolute or relative pathname, or as a file somewhere in LLVM_LIB_SEARCH_PATH.

Inputs: progname - The name of the program (infamous argv[0]). HeadModule - The module under which all files will be linked. Files - A vector of C++ strings indicating the LLVM bytecode filenames to be linked. The names can refer to a mixture of pure LLVM bytecode files and archive (ar) formatted files. Verbose - Flags whether verbose output should be printed while linking.

Outputs: HeadModule - The module will have the specified LLVM bytecode files linked in.

Return value: FALSE - No errors. TRUE - Some error occurred.

Parameters:
progname  Name of the program being linked (for output)
HeadModule  Main (resulting) module to be linked into
Files  Files to link in
Verbose  Link verbosely, indicating each action

Definition at line 294 of file LinkArchives.cpp.

References FileOpenable(), IsArchive(), IsBytecode(), LinkInArchive(), and LinkInFile().

Referenced by LinkItems().

bool llvm::LinkFiles const char *  progname,
Module HeadModule,
const std::vector< std::string > &  Files,
bool  Verbose
 

LinkFiles - takes a module and a list of files and links them all together. It locates the file either in the current directory, as its absolute or relative pathname, or as a file somewhere in LLVM_LIB_SEARCH_PATH.

Inputs: progname - The name of the program (infamous argv[0]). HeadModule - The module under which all files will be linked. Files - A vector of C++ strings indicating the LLVM bytecode filenames to be linked. The names can refer to a mixture of pure LLVM bytecode files and archive (ar) formatted files. Verbose - Flags whether verbose output should be printed while linking.

Outputs: HeadModule - The module will have the specified LLVM bytecode files linked in.

Return value: FALSE - No errors. TRUE - Some error occurred.

Parameters:
progname  Name of the program being linked (for output)
HeadModule  Main (resulting) module to be linked into
Files  Files to link in
Verbose  Link verbosely, indicating each action

Definition at line 294 of file LinkArchives.cpp.

References FileOpenable(), IsArchive(), IsBytecode(), LinkInArchive(), and LinkInFile().

Referenced by LinkItems().

bool llvm::LinkInArchive Module M,
const std::string &  Filename,
std::string *  ErrorMessage,
bool  Verbose
 

Link in one archive.

LinkInArchive - opens an archive library and link in all objects which provide symbols that are currently undefined.

Inputs: M - The module in which to link the archives. Filename - The pathname of the archive. Verbose - Flags whether verbose messages should be printed.

Outputs: ErrorMessage - A C++ string detailing what error occurred, if any.

Return Value: TRUE - An error occurred. FALSE - No errors.

Parameters:
M  Main (resulting) module to be linked into
Filename  Filename of the archive to link
ErrorMessage  Error message if an error occurs.
Verbose  Link verbosely, indicating each action

Definition at line 167 of file LinkArchives.cpp.

References E, llvm::Archive::findModulesDefiningSymbols(), GetAllUndefinedSymbols(), I, LinkModules(), and llvm::Archive::OpenAndLoadSymbols().

Referenced by LinkFiles(), and LinkOneLibrary().

bool llvm::LinkInArchive Module M,
const std::string &  Filename,
std::string *  ErrorMessage,
bool  Verbose
 

Link in one archive.

LinkInArchive - opens an archive library and link in all objects which provide symbols that are currently undefined.

Inputs: M - The module in which to link the archives. Filename - The pathname of the archive. Verbose - Flags whether verbose messages should be printed.

Outputs: ErrorMessage - A C++ string detailing what error occurred, if any.

Return Value: TRUE - An error occurred. FALSE - No errors.

Parameters:
M  Main (resulting) module to be linked into
Filename  Filename of the archive to link
ErrorMessage  Error message if an error occurs.
Verbose  Link verbosely, indicating each action

Definition at line 167 of file LinkArchives.cpp.

References E, llvm::Archive::findModulesDefiningSymbols(), GetAllUndefinedSymbols(), I, LinkModules(), and llvm::Archive::OpenAndLoadSymbols().

Referenced by LinkFiles(), and LinkOneLibrary().

Module* llvm::LinkItems const char *  progname,
const LinkItemList Items,
const std::vector< std::string > &  LibPaths,
bool  Verbose,
bool  Native
 

This function can be used to link a set of linkage items into a module. A linkage item is one of the three things identified by the LinkItemKind enumeration. This function allows linking to preserve the order of specification associated with a command line, or for other purposes. Each item will be linked in turn as it occurs in Items. Note that library path items will only be in effect after they have been processed.

Returns:
The aggregated/linked Module.
Exceptions:
nothing 
Parameters:
progname  Name of the program being linked (for output)
Verbose  Link verbosely, indicating each action
Native  Linking is for a native executable

Definition at line 81 of file LinkItems.cpp.

References llvm::SetVector< T >::begin(), E, llvm::SetVector< T >::end(), I, LinkFiles(), and LinkOneLibrary().

Module* llvm::LinkItems const char *  progname,
const LinkItemList Items,
const std::vector< std::string > &  LibPaths,
bool  Verbose,
bool  Native
 

This function can be used to link a set of linkage items into a module. A linkage item is one of the three things identified by the LinkItemKind enumeration. This function allows linking to preserve the order of specification associated with a command line, or for other purposes. Each item will be linked in turn as it occurs in Items. Note that library path items will only be in effect after they have been processed.

Returns:
The aggregated/linked Module.
Exceptions:
nothing 
Parameters:
progname  Name of the program being linked (for output)
Verbose  Link verbosely, indicating each action
Native  Linking is for a native executable

Definition at line 81 of file LinkItems.cpp.

References llvm::SetVector< T >::begin(), E, llvm::SetVector< T >::end(), I, LinkFiles(), and LinkOneLibrary().

void llvm::LinkLibraries const char *  progname,
Module HeadModule,
const std::vector< std::string > &  Libraries,
const std::vector< std::string > &  LibPaths,
bool  Verbose,
bool  Native
 

Link libraries into a module.

LinkLibraries - takes the specified library files and links them into the main bytecode object file.

Inputs: progname - The name of the program (infamous argv[0]). HeadModule - The module into which all necessary libraries will be linked. Libraries - The list of libraries to link into the module. LibPaths - The list of library paths in which to find libraries. Verbose - Flags whether verbose messages should be printed. Native - Flags whether native code is being generated.

Outputs: HeadModule - The module will have all necessary libraries linked in.

Return value: FALSE - No error. TRUE - Error.

Parameters:
progname  Name of the program being linked (for output)
HeadModule  Main (resulting) module to be linked into
Libraries  Set of libraries to link in
LibPaths  Set of library paths
Verbose  Link verbosely, indicating each action
Native  Linking is for a native executable

Definition at line 413 of file LinkArchives.cpp.

References llvm::SetVector< T >::begin(), E, llvm::SetVector< T >::end(), llvm::Module::getLibraries(), I, and LinkOneLibrary().

void llvm::LinkLibraries const char *  progname,
Module HeadModule,
const std::vector< std::string > &  Libraries,
const std::vector< std::string > &  LibPaths,
bool  Verbose,
bool  Native
 

Link libraries into a module.

LinkLibraries - takes the specified library files and links them into the main bytecode object file.

Inputs: progname - The name of the program (infamous argv[0]). HeadModule - The module into which all necessary libraries will be linked. Libraries - The list of libraries to link into the module. LibPaths - The list of library paths in which to find libraries. Verbose - Flags whether verbose messages should be printed. Native - Flags whether native code is being generated.

Outputs: HeadModule - The module will have all necessary libraries linked in.

Return value: FALSE - No error. TRUE - Error.

Parameters:
progname  Name of the program being linked (for output)
HeadModule  Main (resulting) module to be linked into
Libraries  Set of libraries to link in
LibPaths  Set of library paths
Verbose  Link verbosely, indicating each action
Native  Linking is for a native executable

Definition at line 413 of file LinkArchives.cpp.

References llvm::SetVector< T >::begin(), E, llvm::SetVector< T >::end(), llvm::Module::getLibraries(), I, and LinkOneLibrary().

bool llvm::LinkModules Module Dest,
Module Src,
std::string *  ErrorMsg
 

Link two modules together.

This is the heart of the linker. The Src module is linked into the Dest module. If an error occurs, true is returned, otherwise false. If ErrorMsg is not null and an error occurs, *ErrorMsg will be set to a readable string that indicates the nature of the error. Note that this can destroy the Src module in arbitrary ways.

Returns:
true if there's an error
Parameters:
Dest  Module into which Src is linked
Src  Module linked into Dest
ErrorMsg  Optional error message string

Definition at line 824 of file LinkModules.cpp.

References llvm::Module::addLibrary(), llvm::Module::AnyEndianness, llvm::Module::AnyPointerSize, llvm::Module::begin(), E, llvm::Module::end(), llvm::Module::gbegin(), llvm::Module::gend(), llvm::sys::Path::getBasename(), llvm::Module::getEndianness(), llvm::Module::getModuleIdentifier(), llvm::Module::getPointerSize(), I, llvm::sys::Path::isEmpty(), llvm::Module::lib_begin(), llvm::Module::lib_end(), LinkAppendingVars(), LinkFunctionBodies(), LinkFunctionProtos(), LinkGlobalInits(), LinkGlobals(), LinkTypes(), llvm::Module::removeLibrary(), llvm::Module::setEndianness(), llvm::sys::Path::setFile(), and llvm::Module::setPointerSize().

Referenced by LinkInArchive(), and LinkInFile().

bool llvm::LinkModules Module Dest,
Module Src,
std::string *  ErrorMsg
 

Link two modules together.

This is the heart of the linker. The Src module is linked into the Dest module. If an error occurs, true is returned, otherwise false. If ErrorMsg is not null and an error occurs, *ErrorMsg will be set to a readable string that indicates the nature of the error. Note that this can destroy the Src module in arbitrary ways.

Returns:
true if there's an error
Parameters:
Dest  Module into which Src is linked
Src  Module linked into Dest
ErrorMsg  Optional error message string

Definition at line 824 of file LinkModules.cpp.

References llvm::Module::addLibrary(), llvm::Module::AnyEndianness, llvm::Module::AnyPointerSize, llvm::Module::begin(), E, llvm::Module::end(), llvm::Module::gbegin(), llvm::Module::gend(), llvm::sys::Path::getBasename(), llvm::Module::getEndianness(), llvm::Module::getModuleIdentifier(), llvm::Module::getPointerSize(), I, llvm::sys::Path::isEmpty(), llvm::Module::lib_begin(), llvm::Module::lib_end(), LinkAppendingVars(), LinkFunctionBodies(), LinkFunctionProtos(), LinkGlobalInits(), LinkGlobals(), LinkTypes(), llvm::Module::removeLibrary(), llvm::Module::setEndianness(), llvm::sys::Path::setFile(), and llvm::Module::setPointerSize().

Referenced by LinkInArchive(), and LinkInFile().

unsigned llvm::log2 unsigned  C  )  [inline]
 

Definition at line 32 of file MathExtras.h.

unsigned llvm::log2 uint64_t  C  )  [inline]
 

Definition at line 25 of file MathExtras.h.

Referenced by llvm::TargetData::getTypeAlignmentShift(), and isPowerOf2().

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

Definition at line 106 of file StringExtras.h.

template<typename T>
std::vector<T> llvm::make_vector 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 27 of file VectorExtras.h.

bool llvm::MakeFileExecutable const std::string &  Filename  ) 
 

MakeFileExecutable - Make the file named Filename executable by setting whichever execute permissions bits the process's current umask would allow. Filename must name an existing file or directory. Returns true on success, false on error.

Definition at line 239 of file FileUtilities.cpp.

References AddPermissionsBits().

bool llvm::MakeFileExecutable const std::string &  Filename  ) 
 

MakeFileExecutable - Make the file named Filename executable by setting whichever execute permissions bits the process's current umask would allow. Filename must name an existing file or directory. Returns true on success, false on error.

Definition at line 239 of file FileUtilities.cpp.

References AddPermissionsBits().

bool llvm::MakeFileReadable const std::string &  Filename  ) 
 

MakeFileReadable - Make the file named Filename readable by setting whichever read permissions bits the process's current umask would allow. Filename must name an existing file or directory. Returns true on success, false on error.

Definition at line 248 of file FileUtilities.cpp.

References AddPermissionsBits().

bool llvm::MakeFileReadable const std::string &  Filename  ) 
 

MakeFileReadable - Make the file named Filename readable by setting whichever read permissions bits the process's current umask would allow. Filename must name an existing file or directory. Returns true on success, false on error.

Definition at line 248 of file FileUtilities.cpp.

References AddPermissionsBits().

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

Definition at line 149 of file STLExtras.h.

Referenced by mapto(), 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< const DSGraph * >::nodes_begin(), llvm::GraphTraits< DSGraph * >::nodes_begin(), llvm::GraphTraits< CallGraph * >::nodes_begin(), 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< const DSGraph * >::nodes_end(), llvm::GraphTraits< DSGraph * >::nodes_end(), and llvm::GraphTraits< CallGraph * >::nodes_end().

template<class InIt, class OutIt, class Functor>
OutIt llvm::mapto InIt  Begin,
InIt  End,
OutIt  Dest,
Functor  F
[inline]
 

Definition at line 258 of file STLExtras.h.

References map_iterator().

Value* llvm::MapValue const Value *  V,
ValueMapTy VM
 

Value* llvm::MapValue const Value V,
std::map< const Value *, Value * > &  VM
 

Definition at line 23 of file ValueMapper.cpp.

References C, llvm::Instruction::Cast, llvm::ConstantExpr::get(), llvm::ConstantStruct::get(), llvm::ConstantArray::get(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getGetElementPtr(), llvm::ConstantExpr::getSelect(), llvm::Value::getType(), and llvm::Instruction::Select.

Referenced by CloneModule(), and RemapInstruction().

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().

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 993 of file PhyRegAlloc.cpp.

References llvm::SparcV9RegInfo::getClassRegNum(), llvm::RegClass::getID(), and llvm::RegClass::markColorsUsed().

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 void llvm::moveDummyCode vector< Edge > &  stDummy,
vector< Edge > &  exDummy,
vector< Edge > &  be,
map< Edge, getEdgeCode *, EdgeCompare2 > &  insertions,
Graph &  g
[static]
 

---new code

Definition at line 423 of file GraphAuxiliary.cpp.

References llvm::Graph::getExit(), llvm::Edge::getFirst(), llvm::Edge::getRandId(), llvm::Graph::getRoot(), llvm::Edge::getSecond(), and llvm::Graph::removeEdgeWithWt().

Referenced by processGraph().

void llvm::MoveFileOverIfUpdated const std::string &  New,
const std::string &  Old
 

MoveFileOverIfUpdated - If the file specified by New is different than Old, or if Old does not exist, move the New file over the Old file. Otherwise, remove the New file.

Definition at line 154 of file FileUtilities.cpp.

References DiffFiles().

void llvm::MoveFileOverIfUpdated const std::string &  New,
const std::string &  Old
 

MoveFileOverIfUpdated - If the file specified by New is different than Old, or if Old does not exist, move the New file over the Old file. Otherwise, remove the New file.

Definition at line 154 of file FileUtilities.cpp.

References DiffFiles().

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

Definition at line 70 of file SchedPriorities.h.

References llvm::NodeDelayPair::delay.

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

Definition at line 170 of file STLExtras.h.

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

Definition at line 163 of file STLExtras.h.

Referenced by llvm::sys::Path::createDirectory(), lt_dlexit(), lt_dlloader_next(), and llvm::LiveInterval::removeRange().

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().

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

Definition at line 58 of file TypeInfo.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 139 of file STLExtras.h.

References llvm::mapped_iterator< RootIt, UnaryFunc >::getCurrent().

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

Definition at line 61 of file LiveInterval.h.

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

Definition at line 54 of file TypeInfo.h.

References llvm::TypeInfo::before().

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

Definition at line 1304 of file Type.cpp.

References llvm::Type::print().

static std::ostream& llvm::operator<< std::ostream &  o,
const std::set< BasicBlock * > &  BBs
[static]
 

Definition at line 304 of file Dominators.cpp.

References E, I, and WriteAsOperand().

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.

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

Definition at line 168 of file MSchedGraph.h.

References llvm::MSchedGraphNode::print().

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.

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

Definition at line 144 of file VirtRegMap.h.

References llvm::VirtRegMap::print().

std::ostream & llvm::operator<< std::ostream &  os,
const LiveInterval li
 

Definition at line 355 of file LiveInterval.cpp.

References llvm::LiveInterval::empty(), llvm::LiveInterval::ranges, llvm::LiveInterval::reg, and llvm::LiveInterval::weight.

static std::ostream & llvm::operator<< std::ostream &  os,
const LiveRange lr
[inline]
 

Definition at line 346 of file LiveInterval.cpp.

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

Definition at line 155 of file Value.h.

References llvm::Value::print().

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

Definition at line 1312 of file Type.cpp.

References llvm::Type::print().

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

Definition at line 150 of file ConstantRange.h.

References llvm::ConstantRange::print().

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

Definition at line 205 of file Pass.h.

References llvm::Pass::print().

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

Definition at line 269 of file Module.h.

References llvm::Module::print().

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

Definition at line 264 of file Module.h.

References llvm::Module::print().

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 llvm::RAV::V.

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

Definition at line 194 of file SchedGraphCommon.h.

References llvm::SchedGraphEdge::print().

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 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::Value::getName(), llvm::MachineOperand::getReg(), llvm::MachineOperand::getSymbolName(), llvm::MachineOperand::getType(), llvm::MachineOperand::getVRegValue(), llvm::MachineOperand::hasAllocatedReg(), llvm::Value::hasName(), 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().

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::MachineInstr::getParent(), llvm::MachineFunction::getTarget(), llvm::MachineOperand::isDef(), llvm::MachineOperand::isUse(), llvm::TargetInstrDescriptor::Name, OutputValue(), llvm::MachineInstr::print(), and TargetInstrDescriptors.

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

std::ostream inserter for BytecodeAnalysis structure

Definition at line 136 of file Analyzer.h.

References PrintBytecodeAnalysis().

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

Definition at line 87 of file ScalarEvolution.h.

References llvm::SCEV::print().

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

Definition at line 370 of file AliasSetTracker.h.

References llvm::AliasSetTracker::print().

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 &  O,
const BitSetVector &  bset
[inline]
 

Definition at line 251 of file BitSetVector.h.

References llvm::BitSetVector::print().

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 50 of file TypeInfo.h.

References llvm::TypeInfo::get().

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 70 of file TypeInfo.h.

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

Definition at line 21 of file Parser.cpp.

References F, and RunVMAsmParser().

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

Definition at line 21 of file Parser.cpp.

References F, and RunVMAsmParser().

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 258 of file ReaderWrappers.cpp.

References getBytecodeBufferModuleProvider().

Referenced by llvm::Archive::getAllModules().

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 258 of file ReaderWrappers.cpp.

References getBytecodeBufferModuleProvider().

Referenced by llvm::Archive::getAllModules().

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

Parse the given bytecode file.

ParseBytecodeFile - Parse the given bytecode file

Definition at line 283 of file ReaderWrappers.cpp.

References getBytecodeModuleProvider().

Referenced by LoadObject().

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

Parse the given bytecode file.

ParseBytecodeFile - Parse the given bytecode file

Definition at line 283 of file ReaderWrappers.cpp.

References getBytecodeModuleProvider().

Referenced by LoadObject().

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

Definition at line 91 of file PostOrderIterator.h.

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

Definition at line 93 of file PostOrderIterator.h.

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_iterator llvm::pred_begin SchedGraphNode *  N  )  [inline]
 

Definition at line 193 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::beginInEdges().

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

Definition at line 79 of file CFG.h.

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

Definition at line 78 of file CFG.h.

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

Definition at line 117 of file Interval.h.

References llvm::Interval::Predecessors.

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

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

Definition at line 202 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::endInEdges().

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

Definition at line 196 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::endInEdges().

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

Definition at line 83 of file CFG.h.

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

Definition at line 82 of file CFG.h.

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(), 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::getLoopPreheader(), llvm::Loop::getNumBackEdges(), isCriticalEdge(), llvm::Interval::isLoop(), isPathTransparentTo(), isValueEqualityComparison(), MarkSuccessorsReady(), PropagatePredecessorsForPHIs(), llvm::BasicBlock::removePredecessor(), RequiresFPRegKill(), llvm::DominatorSet::runOnFunction(), llvm::ImmediateDominators::runOnFunction(), and SimplifyCFG().

void llvm::PrependInstructions std::vector< MachineInstr * > &  IBef,
MachineBasicBlock &  MBB,
MachineBasicBlock::iterator &  MII,
const std::string &  msg
[inline]
 

Definition at line 350 of file PhyRegAlloc.cpp.

References InsertBefore().

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 620 of file Analyzer.cpp.

References 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<<().

void llvm::printEdge Edge  ed  ) 
 

Definition at line 414 of file GraphAuxiliary.cpp.

References llvm::Edge::getFirst(), llvm::Edge::getRandId(), llvm::Edge::getSecond(), and llvm::Edge::getWeight().

Referenced by llvm::Graph::getMaxSpanningTree(), llvm::Graph::makeUnDirectional(), processGraph(), and llvm::ProfilePaths::runOnFunction().

void llvm::printGraph Graph &  g  ) 
 

Definition at line 661 of file GraphAuxiliary.cpp.

References llvm::Graph::getAllNodes(), and llvm::Graph::getNodeList().

Referenced by processGraph(), and llvm::ProfilePaths::runOnFunction().

void llvm::PrintMachineInstructions const Function *  F  ) 
 

static void llvm::printNode Node *  nd  )  [static]
 

Definition at line 335 of file Graph.cpp.

References llvm::Node::getElement(), and llvm::Value::getName().

Referenced by llvm::Graph::getMaxSpanningTree().

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().

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

Definition at line 184 of file STLExtras.h.

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

Definition at line 177 of file STLExtras.h.

Referenced by DeleteInstruction(), llvm::X86RegisterInfo::emitEpilogue(), llvm::PPC64RegisterInfo::emitEpilogue(), llvm::PPC32RegisterInfo::emitEpilogue(), and llvm::LiveInterval::getLiveRangeContaining().

void llvm::processGraph Graph &  g,
Instruction *  rInst,
Value *  countInst,
vector< Edge > &  be,
vector< Edge > &  stDummy,
vector< Edge > &  exDummy,
int  numPaths,
int  MethNo,
Value *  threshold
 

Definition at line 487 of file GraphAuxiliary.cpp.

References llvm::Graph::addEdge(), DEBUG, llvm::Edge::first, llvm::SparcV9::g2, getChords(), getCodeInsertions(), getEdgeIncrements(), llvm::Graph::getExit(), llvm::Graph::getMaxSpanningTree(), llvm::Graph::getRoot(), llvm::Graph::hasEdge(), insertBB(), llvm::Graph::makeUnDirectional(), moveDummyCode(), printEdge(), printGraph(), llvm::Graph::removeEdge(), removeTreeEdges(), llvm::Graph::reverseWts(), and llvm::Edge::second.

void llvm::processGraph Graph &  g,
Instruction *  rInst,
Value *  countInst,
std::vector< Edge > &  be,
std::vector< Edge > &  stDummy,
std::vector< Edge > &  exDummy,
int  n,
int  MethNo,
Value *  threshold
 

Referenced by llvm::ProfilePaths::runOnFunction().

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 625 of file PromoteMemoryToRegister.cpp.

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 625 of file PromoteMemoryToRegister.cpp.

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::ReadFileIntoAddressSpace const std::string &  Filename,
unsigned &  Length
 

ReadFileIntoAddressSpace - Attempt to map the specific file into the address space of the current process for reading. If this succeeds, return the address of the buffer and the length of the file mapped. On failure, return null.

Definition at line 276 of file FileUtilities.cpp.

References getFileSize().

void* llvm::ReadFileIntoAddressSpace const std::string &  Filename,
unsigned &  Length
 

ReadFileIntoAddressSpace - Attempt to map the specific file into the address space of the current process for reading. If this succeeds, return the address of the buffer and the length of the file mapped. On failure, return null.

Definition at line 276 of file FileUtilities.cpp.

References getFileSize().

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, llvm::ISD::PHI, llvm::MachineBasicBlock::push_back(), llvm::MachineBasicBlock::remove(), and llvm::SchedulingManager::schedInfo.

template<class InputIt, class Function, class ValueType>
ValueType llvm::reduce InputIt  First,
InputIt  Last,
Function  Func,
ValueType  Value
 

Definition at line 211 of file STLExtras.h.

template<class InputIt, class Function, class ValueType, class TransFunc>
ValueType llvm::reduce_apply InputIt  First,
InputIt  Last,
Function  Func,
ValueType  Value,
TransFunc  XForm
[inline]
 

Definition at line 223 of file STLExtras.h.

Referenced by reduce_apply_bool().

template<class InputIt, class Function>
bool llvm::reduce_apply_bool InputIt  First,
InputIt  Last,
Function  Func
[inline]
 

Definition at line 249 of file STLExtras.h.

References reduce_apply().

static void llvm::RegisterHandler  )  [static]
 

Definition at line 51 of file Win32/Signals.cpp.

References CriticalSection, LLVMConsoleCtrlHandler(), LLVMUnhandledExceptionFilter(), OldFilter, and RegisteredUnhandledExceptionFilter.

Referenced by llvm::sys::PrintStackTraceOnErrorSignal(), llvm::sys::RemoveDirectoryOnSignal(), and llvm::sys::RemoveFileOnSignal().

void llvm::RemapInstruction Instruction *  I,
ValueMapTy VM
 

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 110 of file ValueMapper.cpp.

References E, llvm::User::getNumOperands(), llvm::User::getOperand(), MapValue(), llvm::User::setOperand(), and V.

Referenced by CloneFunctionInto(), and CloneTraceInto().

void llvm::removeFile const std::string &  Filename  ) 
 

removeFile - Delete the specified file

Definition at line 166 of file FileUtilities.cpp.

Referenced by llvm::LLC::compileProgram(), llvm::CBE::compileProgram(), ProcessFailure(), and llvm::FileRemover::~FileRemover().

void llvm::removeFile const std::string &  Filename  ) 
 

removeFile - Delete the specified file

Definition at line 166 of file FileUtilities.cpp.

Referenced by llvm::CBE::compileProgram(), llvm::LLC::compileProgram(), ProcessFailure(), and llvm::FileRemover::~FileRemover().

void llvm::RemoveSuccessor TerminatorInst TI,
unsigned  SuccNum
 

Definition at line 77 of file BasicBlockUtils.cpp.

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

void llvm::RemoveSuccessor TerminatorInst TI,
unsigned  SuccNum
 

Definition at line 77 of file BasicBlockUtils.cpp.

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

static void llvm::removeTreeEdges Graph &  g,
Graph &  t
[static]
 

Definition at line 58 of file GraphAuxiliary.cpp.

References llvm::Graph::getAllNodes(), llvm::Graph::getNodeList(), llvm::Graph::hasEdgeAndWt(), and llvm::Graph::removeEdge().

Referenced by processGraph().

bool llvm::RemoveUselessCopies MachineBasicBlock &  mvec,
MachineBasicBlock::iterator &  BBI,
const TargetMachine &  target
[inline]
 

Definition at line 99 of file SparcV9PeepholeOpts.cpp.

References DeleteInstruction(), and IsUselessCopy().

void llvm::ReplaceInstWithInst Instruction From,
Instruction To
 

Definition at line 65 of file BasicBlockUtils.cpp.

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

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

Definition at line 47 of file BasicBlockUtils.cpp.

References llvm::Instruction::getParent(), and ReplaceInstWithValue().

void llvm::ReplaceInstWithInst Instruction From,
Instruction To
 

Definition at line 65 of file BasicBlockUtils.cpp.

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

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

Definition at line 47 of file BasicBlockUtils.cpp.

Referenced by HandleCastToPointer(), PeepholeOptimizeAddCast(), RemoveSuccessor(), and ReplaceInstWithInst().

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

Definition at line 26 of file BasicBlockUtils.cpp.

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

Referenced by ReplaceInstWithInst().

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

Definition at line 26 of file BasicBlockUtils.cpp.

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

Referenced by ReplaceInstWithInst().

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(), and MarkNodeForDelaySlot().

Referenced by ChooseInstructionsForDelaySlots().

int llvm::RunProgramWithTimeout const std::string &  ProgramPath,
const char **  Args,
const std::string &  StdInFile,
const std::string &  StdOutFile,
const std::string &  StdErrFile,
unsigned  NumSeconds
 

RunProgramWithTimeout - This function executes the specified program, with the specified null-terminated argument array, with the stdin/out/err fd's redirected, with a timeout specified by the last argument. This terminates the calling program if there is an error executing the specified program. It returns the return value of the program, or -1 if a timeout is detected.

Definition at line 140 of file SystemUtils.cpp.

References RedirectFD(), Timeout, and TimeOutHandler().

Referenced by llvm::GCC::ExecuteProgram(), llvm::GCC::MakeSharedObject(), llvm::LLC::OutputAsm(), llvm::CBE::OutputC(), and ProcessFailure().

int llvm::RunProgramWithTimeout const std::string &  ProgramPath,
const char **  Args,
const std::string &  StdInFile,
const std::string &  StdOutFile,
const std::string &  StdErrFile,
unsigned  NumSeconds
 

RunProgramWithTimeout - This function executes the specified program, with the specified null-terminated argument array, with the stdin/out/err fd's redirected, with a timeout specified by the last argument. This terminates the calling program if there is an error executing the specified program. It returns the return value of the program, or -1 if a timeout is detected.

Definition at line 140 of file SystemUtils.cpp.

References RedirectFD(), Timeout, and TimeOutHandler().

Referenced by llvm::GCC::ExecuteProgram(), llvm::GCC::MakeSharedObject(), llvm::LLC::OutputAsm(), llvm::CBE::OutputC(), and ProcessFailure().

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

Definition at line 975 of file llvmAsmParser.cpp.

References CurFilename, CurModule, PerModuleInfo::CurrentModule, llvm::Module::getFunctionList(), llvm::BasicBlock::getInstList(), llvm::Module::getNamedFunction(), llvm::User::getOperand(), llvm::Module::getOrInsertFunction(), llvm::Instruction::getParent(), llvmAsmin, llvmAsmlineno, ObsoleteVarArgs, V, llvm::Type::VoidTy, and yyparse.

Referenced by ParseAssemblyFile().

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

Definition at line 188 of file SCCIterator.h.

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

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

Definition at line 193 of file SCCIterator.h.

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

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.

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.

Referenced by llvm::PostDominatorSet::runOnFunction().

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.

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.

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

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 2633 of file SparcV9BurgISel.cpp.

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 649 of file Utils/SimplifyCFG.cpp.

References llvm::SwitchInst::addCase(), llvm::PHINode::addIncoming(), AddPredecessorToBlock(), llvm::ISD::And, llvm::BasicBlock::back(), llvm::BasicBlock::begin(), llvm::ISD::BrCond, llvm::BinaryOperator::clone(), llvm::TerminatorInst::clone(), ConstantFoldTerminator(), llvm::BinaryOperator::create(), llvm::BinaryOperator::createNot(), DEBUG, DominatesMergePoint(), E, llvm::BasicBlock::empty(), llvm::BasicBlock::end(), llvm::BasicBlock::eraseFromParent(), ErasePossiblyDeadInstructionTree(), FoldValueComparisonIntoPredecessors(), llvm::BasicBlock::front(), llvm::Function::front(), GatherValueComparisons(), llvm::Function::getBasicBlockList(), llvm::BranchInst::getCondition(), GetIfCondition(), llvm::PHINode::getIncomingValue(), llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::Instruction::getNext(), llvm::Constant::getNullValue(), llvm::User::getNumOperands(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::Instruction::getParent(), llvm::BasicBlock::getParent(), llvm::BranchInst::getSuccessor(), llvm::BasicBlock::getTerminator(), llvm::Value::getType(), llvm::Value::hasName(), llvm::Value::hasOneUse(), HoistThenElseCodeToIf(), I, llvm::Type::isInteger(), isValueEqualityComparison(), M, llvm::ISD::Or, pred_begin(), pred_end(), PropagatePredecessorsForPHIs(), llvm::BasicBlock::removePredecessor(), llvm::Value::replaceAllUsesWith(), SafeToMergeTerminators(), llvm::Instruction::setName(), llvm::BasicBlock::setName(), llvm::User::setOperand(), SimplifyCFG(), succ_begin(), succ_end(), and llvm::Value::use_empty().

Referenced by SimplifyCFG().

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 649 of file Utils/SimplifyCFG.cpp.

References llvm::SwitchInst::addCase(), llvm::PHINode::addIncoming(), AddPredecessorToBlock(), llvm::ISD::And, llvm::BasicBlock::back(), llvm::BasicBlock::begin(), llvm::ISD::BrCond, llvm::TerminatorInst::clone(), llvm::BinaryOperator::clone(), ConstantFoldTerminator(), llvm::BinaryOperator::create(), llvm::BinaryOperator::createNot(), DEBUG, DominatesMergePoint(), E, llvm::BasicBlock::empty(), llvm::BasicBlock::end(), llvm::BasicBlock::eraseFromParent(), ErasePossiblyDeadInstructionTree(), FoldValueComparisonIntoPredecessors(), llvm::Function::front(), llvm::BasicBlock::front(), GatherValueComparisons(), llvm::Function::getBasicBlockList(), llvm::BranchInst::getCondition(), GetIfCondition(), llvm::PHINode::getIncomingValue(), llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::Instruction::getNext(), llvm::Constant::getNullValue(), llvm::User::getNumOperands(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::BranchInst::getSuccessor(), llvm::BasicBlock::getTerminator(), llvm::Value::getType(), llvm::Value::hasName(), llvm::Value::hasOneUse(), HoistThenElseCodeToIf(), I, llvm::Type::isInteger(), isValueEqualityComparison(), M, llvm::ISD::Or, pred_begin(), pred_end(), PropagatePredecessorsForPHIs(), llvm::BasicBlock::removePredecessor(), llvm::Value::replaceAllUsesWith(), SafeToMergeTerminators(), llvm::BasicBlock::setName(), llvm::Instruction::setName(), llvm::User::setOperand(), SimplifyCFG(), succ_begin(), succ_end(), and llvm::Value::use_empty().

Referenced by SimplifyCFG().

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 100 of file BreakCriticalEdges.cpp.

References llvm::DominatorSetBase::addBasicBlock(), llvm::PHINode::addIncoming(), llvm::ISD::BasicBlock, llvm::BasicBlock::begin(), llvm::X86II::DF, DS, llvm::Pass::getAnalysisToUpdate(), llvm::Function::getBasicBlockList(), llvm::DominatorSetBase::getDominators(), llvm::Value::getName(), llvm::BasicBlock::getNext(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::TerminatorInst::getSuccessor(), I, isCriticalEdge(), llvm::PHINode::removeIncomingValue(), and llvm::TerminatorInst::setSuccessor().

Referenced by 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 E, SplitCriticalEdge(), succ_begin(), and succ_end().

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

Definition at line 70 of file BasicBlockUtils.h.

References llvm::SuccIterator< Term_, BB_ >::getSuccessorIndex(), llvm::BasicBlock::getTerminator(), and 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 100 of file BreakCriticalEdges.cpp.

References llvm::DominatorSetBase::addBasicBlock(), llvm::PHINode::addIncoming(), llvm::ISD::BasicBlock, llvm::BasicBlock::begin(), llvm::X86II::DF, DS, llvm::Pass::getAnalysisToUpdate(), llvm::Function::getBasicBlockList(), llvm::DominatorSetBase::getDominators(), llvm::Value::getName(), llvm::BasicBlock::getNext(), llvm::Instruction::getParent(), llvm::BasicBlock::getParent(), llvm::TerminatorInst::getSuccessor(), I, isCriticalEdge(), llvm::PHINode::removeIncomingValue(), and llvm::TerminatorInst::setSuccessor().

Referenced by SplitCriticalEdge().

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_iterator llvm::succ_begin SchedGraphNode *  N  )  [inline]
 

Definition at line 216 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::beginOutEdges().

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

Definition at line 145 of file CFG.h.

References llvm::BasicBlock::getTerminator().

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

Definition at line 142 of file CFG.h.

References llvm::BasicBlock::getTerminator().

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

Definition at line 107 of file Interval.h.

References llvm::Interval::Successors.

Referenced by AddPredecessorToBlock(), CalcRegionExitBlocks(), 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(), getBBtrace(), llvm::DOTGraphTraits< const Function * >::getEdgeSourceLabel(), llvm::Loop::getExitBlocks(), llvm::Loop::getLoopPreheader(), HoistThenElseCodeToIf(), llvm::Loop::isLoopExit(), MarkAliveBlocks(), MarkSuccessorsReady(), PropagatePredecessorsForPHIs(), RequiresFPRegKill(), llvm::ProfilePaths::runOnFunction(), llvm::PostDominatorSet::runOnFunction(), SafeToMergeTerminators(), SimplifyCFG(), llvm::BasicBlock::splitBasicBlock(), and SplitCriticalEdge().

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

Definition at line 225 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::endOutEdges().

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

Definition at line 219 of file SchedGraph.h.

References llvm::SchedGraphNodeCommon::endOutEdges().

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

Definition at line 151 of file CFG.h.

References llvm::BasicBlock::getTerminator().

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

Definition at line 148 of file CFG.h.

References llvm::BasicBlock::getTerminator().

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(), getBBtrace(), llvm::Loop::getExitBlocks(), llvm::Loop::getLoopPreheader(), HoistThenElseCodeToIf(), llvm::Loop::isLoopExit(), MarkAliveBlocks(), MarkSuccessorsReady(), llvm::IntervalIterator< NodeTy, OrigContainer_t, GT, IGT >::operator++(), RequiresFPRegKill(), llvm::ProfilePaths::runOnFunction(), llvm::PostDominatorSet::runOnFunction(), SafeToMergeTerminators(), SimplifyCFG(), llvm::BasicBlock::splitBasicBlock(), and SplitCriticalEdge().

bool llvm::ThisIsAChainRule int  eruleno  ) 
 

ThisIsAChainRule - returns true if the given BURG rule is a chain rule.

Definition at line 2832 of file SparcV9BurgISel.cpp.

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

Definition at line 58 of file ParserInternals.h.

References CurFilename, and llvmAsmlineno.

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

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

Definition at line 304 of file STLExtras.h.

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

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

Definition at line 869 of file Lexer.cpp.

References ThrowException().

void llvm::UnmapFileFromAddressSpace void *  Buffer,
unsigned  Length
 

UnmapFileFromAddressSpace - Remove the specified file from the current address space.

Definition at line 306 of file FileUtilities.cpp.

void llvm::UnmapFileFromAddressSpace void *  Buffer,
unsigned  Length
 

UnmapFileFromAddressSpace - Remove the specified file from the current address space.

Definition at line 306 of file FileUtilities.cpp.

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

Definition at line 24 of file StringExtras.h.

Referenced by WriteConstantInt().

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

Definition at line 62 of file StringExtras.h.

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 long long  X,
bool  isNeg = false
[inline, static]
 

Definition at line 42 of file StringExtras.h.

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

int llvm::valueAssignmentToEdges Graph &  g,
map< Node *, int >  nodePriority,
vector< Edge > &  be
 

Definition at line 75 of file GraphAuxiliary.cpp.

References llvm::BranchInst::getNumSuccessors(), llvm::Graph::getRoot(), llvm::Graph::getSortedNodeList(), llvm::BranchInst::getSuccessor(), llvm::Graph::isLeaf(), llvm::Graph::reverseTopologicalSort(), and llvm::graphListElement::weight.

int llvm::valueAssignmentToEdges Graph &  g,
std::map< Node *, int >  nodePriority,
std::vector< Edge > &  be
 

Referenced by getBBtrace(), and llvm::ProfilePaths::runOnFunction().

bool llvm::ValueConvertibleToType Value V,
const Type Ty,
ValueTypeCache ConvertedTypes,
const TargetData TD
 

Definition at line 561 of file ExprTypeConvert.cpp.

References E, llvm::Value::getType(), I, OperandConvertibleToType(), llvm::Value::use_begin(), and llvm::Value::use_end().

Referenced by OperandConvertibleToType().

bool llvm::verifyFunction const Function f,
VerifierFailureAction  action
 

Definition at line 759 of file Verifier.cpp.

References llvm::FunctionPassManager::add(), llvm::GlobalValue::getParent(), llvm::Function::isExternal(), and llvm::FunctionPassManager::run().

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

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

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 773 of file Verifier.cpp.

References llvm::PassManager::add(), and llvm::PassManager::run().

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

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

Definition at line 1396 of file InstrScheduling.cpp.

References llvm::SchedulingManager::getEarliestStartTimeForOp().

Referenced by instrIsFeasible().

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 626 of file AsmWriter.cpp.

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

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 585 of file AsmWriter.cpp.

References fillTypeNameTable(), getModuleFromVal(), llvm::Value::getType(), printTypeInt(), 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 626 of file AsmWriter.cpp.

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

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 585 of file AsmWriter.cpp.

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

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

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

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

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

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

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

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

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

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().

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

Definition at line 195 of file GraphWriter.h.

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

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

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().

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 376 of file AsmWriter.cpp.

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

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

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 376 of file AsmWriter.cpp.

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

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

static RegisterOpt<ProfilePaths> llvm::X "paths"  ,
"Profile Paths" 
[static]
 

RegisterOpt<InstLoops> llvm::@0::X "instloops"  ,
"Instrument backedges for profiling" 
[static]
 

RegisterOpt<CombineBranches> llvm::@0::X "branch-combine"  ,
"Multiple backedges going to same target are merged" 
[static]
 

RegisterOpt<EmitFunctionTable> llvm::@0::X "emitfuncs"  ,
"Emit a function table for the reoptimizer" 
[static]
 

static RegisterAnalysis<FunctionLiveVarInfo> llvm::X "livevar"  ,
"Live Variable Analysis" 
[static]
 

static RegisterAnalysis<IntervalPartition> llvm::X "intervals"  ,
"Interval Partition Construction"  ,
true 
[static]
 

static RegisterAnalysis<PgmDependenceGraph> llvm::Z "pgmdep"  ,
"Enumerate Program Dependence Graph (data and control)" 
[static]
 

static RegisterAnalysis<MemoryDepAnalysis> llvm::Z "memdep"  ,
"Memory Dependence Analysis" 
[static]
 


Variable Documentation

cl::opt< bool > llvm::AIX
 

Definition at line 36 of file PPC32RegisterInfo.cpp.

Referenced by llvm::PowerPCTargetMachine::addPassesToEmitAssembly().

llvm::Alloca
 

Definition at line 145 of file InstCount.cpp.

Referenced by isSafeInstruction(), and TraceThisOpCode().

const PassInfo * llvm::BreakCriticalEdgesID = X.getPassInfo()
 

Definition at line 50 of file BreakCriticalEdges.cpp.

Referenced by llvm::UnifyFunctionExitNodes::getAnalysisUsage().

AllocaInst PHINode llvm::Call
 

Definition at line 155 of file InstCount.cpp.

Referenced by llvm::DOTGraphTraits< const DSGraph * >::addCustomGraphFeatures().

IncludeFile llvm::CALLGRAPH_INCLUDE_FILE((void *)&CallGraph::stub) [static]
 

const unsigned llvm::ccr_AliasSet[] = { SparcV9::xcc, SparcV9::icc, 0 } [static]
 

Definition at line 129 of file SparcV9RegisterInfo.cpp.

std::string llvm::CurFilename
 

Definition at line 261 of file llvmAsmParser.cpp.

Referenced by RunVMAsmParser(), ThrowException(), and yyerror().

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]
 

RegAllocDebugLevel_t llvm::DEBUG_RA
 

Definition at line 54 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().

bool llvm::DebugFlag
 

Definition at line 30 of file Debug.cpp.

IncludeFile llvm::DOMINATORS_INCLUDE_FILE((void *)&DominatorSet::stub) [static]
 

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]
 

bool llvm::EmitMappingInfo = false
 

Definition at line 599 of file SparcV9TargetMachine.cpp.

const unsigned llvm::Empty_AliasSet[] = { 0 } [static]
 

Definition at line 120 of file SparcV9RegisterInfo.cpp.

cl::opt<bool> llvm::EnableFillingDelaySlots("sched-fill-delay-slots", cl::desc("Fill branch delay slots during local scheduling")) [static]
 

Referenced by ChooseInstructionsForDelaySlots().

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 71 of file PhyRegAlloc.cpp.

const unsigned llvm::fcc0_AliasSet[] = { SparcV9::fsr, 0 } [static]
 

Definition at line 124 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::fcc1_AliasSet[] = { SparcV9::fsr, 0 } [static]
 

Definition at line 123 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::fcc2_AliasSet[] = { SparcV9::fsr, 0 } [static]
 

Definition at line 122 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::fcc3_AliasSet[] = { SparcV9::fsr, 0 } [static]
 

Definition at line 121 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::FCCR[] [static]
 

Initial value:

Definition at line 88 of file SparcV9RegisterInfo.cpp.

{ ... } ::FCCRClass llvm::FCCRInstance [static]
 

IncludeFile llvm::FIND_USED_TYPES_INCLUDE_FILE((void *)&FindUsedTypes::stub) [static]
 

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::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 unsigned llvm::FR[] [static]
 

Initial value:

Definition at line 51 of file SparcV9RegisterInfo.cpp.

Referenced by CopyFile().

{ ... } ::FRClass llvm::FRInstance [static]
 

const unsigned llvm::fsr_AliasSet[] [static]
 

Initial value:

Definition at line 125 of file SparcV9RegisterInfo.cpp.

AllocaInst llvm::HANDLE_MEMORY_INST(24, Load, LoadInst)HANDLE_OTHER_INST(27
 

const cycles_t llvm::HUGE_LATENCY = ~((long long) 1 << (sizeof(cycles_t)-2)) [static]
 

Definition at line 26 of file TargetSchedInfo.h.

Referenced by llvm::SchedPriorities::issuedReadyNodeAt().

const unsigned llvm::icc_AliasSet[] = { SparcV9::ccr, 0 } [static]
 

Definition at line 128 of file SparcV9RegisterInfo.cpp.

const unsigned llvm::ICCR[] [static]
 

Initial value:

Definition at line 79 of file SparcV9RegisterInfo.cpp.

{ ... } ::ICCRClass llvm::ICCRInstance [static]
 

Statistic llvm::IncreasedII("modulosched-increasedII","Number of times we had to increase II")
 

const char* const llvm::IntCCRegNames[] [static]
 

Initial value:

 {    
  "xcc",  "icc",  "ccr"
}

Definition at line 110 of file SparcV9RegInfo.cpp.

Referenced by llvm::SparcV9IntCCRegClass::getRegName().

function_interval_iterator llvm::intervals_end(Function *)
 

Definition at line 243 of file IntervalIterator.h.

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

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 cycles_t llvm::INVALID_LATENCY = -HUGE_LATENCY [static]
 

Definition at line 27 of file TargetSchedInfo.h.

const ResourceId llvm::InvalidRID = -1
 

Definition at line 30 of file SchedGraphCommon.h.

const unsigned llvm::IR[] [static]
 

Initial value:

Definition at line 36 of file SparcV9RegisterInfo.cpp.

{ ... } ::IRClass llvm::IRInstance [static]
 

cl::opt<PluginLoader, false, cl::parser<std::string> > llvm::LoadOpt("load", cl::ZeroOrMore, cl::value_desc("pluginfilename"), cl::desc("Load the specified plugin")) [static]
 

IncludeFile llvm::LOOP_INFO_INCLUDE_FILE((void *)&LoopInfo::stub) [static]
 

const PassInfo * llvm::LoopSimplifyID = X.getPassInfo()
 

Definition at line 90 of file LoopSimplify.cpp.

Referenced by llvm::ScalarEvolution::getAnalysisUsage().

const PassInfo * llvm::LowerInvokePassID = X.getPassInfo()
 

Definition at line 79 of file LowerInvoke.cpp.

const unsigned llvm::M_2_ADDR_FLAG = 1 << 15
 

Definition at line 56 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isTwoAddrInstr().

const unsigned llvm::M_BARRIER_FLAG = 1 << 4
 

Definition at line 50 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isBarrier().

const unsigned llvm::M_BRANCH_FLAG = 1 << 1
 

Definition at line 47 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isBranch().

const unsigned llvm::M_CALL_FLAG = 1 << 2
 

Definition at line 48 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isCall().

const unsigned llvm::M_CC_FLAG = 1 << 6
 

Definition at line 52 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isCCInstr().

const unsigned llvm::M_DELAY_SLOT_FLAG = 1 << 5
 

Definition at line 51 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::hasDelaySlot().

const unsigned llvm::M_LOAD_FLAG = 1 << 10
 

Definition at line 53 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isLoad().

const unsigned llvm::M_NOP_FLAG = 1 << 0
 

Definition at line 46 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isNop().

const unsigned llvm::M_RET_FLAG = 1 << 3
 

Definition at line 49 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isReturn().

const unsigned llvm::M_STORE_FLAG = 1 << 12
 

Definition at line 54 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isStore().

const unsigned llvm::M_TERMINATOR_FLAG = 1 << 16
 

Definition at line 62 of file TargetInstrInfo.h.

Referenced by llvm::TargetInstrInfo::isTerminatorInstr().

const ResourceId llvm::MachineCCRegsRID = -2
 

Definition at line 31 of file SchedGraphCommon.h.

const ResourceId llvm::MachineFPRegsRID = -4
 

Definition at line 33 of file SchedGraphCommon.h.

const ResourceId llvm::MachineIntRegsRID = -3
 

Definition at line 32 of file SchedGraphCommon.h.

const int llvm::MAX_NUM_CYCLES = 32
 

Definition at line 71 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 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.

Statistic llvm::MSLoops("modulosched-schedLoops","Number of loops successfully modulo-scheduled")
 

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

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().

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< Function >::addPass(), llvm::PMDebug::PerformPassStartupStuff(), llvm::PMDebug::PrintAnalysisSetInfo(), llvm::PMDebug::PrintPassInformation(), and llvm::PassManagerT< Function >::runOnUnit().

AllocaInst llvm::PHI
 

Definition at line 153 of file InstCount.cpp.

Referenced by InlineFunction().

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 59 of file PHIElimination.cpp.

Referenced by llvm::LiveIntervals::getAnalysisUsage().

IncludeFile llvm::POST_DOMINATOR_INCLUDE_FILE((void *)&PostDominanceFrontier::stub) [static]
 

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::addPassesToEmitAssembly(), llvm::PowerPCTargetMachine::addPassesToEmitAssembly(), llvm::X86JITInfo::addPassesToJITCompile(), and llvm::PowerPCJITInfo::addPassesToJITCompile().

const TargetRegisterClass* const llvm::RegisterClasses[] [static]
 

Initial value:

Definition at line 106 of file SparcV9RegisterInfo.cpp.

const MRegisterDesc llvm::RegisterDescriptors[] [static]
 

Definition at line 131 of file SparcV9RegisterInfo.cpp.

bool llvm::SaveRegAllocState = false
 

Definition at line 72 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]
 

bool llvm::SaveStateToModule = true
 

Definition at line 73 of file PhyRegAlloc.cpp.

SchedDebugLevel_t llvm::SchedDebugLevel
 

Definition at line 29 of file InstrScheduling.cpp.

Referenced by llvm::SchedPriorities::insertReady().

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]
 

AllocaInst PHINode CallInst VANextInst llvm::Select
 

Definition at line 161 of file InstCount.cpp.

Referenced by AnalyzeGlobal(), ConstantFold(), DecomposeConstantExpr(), and RemapOperand().

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 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.

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 TargetInstrDescriptor llvm::SparcV9MachineInstrDesc
 

Definition at line 37 of file SparcV9TargetMachine.cpp.

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::SR[] [static]
 

Initial value:

Definition at line 97 of file SparcV9RegisterInfo.cpp.

{ ... } ::SRClass llvm::SRInstance [static]
 

const TargetInstrDescriptor * llvm::TargetInstrDescriptors = 0
 

Definition at line 24 of file TargetInstrInfo.cpp.

Referenced by operator<<(), llvm::MachineInstr::SetMachineOperandConst(), llvm::TargetInstrInfo::TargetInstrInfo(), and llvm::TargetInstrInfo::~TargetInstrInfo().

TimingInfo* llvm::TheTimeInfo [static]
 

Definition at line 124 of file PassManagerT.h.

Referenced by llvm::TimingInfo::createTheTimeInfo(), and llvm::PassManagerT< Function >::runOnUnit().

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 117 of file Pass.cpp.

Statistic llvm::TotalBlocks("instcount","Number of basic blocks") [static]
 

Statistic llvm::TotalFuncs("instcount","Number of non-external functions") [static]
 

Statistic llvm::TotalInsts("instcount","Number of instructions (of all types)") [static]
 

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 60 of file TwoAddressInstructionPass.cpp.

Referenced by llvm::LiveIntervals::getAnalysisUsage().

Statistic llvm::ValidLoops("modulosched-validLoops","Number of candidate loops modulo-scheduled")
 

Referenced by llvm::ModuloSchedulingPass::runOnFunction().

AllocaInst PHINode CallInst llvm::VANext
 

Definition at line 159 of file InstCount.cpp.

RegisterOpt<ProfilePaths> llvm::X("paths","Profile Paths") [static]
 

Referenced by llvm::AliasSetTracker::add(), cast(), llvm::DSGraph::cloneInto(), llvm::DSGraph::mergeInGraph(), llvm::DSGraph::removeDeadNodes(), llvm::DSGraph::removeTriviallyDeadNodes(), and llvm::DSGraph::updateFromGlobalGraph().

X86VectorEnum llvm::X86Vector = NoSSE
 

Definition at line 28 of file X86TargetMachine.cpp.

const unsigned llvm::xcc_AliasSet[] = { SparcV9::ccr, 0 } [static]
 

Definition at line 127 of file SparcV9RegisterInfo.cpp.

RegisterAnalysis<PgmDependenceGraph> llvm::Z("pgmdep","Enumerate Program Dependence Graph (data and control)") [static]