/external/chromium_org/sandbox/linux/seccomp-bpf/ |
basicblock.cc | 5 #include "sandbox/linux/seccomp-bpf/basicblock.h" 9 BasicBlock::BasicBlock() {} 11 BasicBlock::~BasicBlock() {}
|
basicblock.h | 14 struct BasicBlock { 15 BasicBlock(); 16 ~BasicBlock(); 26 int (*cmp)(const BasicBlock*, const BasicBlock*, const T& data)) 29 bool operator()(const BasicBlock* a, const BasicBlock* b) const { 35 int (*cmp_)(const BasicBlock*, const BasicBlock*, const T&);
|
codegen.h | 15 struct BasicBlock; 19 typedef std::vector<BasicBlock*> BasicBlocks; 21 typedef std::map<const Instruction*, BasicBlock*> TargetsToBlocks; 22 typedef std::map<const BasicBlock*, int> IncomingBranches; 99 BasicBlock* MakeBasicBlock(Instruction* head, Instruction* tail); 107 BasicBlock** first_block); 110 BasicBlock* CutGraphIntoBasicBlocks(Instruction* instructions, 118 void ComputeIncomingBranches(BasicBlock* block, 124 void TopoSortBasicBlocks(BasicBlock* first_block,
|
/external/llvm/include/llvm/Analysis/ |
BranchProbabilityInfo.h | 58 BranchProbability getEdgeProbability(const BasicBlock *Src, 64 BranchProbability getEdgeProbability(const BasicBlock *Src, 65 const BasicBlock *Dst) const; 71 bool isEdgeHot(const BasicBlock *Src, const BasicBlock *Dst) const; 77 BasicBlock *getHotSucc(BasicBlock *BB) const; 84 raw_ostream &printEdgeProbability(raw_ostream &OS, const BasicBlock *Src, 85 const BasicBlock *Dst) const; 93 uint32_t getEdgeWeight(const BasicBlock *Src [all...] |
CFG.h | 1 //===-- Analysis/CFG.h - BasicBlock Analyses --------------------*- C++ -*-===// 18 #include "llvm/IR/BasicBlock.h" 23 class BasicBlock; 37 SmallVectorImpl<std::pair<const BasicBlock *, const BasicBlock *> > & 43 unsigned GetSuccessorNumber(BasicBlock *BB, BasicBlock *Succ); 77 bool isPotentiallyReachable(const BasicBlock *From, const BasicBlock *To,
|
LazyValueInfo.h | 53 BasicBlock *FromBB, BasicBlock *ToBB); 58 Constant *getConstant(Value *V, BasicBlock *BB); 62 Constant *getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB); 66 void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc); 69 void eraseBlock(BasicBlock *BB);
|
PostDominators.h | 26 DominatorTreeBase<BasicBlock>* DT; 30 DT = new DominatorTreeBase<BasicBlock>(true); 41 inline const std::vector<BasicBlock*> &getRoots() const { 49 inline DomTreeNode *operator[](BasicBlock *BB) const { 53 inline DomTreeNode *getNode(BasicBlock *BB) const { 61 inline bool dominates(const BasicBlock* A, const BasicBlock* B) const { 69 inline bool properlyDominates(BasicBlock* A, BasicBlock* B) const { 73 inline BasicBlock *findNearestCommonDominator(BasicBlock *A, BasicBlock *B) [all...] |
RegionInfo.h | 60 /// and the iteration returns every BasicBlock. If the Flat mode is not 66 /// @brief A RegionNode represents a subregion or a BasicBlock that is part of a 74 /// BasicBlock RegionNode, then entry is just the basic block, that this 80 /// The node can hold either a Region or a BasicBlock. 81 /// Use one bit to save, if this RegionNode is a subregion or BasicBlock 83 PointerIntPair<BasicBlock*, 1, bool> entry; 93 /// @param Entry The entry BasicBlock of the RegionNode. If this 94 /// RegionNode represents a BasicBlock, this is the 95 /// BasicBlock itself. If it represents a subregion, this 96 /// is the entry BasicBlock of the subregion [all...] |
Interval.h | 28 class BasicBlock; 38 /// HeaderNode - The header BasicBlock, which dominates all BasicBlocks in this 41 BasicBlock *HeaderNode; 43 typedef std::vector<BasicBlock*>::iterator succ_iterator; 44 typedef std::vector<BasicBlock*>::iterator pred_iterator; 45 typedef std::vector<BasicBlock*>::iterator node_iterator; 47 inline Interval(BasicBlock *Header) : HeaderNode(Header) { 51 inline BasicBlock *getHeaderNode() const { return HeaderNode; } 55 std::vector<BasicBlock*> Nodes; 61 std::vector<BasicBlock*> Successors [all...] |
PHITransAddr.h | 58 /// BasicBlock to its predecessors requires PHI translation. 59 bool NeedsPHITranslationFromBlock(BasicBlock *BB) const { 77 bool PHITranslateValue(BasicBlock *CurBB, BasicBlock *PredBB, 87 Value *PHITranslateWithInsertion(BasicBlock *CurBB, BasicBlock *PredBB, 98 Value *PHITranslateSubExpr(Value *V, BasicBlock *CurBB, BasicBlock *PredBB, 106 Value *InsertPHITranslatedSubExpr(Value *InVal, BasicBlock *CurBB, 107 BasicBlock *PredBB, const DominatorTree &DT [all...] |
Loads.h | 17 #include "llvm/IR/BasicBlock.h" 50 Value *FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB, 51 BasicBlock::iterator &ScanFrom,
|
Trace.h | 25 class BasicBlock; 31 typedef std::vector<BasicBlock *> BasicBlockListType; 39 Trace(const std::vector<BasicBlock *> &vBB) : BasicBlocks (vBB) {} 44 BasicBlock *getEntryBasicBlock () const { return BasicBlocks[0]; } 48 BasicBlock *operator[](unsigned i) const { return BasicBlocks[i]; } 49 BasicBlock *getBlock(unsigned i) const { return BasicBlocks[i]; } 62 int getBlockIndex(const BasicBlock *X) const { 72 bool contains(const BasicBlock *X) const { 79 bool dominates(const BasicBlock *B1, const BasicBlock *B2) const [all...] |
LoopIterator.h | 41 typedef std::vector<BasicBlock*>::const_iterator POIterator; 42 typedef std::vector<BasicBlock*>::const_reverse_iterator RPOIterator; 52 DenseMap<BasicBlock*, unsigned> PostNumbers; 53 std::vector<BasicBlock*> PostBlocks; 84 bool hasPreorder(BasicBlock *BB) const { return PostNumbers.count(BB); } 87 bool hasPostorder(BasicBlock *BB) const { 88 DenseMap<BasicBlock*, unsigned>::const_iterator I = PostNumbers.find(BB); 93 unsigned getPostorder(BasicBlock *BB) const { 94 DenseMap<BasicBlock*, unsigned>::const_iterator I = PostNumbers.find(BB); 101 unsigned getRPO(BasicBlock *BB) const [all...] |
/external/llvm/include/llvm/Transforms/Utils/ |
BasicBlockUtils.h | 1 //===-- Transform/Utils/BasicBlockUtils.h - BasicBlock Utils ----*- C++ -*-===// 18 // FIXME: Move to this file: BasicBlock::removePredecessor, BB::splitBasicBlock 20 #include "llvm/IR/BasicBlock.h" 35 void DeleteDeadBlock(BasicBlock *BB); 41 void FoldSingleEntryPHINodes(BasicBlock *BB, Pass *P = nullptr); 48 bool DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI = nullptr); 52 bool MergeBlockIntoPredecessor(BasicBlock *BB, Pass *P = nullptr); 57 void ReplaceInstWithValue(BasicBlock::InstListType &BIL, 58 BasicBlock::iterator &BI, Value *V); 64 void ReplaceInstWithInst(BasicBlock::InstListType &BIL [all...] |
UnifyFunctionExitNodes.h | 26 BasicBlock *ReturnBlock, *UnwindBlock, *UnreachableBlock; 41 BasicBlock *getReturnBlock() const { return ReturnBlock; } 42 BasicBlock *getUnwindBlock() const { return UnwindBlock; } 43 BasicBlock *getUnreachableBlock() const { return UnreachableBlock; }
|
CodeExtractor.h | 22 class BasicBlock; 52 SetVector<BasicBlock *> Blocks; 61 CodeExtractor(BasicBlock *BB, bool AggregateArgs = false); 69 CodeExtractor(ArrayRef<BasicBlock *> BBs, DominatorTree *DT = nullptr, 108 void severSplitPHINodes(BasicBlock *&Header); 113 BasicBlock *header, 114 BasicBlock *newRootNode, BasicBlock *newHeader, 120 BasicBlock *newHeader,
|
/external/llvm/include/llvm/IR/ |
PredIteratorCache.h | 29 DenseMap<BasicBlock*, BasicBlock**> BlockToPredsMap; 30 DenseMap<BasicBlock*, unsigned> BlockToPredCountMap; 38 /// for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI) 42 BasicBlock **GetPreds(BasicBlock *BB) { 43 BasicBlock **&Entry = BlockToPredsMap[BB]; 46 SmallVector<BasicBlock*, 32> PredCache(pred_begin(BB), pred_end(BB)); 51 Entry = Memory.Allocate<BasicBlock*>(PredCache.size()); 56 unsigned GetNumPreds(BasicBlock *BB) [all...] |
BasicBlock.h | 1 //===-- llvm/BasicBlock.h - Represent a basic block in the VM ---*- C++ -*-===// 10 // This file contains the declaration of the BasicBlock class. 32 : public SymbolTableListTraits<Instruction, BasicBlock> { 62 /// tables. The type of a BasicBlock is "Type::LabelTy" because the basic block 68 /// terminate the blocks. The BasicBlock class allows malformed basic blocks to 72 class BasicBlock : public Value, // Basic blocks are data objects also 73 public ilist_node<BasicBlock> { 82 friend class SymbolTableListTraits<BasicBlock, Function>; 84 BasicBlock(const BasicBlock &) LLVM_DELETED_FUNCTION [all...] |
AssemblyAnnotationWriter.h | 23 class BasicBlock; 41 virtual void emitBasicBlockStartAnnot(const BasicBlock *, 47 virtual void emitBasicBlockEndAnnot(const BasicBlock *,
|
Dominators.h | 23 #include "llvm/IR/BasicBlock.h" 34 EXTERN_TEMPLATE_INSTANTIATION(class DomTreeNodeBase<BasicBlock>); 35 EXTERN_TEMPLATE_INSTANTIATION(class DominatorTreeBase<BasicBlock>); 38 EXTERN_TEMPLATE_INSTANTIATION(void Calculate<Function LLVM_COMMA BasicBlock *>( 39 DominatorTreeBase<GraphTraits<BasicBlock *>::NodeType> &DT LLVM_COMMA 42 void Calculate<Function LLVM_COMMA Inverse<BasicBlock *> >( 43 DominatorTreeBase<GraphTraits<Inverse<BasicBlock *> >::NodeType> &DT 47 typedef DomTreeNodeBase<BasicBlock> DomTreeNode; 50 const BasicBlock *Start; 51 const BasicBlock *End [all...] |
/external/llvm/lib/IR/ |
BasicBlock.cpp | 1 //===-- BasicBlock.cpp - Implement BasicBlock related methods -------------===// 10 // This file implements the BasicBlock class for the IR library. 14 #include "llvm/IR/BasicBlock.h" 27 ValueSymbolTable *BasicBlock::getValueSymbolTable() { 33 const DataLayout *BasicBlock::getDataLayout() const { 37 LLVMContext &BasicBlock::getContext() const { 43 template class llvm::SymbolTableListTraits<Instruction, BasicBlock>; 46 BasicBlock::BasicBlock(LLVMContext &C, const Twine &Name, Function *NewParent [all...] |
/external/chromium_org/v8/src/compiler/ |
schedule.h | 24 class BasicBlock; 41 BasicBlock* dominator_; // Immediate dominator of the block. 42 BasicBlock* loop_header_; // Pointer to dominating loop header basic block, 95 class BasicBlock FINAL : public GenericNode<BasicBlockData, BasicBlock> { 97 BasicBlock(GenericGraphBase* graph, int input_count) 98 : GenericNode<BasicBlockData, BasicBlock>(graph, input_count) {} 107 BasicBlock* PredecessorAt(int index) { return InputAt(index); } 110 BasicBlock* SuccessorAt(int index) { return UseAt(index); } 112 int PredecessorIndexOf(BasicBlock* predecessor) [all...] |
/art/compiler/dex/ |
dataflow_iterator-inl.h | 25 inline BasicBlock* DataflowIterator::ForwardSingleNext() { 26 BasicBlock* res = NULL; 40 inline BasicBlock* DataflowIterator::ForwardRepeatNext() { 41 BasicBlock* res = NULL; 63 inline BasicBlock* DataflowIterator::ReverseSingleNext() { 64 BasicBlock* res = NULL; 78 inline BasicBlock* DataflowIterator::ReverseRepeatNext() { 79 BasicBlock* res = NULL; 101 inline BasicBlock* AllNodesIterator::Next(bool had_change) { 102 BasicBlock* res = NULL [all...] |
/external/llvm/lib/Transforms/Utils/ |
FlattenCFG.cpp | 31 bool FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder, 36 bool MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder, Pass *P = nullptr); 42 bool CompareIfRegionBlock(BasicBlock *Head1, BasicBlock *Head2, 43 BasicBlock *Block1, BasicBlock *Block2); 47 bool run(BasicBlock *BB); 125 bool FlattenCFGOpt::FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder, 131 BasicBlock *LastCondBlock = nullptr; 132 BasicBlock *FirstCondBlock = nullptr [all...] |
/external/llvm/lib/Analysis/ |
CFG.cpp | 1 //===-- CFG.cpp - BasicBlock analysis --------------------------------------==// 28 SmallVectorImpl<std::pair<const BasicBlock*,const BasicBlock*> > &Result) { 29 const BasicBlock *BB = &F.getEntryBlock(); 33 SmallPtrSet<const BasicBlock*, 8> Visited; 34 SmallVector<std::pair<const BasicBlock*, succ_const_iterator>, 8> VisitStack; 35 SmallPtrSet<const BasicBlock*, 8> InStack; 41 std::pair<const BasicBlock*, succ_const_iterator> &Top = VisitStack.back(); 42 const BasicBlock *ParentBB = Top.first; 72 unsigned llvm::GetSuccessorNumber(BasicBlock *BB, BasicBlock *Succ) [all...] |