/// Performs a bitwise complement operation on APInt.
inline APInt Not(const APInt &APIVal) { return ~APIVal; }
-} // End of APIntOps namespace
+} // namespace APIntOps
// See friend declaration above. This additional declaration is required in
// order to compile LLVM with IBM xlC compiler.
hash_code hash_value(const APInt &Arg);
-} // End of llvm namespace
+} // namespace llvm
#endif
template <typename T> struct isPodLike<ArrayRef<T> > {
static const bool value = true;
};
-}
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
namespace std {
/// Implement std::swap in terms of BitVector swap.
ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
};
-}
+} // namespace detail
template <
typename KeyT, typename ValueT, typename KeyInfoT = DenseMapInfo<KeyT>,
DenseSetEmpty &getSecond() { return *this; }
const DenseSetEmpty &getSecond() const { return *this; }
};
-}
+} // namespace detail
/// DenseSet - This implements a dense probed hash-table based set.
template<typename ValueT, typename ValueInfoT = DenseMapInfo<ValueT> >
return make_range(idf_ext_begin(G, S), idf_ext_end(G, S));
}
-} // End llvm namespace
+} // namespace llvm
#endif
};
};
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
void uncompress();
};
-} // End llvm namespace
+} // namespace llvm
#endif
template<typename T, typename U>
void operator>(const Optional<T> &X, const Optional<U> &Y);
-} // end llvm namespace
+} // namespace llvm
#endif
RHS.template get<U>()));
}
};
-}
+} // namespace llvm
#endif
rpo_iterator end() { return Blocks.rend(); }
};
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
return scc_iterator<Inverse<T> >::end(G);
}
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
S1.erase(*SI);
}
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
// vim: sw=2 ai
#endif
return Result;
}
-} // End llvm namespace
+} // namespace llvm
namespace std {
/// Implement std::swap in terms of BitVector swap.
}
};
-}
+} // namespace llvm
namespace std {
/// Implement std::swap in terms of SmallPtrSet swap.
}
};
-}
+} // namespace llvm
#endif
return X.capacity_in_bytes();
}
-} // End llvm namespace
+} // namespace llvm
namespace std {
/// Implement std::swap in terms of SmallVector swap.
swap(llvm::SmallVector<T, N> &LHS, llvm::SmallVector<T, N> &RHS) {
LHS.swap(RHS);
}
-}
+} // namespace std
#endif
/// \brief Print statistics to the given output stream.
void PrintStatistics(raw_ostream &OS);
-} // End llvm namespace
+} // namespace llvm
#endif
return join_impl(Begin, End, Separator, tag());
}
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-}
+} // namespace llvm
#endif
// StringRefs can be treated like a POD type.
template <typename T> struct isPodLike;
template <> struct isPodLike<StringRef> { static const bool value = true; };
-}
+} // namespace llvm
#endif
return base::insert(std::make_pair(Key, '\0'));
}
};
-}
+} // namespace llvm
#endif // LLVM_ADT_STRINGSET_H
/// @}
};
-} // End llvm namespace
+} // namespace llvm
#endif
}
/// @}
-}
+} // namespace llvm
#endif
return Result;
}
-} // End llvm namespace
+} // namespace llvm
#endif
void resize(size_type newsize) { resize(newsize, NodeTy()); }
};
-} // End llvm namespace
+} // namespace llvm
namespace std {
// Ensure that swap uses the fast list swap...
/// @}
};
-} // End llvm namespace
+} // namespace llvm
#endif
T &operator*() const { return **this->I; }
};
-}
+} // namespace llvm
#endif
template <typename T> iterator_range<T> make_range(std::pair<T, T> p) {
return iterator_range<T>(std::move(p.first), std::move(p.second));
}
-}
+} // namespace llvm
#endif
/// IdentifiedObjects.
bool isIdentifiedFunctionLocal(const Value *V);
-} // End llvm namespace
+} // namespace llvm
#endif
return OS;
}
-} // End llvm namespace
+} // namespace llvm
#endif
};
-}
+} // namespace llvm
#endif
else
addBlockEdges(*this, Irr, OuterLoop);
}
-}
+} // namespace bfi_detail
/// \brief Shared implementation for block frequency analysis.
///
G.addEdge(Irr, BFI.getNode(*I), OuterLoop);
}
};
-}
+} // namespace bfi_detail
template <class BT>
void BlockFrequencyInfoImpl<BT>::computeIrreducibleMass(
LoopData *OuterLoop, std::list<LoopData>::iterator Insert) {
bool calcInvokeHeuristics(BasicBlock *BB);
};
-}
+} // namespace llvm
#endif
const DominatorTree *DT = nullptr,
const LoopInfo *LI = nullptr);
-} // End llvm namespace
+} // namespace llvm
#endif
return "";
}
};
-} // End llvm namespace
+} // namespace llvm
namespace llvm {
class FunctionPass;
createCGSCCToFunctionPassAdaptor(FunctionPassT Pass) {
return CGSCCToFunctionPassAdaptor<FunctionPassT>(std::move(Pass));
}
-}
+} // namespace llvm
#endif
static const CallGraphNode &CGdereference(PairTy P) { return *P.second; }
};
-} // End llvm namespace
+} // namespace llvm
#endif
iterator end() const { return Nodes.end(); }
};
-} // End llvm namespace
+} // namespace llvm
#endif
SmallPtrSetImpl<const Value *> &EphValues);
};
-}
+} // namespace llvm
#endif
/// with the specified arguments, returning null if unsuccessful.
Constant *ConstantFoldCall(Function *F, ArrayRef<Constant *> Operands,
const TargetLibraryInfo *TLI = nullptr);
-}
+} // namespace llvm
#endif
FunctionPass *createPostDomOnlyPrinterPass();
FunctionPass *createPostDomViewerPass();
FunctionPass *createPostDomOnlyViewerPass();
-} // End llvm namespace
+} // namespace llvm
#endif
EXTERN_TEMPLATE_INSTANTIATION(class DominanceFrontierBase<BasicBlock>);
EXTERN_TEMPLATE_INSTANTIATION(class ForwardDominanceFrontierBase<BasicBlock>);
-} // End llvm namespace
+} // namespace llvm
#endif
return *Result;
}
-} // End llvm namespace
+} // namespace llvm
#endif
Pass *createIVUsersPass();
-}
+} // namespace llvm
#endif
/// Do not inline functions which allocate this many bytes on the stack
/// when the caller is recursive.
const unsigned TotalAllocaSizeRecursiveCaller = 1024;
-}
+} // namespace InlineConstants
/// \brief Represents the cost of inlining a function.
///
bool isInlineViable(Function &Callee);
};
-}
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
return interval_part_interval_iterator();
}
-} // End llvm namespace
+} // namespace llvm
#endif
void updatePredecessors(Interval *Int);
};
-} // End llvm namespace
+} // namespace llvm
#endif
const SmallPtrSetImpl<BasicBlock *> *DefBlocks;
SmallVector<BasicBlock *, 32> PHIBlocks;
};
-}
+} // namespace llvm
#endif
/// bound specifies the maximum number of bytes needed to represent an
/// unconditional jump or a trap instruction in the back end currently in use.
ModulePass *createJumpInstrTableInfoPass(unsigned Bound);
-}
+} // namespace llvm
#endif /* LLVM_ANALYSIS_JUMPINSTRTABLEINFO_H */
static StringRef name() { return "LazyCallGraphPrinterPass"; }
};
-}
+} // namespace llvm
#endif
ImmutableCallSite CS,
const MemoryLocation &Loc);
};
-} // End of llvm namespace
+} // namespace llvm
#endif
const Function &F ///< The function to be checked
);
-} // End llvm namespace
+} // namespace llvm
#endif
AliasAnalysis *AA = nullptr,
AAMDNodes *AATags = nullptr);
-}
+} // namespace llvm
#endif
DominatorTree *DT;
LoopInfo *LI;
};
-} // End llvm namespace
+} // namespace llvm
#endif
void getAnalysisUsage(AnalysisUsage &AU) const override;
};
-} // End llvm namespace
+} // namespace llvm
#endif
#endif
}
-} // End llvm namespace
+} // namespace llvm
#endif
Loop *CurrentLoop;
};
-} // End llvm namespace
+} // namespace llvm
#endif
SizeOffsetEvalType visitInstruction(Instruction &I);
};
-} // End llvm namespace
+} // namespace llvm
#endif
};
-} // End llvm namespace
+} // namespace llvm
#endif
return LHS == RHS;
}
};
-}
+} // namespace llvm
#endif
//
FunctionPass *createMemDerefPrinter();
-}
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-}
+} // namespace llvm
#endif
EXTERN_TEMPLATE_INSTANTIATION(class RegionNodeBase<RegionTraits<Function>>);
EXTERN_TEMPLATE_INSTANTIATION(class RegionInfoBase<RegionTraits<Function>>);
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
/// to locate them all and call their destructors.
SCEVUnknown *FirstUnknown;
};
-}
+} // namespace llvm
#endif
Value *expandIVInc(PHINode *PN, Value *StepV, const Loop *L,
Type *ExpandTy, Type *IntTy, bool useSubtract);
};
-}
+} // namespace llvm
#endif
return SCEVApplyRewriter::rewrite(Scev, Map, SE);
}
-}
+} // namespace llvm
#endif
ScalarEvolution &SE,
DominatorTree &DT);
-}
+} // namespace llvm
#endif
}
};
-}
+} // namespace llvm
#endif
/// clients.
ImmutablePass *createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA);
-} // End llvm namespace
+} // namespace llvm
#endif
U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr);
}
};
-}
+} // namespace llvm
#endif
/// @return true on error.
bool parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err);
-} // End llvm namespace
+} // namespace llvm
#endif
// [id, name]
};
-} // End bitc namespace
+} // namespace bitc
/// BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
/// This is actually a union of two different things:
OperandList.push_back(OpInfo);
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
static StringRef name() { return "BitcodeWriterPass"; }
};
-}
+} // namespace llvm
#endif
bool ReadBlockInfoBlock();
};
-} // End llvm namespace
+} // namespace llvm
#endif
};
-} // End llvm namespace
+} // namespace llvm
#endif
COMDAT_SELECTION_KIND_SAME_SIZE = 5,
};
-} // End bitc namespace
-} // End llvm namespace
+} // namespace bitc
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
namespace std {
template <> struct is_error_code_enum<llvm::BitcodeError> : std::true_type {};
// or we are in LTO.
bool canBeOmittedFromSymbolTable(const GlobalValue *GV);
-} // End llvm namespace
+} // namespace llvm
#endif
void EmitXXStructorList(const Constant *List, bool isCtor);
GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy &C);
};
-}
+} // namespace llvm
#endif
}
};
-}
+} // namespace llvm
#endif
const MachineBlockFrequencyInfo &MBFI,
VirtRegAuxInfo::NormalizingFn norm =
normalizeSpillWeight);
-}
+} // namespace llvm
#endif // LLVM_CODEGEN_CALCSPILLWEIGHTS_H
}
};
-}
+} // namespace llvm
#endif
#endif
};
-} // end llvm namespace
+} // namespace llvm
#endif
void emitFunctionInfo(const MCSymbol *FnLabel, const FunctionFaultInfos &FFI);
};
-}
+} // namespace llvm
#endif
/// will soon change.
GCFunctionInfo &getFunctionInfo(const Function &F);
};
-}
+} // namespace llvm
#endif
virtual ~GCMetadataPrinter();
};
-}
+} // namespace llvm
#endif
/// register your GCMetadataPrinter subclass with the
/// GCMetadataPrinterRegistery as well.
typedef Registry<GCStrategy> GCRegistry;
-}
+} // namespace llvm
#endif
void linkShadowStackGC();
void linkStatepointExampleGC();
-}
+} // namespace llvm
#endif
CVT_INVALID /// Marker - Invalid opcode
};
-} // end llvm::ISD namespace
+} // namespace ISD
-} // end llvm namespace
+} // namespace llvm
#endif
/// simple integer bswap.
static bool LowerToByteSwap(CallInst *CI);
};
-}
+} // namespace llvm
#endif
void AdjustPriorityOfUnscheduledPreds(SUnit *SU);
SUnit *getSingleUnscheduledPred(SUnit *SU);
};
-}
+} // namespace llvm
#endif
LexicalScope *CurrentFnLexicalScope;
};
-} // end llvm namespace
+} // namespace llvm
#endif
};
-}
+} // namespace llvm
#endif
class HMEditor;
};
-} // End llvm namespace
+} // namespace llvm
#endif
const MachineBlockFrequencyInfo&);
};
-}
+} // namespace llvm
#endif
/// print - Implement the dump method.
void print(raw_ostream &O, const Module* = nullptr) const override;
};
-}
+} // namespace llvm
#endif /* LLVM_CODEGEN_LIVESTACK_ANALYSIS_H */
void setPHIJoin(unsigned Reg) { PHIJoins.set(Reg); }
};
-} // End llvm namespace
+} // namespace llvm
#endif
MachineBasicBlock::iterator getInitial() { return I; }
};
-} // End llvm namespace
+} // namespace llvm
#endif
};
-}
+} // namespace llvm
#endif
const MachineBasicBlock *Dst) const;
};
-}
+} // namespace llvm
#endif
void dump() const;
};
-} // End llvm namespace
+} // namespace llvm
#endif
void getAnalysisUsage(AnalysisUsage &AU) const override;
};
-}
+} // namespace llvm
#endif
}
};
-}
+} // namespace llvm
#endif
void dump(const MachineFunction &MF) const;
};
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
void getAnalysisUsage(AnalysisUsage &AU) const override;
};
-} // End llvm namespace
+} // namespace llvm
#endif
bool runOnFunction(Function &F) override;
};
-} // End llvm namespace
+} // namespace llvm
#endif
return OS;
}
-} // End llvm namespace
+} // namespace llvm
#endif
ImplicitDefine = Implicit | Define,
ImplicitKill = Implicit | Kill
};
-}
+} // namespace RegState
class MachineInstrBuilder {
MachineFunction *MF;
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
const MachineOperand *operator->() const { return &deref(); }
};
-} // End llvm namespace
+} // namespace llvm
#endif
void dump() const;
};
-} // End llvm namespace
+} // namespace llvm
#endif
}
};
-} // End llvm namespace
+} // namespace llvm
#endif
raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MRO);
-} // End llvm namespace
+} // namespace llvm
#endif
}; // End class MachineModuleInfo
-} // End llvm namespace
+} // namespace llvm
#endif
// See friend declaration above. This additional declaration is required in
// order to compile LLVM with IBM xlC compiler.
hash_code hash_value(const MachineOperand &MO);
-} // End llvm namespace
+} // namespace llvm
#endif
EXTERN_TEMPLATE_INSTANTIATION(class RegionNodeBase<RegionTraits<MachineFunction>>);
EXTERN_TEMPLATE_INSTANTIATION(class RegionInfoBase<RegionTraits<MachineFunction>>);
-}
+} // namespace llvm
#endif
return PSetIterator(RegUnit, this);
}
-} // End llvm namespace
+} // namespace llvm
#endif
MachineSSAUpdater(const MachineSSAUpdater&) = delete;
};
-} // End llvm namespace
+} // namespace llvm
#endif
/// @}
};
-} // End llvm namespace
+} // namespace llvm
#endif
void anchor() override;
};
-}
+} // namespace llvm
#endif /* LLVM_CODEGEN_PBQPRACONSTRAINT_H */
/// createForwardControlFlowIntegrityPass - This pass adds control-flow
/// integrity.
ModulePass *createForwardControlFlowIntegrityPass();
-} // End llvm namespace
+} // namespace llvm
/// Target machine pass initializer for passes with dependencies. Use with
/// INITIALIZE_TM_PASS_END.
int getFrameIndex() const { return FI; }
};
-} // End llvm namespace
+} // namespace llvm
#endif
};
-} // End llvm namespace
+} // namespace llvm
#endif
unsigned numberRCValPredInSU (SUnit *SU, unsigned RCId);
unsigned numberRCValSuccInSU (SUnit *SU, unsigned RCId);
};
-}
+} // namespace llvm
#endif
/// Return the SYNC_FETCH_AND_* value for the given opcode and type, or
/// UNKNOWN_LIBCALL if there is none.
Libcall getATOMIC(unsigned Opc, MVT VT);
-}
-}
+} // namespace RTLIB
+} // namespace llvm
#endif
reverse_iterator rend() { return Index2Node.rend(); }
const_reverse_iterator rend() const { return Index2Node.rend(); }
};
-}
+} // namespace llvm
#endif
}
};
-}
+} // namespace llvm
#endif
void RecedeCycle() override;
};
-}
+} // namespace llvm
#endif //!LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
};
-}
+} // namespace llvm
#endif /* LLVM_CODEGEN_SELECTIONDAGISEL_H */
/// Return true if the node has at least one operand
/// and all operands of the specified node are ISD::UNDEF.
bool allOperandsUndef(const SDNode *N);
-} // end llvm:ISD namespace
+} // namespace ISD
//===----------------------------------------------------------------------===//
/// Unlike LLVM values, Selection DAG nodes may return multiple
return isa<StoreSDNode>(N) &&
cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
}
-}
+} // namespace ISD
-} // end llvm namespace
+} // namespace llvm
#endif
struct IntervalMapInfo<SlotIndex> : IntervalMapHalfOpenInfo<SlotIndex> {
};
-}
+} // namespace llvm
#endif // LLVM_CODEGEN_SLOTINDEXES_H
void debug() { print(dbgs()); }
};
-}
+} // namespace llvm
#endif
unsigned getExtendedSizeInBits() const;
};
-} // End llvm namespace
+} // namespace llvm
#endif
VRM.print(OS);
return OS;
}
-} // End llvm namespace
+} // namespace llvm
#endif
void calculateWinCXXEHStateNumbers(const Function *ParentFn,
WinEHFuncInfo &FuncInfo);
-}
+} // namespace llvm
#endif // LLVM_CODEGEN_WINEHFUNCINFO_H
virtual std::unique_ptr<LoadedObjectInfo> clone() const = 0;
};
-}
+} // namespace llvm
#endif
AttributeSpecVector AttributeSpecs;
};
-}
+} // namespace llvm
#endif
void dump(raw_ostream &OS) const;
};
-}
+} // namespace llvm
#endif
~DWARFCompileUnit() override;
};
-}
+} // namespace llvm
#endif
}
};
-}
+} // namespace llvm
#endif
void clear();
};
-}
+} // namespace llvm
#endif
}
};
-}
+} // namespace llvm
#endif
DenseSet<uint32_t> ParsedCUOffsets;
};
-}
+} // namespace llvm
#endif
const DWARFUnit *U;
};
-}
+} // namespace llvm
#endif
LineTableMapTy LineTableMap;
};
-}
+} // namespace llvm
#endif
void parse(DataExtractor data);
void dump(raw_ostream &OS) const;
};
-}
+} // namespace llvm
#endif
void dumpString(raw_ostream &OS, const DWARFUnit *U) const;
};
-}
+} // namespace llvm
#endif
projects / oota-llvm.git / commitdiff