reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

lib/CodeGen/AsmPrinter/DwarfDebug.h
   58 class LexicalScope;
lib/CodeGen/AsmPrinter/DwarfFile.h
   31 class LexicalScope;

References

include/llvm/ADT/ArrayRef.h
  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  118       const SmallVectorTemplateCommon<U *, DummyT> &Vec,
  120           std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
include/llvm/ADT/DenseMapInfo.h
   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/CodeGen/LexicalScopes.h
   46   LexicalScope(LexicalScope *P, const DILocalScope *D, const DILocation *I,
   60   LexicalScope *getParent() const { return Parent; }
   65   SmallVectorImpl<LexicalScope *> &getChildren() { return Children; }
   69   void addChild(LexicalScope *S) { Children.push_back(S); }
   92   void closeInsnRange(LexicalScope *NewScope = nullptr) {
  104   bool dominates(const LexicalScope *S) const {
  122   LexicalScope *Parent;                        // Parent to this scope.
  127   SmallVector<LexicalScope *, 4> Children;     // Scopes defined in scope.
  156   LexicalScope *getCurrentFunctionScope() const {
  172   LexicalScope *findLexicalScope(const DILocation *DL);
  175   ArrayRef<LexicalScope *> getAbstractScopesList() const {
  180   LexicalScope *findAbstractScope(const DILocalScope *N) {
  186   LexicalScope *findInlinedScope(const DILocalScope *N, const DILocation *IA) {
  192   LexicalScope *findLexicalScope(const DILocalScope *N) {
  201   LexicalScope *getOrCreateAbstractScope(const DILocalScope *Scope);
  206   LexicalScope *getOrCreateLexicalScope(const DILocalScope *Scope,
  208   LexicalScope *getOrCreateLexicalScope(const DILocation *DL) {
  214   LexicalScope *getOrCreateRegularScope(const DILocalScope *Scope);
  217   LexicalScope *getOrCreateInlinedScope(const DILocalScope *Scope,
  223                             DenseMap<const MachineInstr *, LexicalScope *> &M);
  224   void constructScopeNest(LexicalScope *Scope);
  227                           DenseMap<const MachineInstr *, LexicalScope *> &M);
  233   std::unordered_map<const DILocalScope *, LexicalScope> LexicalScopeMap;
  238                      LexicalScope,
  244   std::unordered_map<const DILocalScope *, LexicalScope> AbstractScopeMap;
  248   SmallVector<LexicalScope *, 4> AbstractScopesList;
  252   LexicalScope *CurrentFnLexicalScope = nullptr;
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
   91   typedef PointerLikeTypeTraits<T *> NonConst;
   93   static inline const void *getAsVoidPointer(const T *P) {
   96   static inline const T *getFromVoidPointer(const void *P) {
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
  476                                         const LexicalScope *LS) {
 1156     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
 1311     LexicalScope *Scope = nullptr;
 2734         SmallVectorImpl<LexicalScope *> &Scopes,
 2738   for (LexicalScope *Scope : Scopes)
 2745     LexicalScope &Scope,
 2838   if (LexicalScope *CFS = LScopes.getCurrentFunctionScope())
lib/CodeGen/AsmPrinter/CodeViewDebug.h
  193   DenseMap<const LexicalScope *, SmallVector<LocalVariable, 1>> ScopeVariables;
  348   void collectLexicalBlockInfo(SmallVectorImpl<LexicalScope *> &Scopes,
  352   void collectLexicalBlockInfo(LexicalScope &Scope,
  359   void recordLocalVariable(LocalVariable &&Var, const LexicalScope *LS);
lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp
   94   SmallVector<LexicalScope *, 4> WorkList;
   97     LexicalScope *S = WorkList.pop_back_val();
   99     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
  415     LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
  523 DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
  557 DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
  578                                          const LexicalScope &Scope) {
  691                                             const LexicalScope &Scope,
  774 DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
  804   for (LexicalScope *LS : Scope->getChildren())
  811                                                    LexicalScope *Scope) {
  838 DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
  852     LexicalScope *Scope) {
 1076                                             LexicalScope *Scope) {
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
  186   void constructScopeDIE(LexicalScope *Scope,
  200   DIE *constructInlinedScopeDIE(LexicalScope *Scope);
  204   DIE *constructLexicalScopeDIE(LexicalScope *Scope);
  209   DIE *constructVariableDIE(DbgVariable &DV, const LexicalScope &Scope,
  213   DIE *constructLabelDIE(DbgLabel &DL, const LexicalScope &Scope);
  216   DIE *createScopeChildrenDIE(LexicalScope *Scope,
  224                                    LexicalScope *Scope);
  226   DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
  228   void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
  269   void createAbstractEntity(const DINode *Node, LexicalScope *Scope);
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
  485 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
  514                                                      LexicalScope *Scope) {
 1258   if (LexicalScope *Scope =
 1275     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
 1304   auto *LScope = LScopes.findLexicalScope(DL);
 1328     auto *PredScope = LScopes.findLexicalScope(PredDL);
 1486                                             LexicalScope &Scope,
 1524     LexicalScope *Scope = nullptr;
 1594     LexicalScope *Scope = nullptr;
 1620     LexicalScope *Scope = nullptr;
 1824   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
 1855   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
lib/CodeGen/AsmPrinter/DwarfDebug.h
  432                                   LexicalScope &Scope,
  438   void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope);
  738   bool isLexicalScopeDIENull(LexicalScope *Scope);
lib/CodeGen/AsmPrinter/DwarfFile.cpp
  104 bool DwarfFile::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
  121 void DwarfFile::addScopeLabel(LexicalScope *LS, DbgLabel *Label) {
lib/CodeGen/AsmPrinter/DwarfFile.h
   91   DenseMap<LexicalScope *, ScopeVars> ScopeVariables;
   95   DenseMap<LexicalScope *, LabelList> ScopeLabels;
  161   bool addScopeVariable(LexicalScope *LS, DbgVariable *Var);
  163   void addScopeLabel(LexicalScope *LS, DbgLabel *Label);
  165   DenseMap<LexicalScope *, ScopeVars> &getScopeVariables() {
  169   DenseMap<LexicalScope *, LabelList> &getScopeLabels() {
lib/CodeGen/LexicalScopes.cpp
   58   DenseMap<const MachineInstr *, LexicalScope *> MI2ScopeMap;
   70     DenseMap<const MachineInstr *, LexicalScope *> &MI2ScopeMap) {
  123 LexicalScope *LexicalScopes::findLexicalScope(const DILocation *DL) {
  141 LexicalScope *LexicalScopes::getOrCreateLexicalScope(const DILocalScope *Scope,
  158 LexicalScope *
  168   LexicalScope *Parent = nullptr;
  186 LexicalScope *
  196   LexicalScope *Parent;
  210 LexicalScope *
  219   LexicalScope *Parent = nullptr;
  233 void LexicalScopes::constructScopeNest(LexicalScope *Scope) {
  235   SmallVector<LexicalScope *, 4> WorkStack;
  239     LexicalScope *WS = WorkStack.back();
  240     const SmallVectorImpl<LexicalScope *> &Children = WS->getChildren();
  260     DenseMap<const MachineInstr *, LexicalScope *> &MI2ScopeMap) {
  261   LexicalScope *PrevLexicalScope = nullptr;
  263     LexicalScope *S = MI2ScopeMap.lookup(R.first);
  284   LexicalScope *Scope = getOrCreateLexicalScope(DL);
  303   LexicalScope *Scope = getOrCreateLexicalScope(DL);
  314       if (LexicalScope *IScope = getOrCreateLexicalScope(IDL))
lib/CodeGen/LiveDebugVariables.cpp
  891   LexicalScope *Scope = LS.findLexicalScope(dl);
usr/include/c++/7.4.0/bits/stl_pair.h
  209     : private __pair_base<_T1, _T2>
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  311        constexpr pair(_U1&& __x, const _T2& __y)
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  380 		       is_copy_assignable<_T2>>::value,
  391 		       is_move_assignable<_T2>>::value,
usr/include/c++/7.4.0/bits/unordered_map.h
  103       typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc>  _Hashtable;
usr/include/c++/7.4.0/type_traits
 1983     { typedef _Up     type; };
usr/include/c++/7.4.0/utility
  180     { typedef _Tp2 type; };
  190         __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
  200         __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
  224     constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
  225     get(std::pair<_Tp1, _Tp2>& __in) noexcept
  229     constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
  230     get(std::pair<_Tp1, _Tp2>&& __in) noexcept
  234     constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
  235     get(const std::pair<_Tp1, _Tp2>& __in) noexcept