Home | History | Annotate | Download | only in Sema 
      1 //===--- ScopeInfo.h - Information about a semantic context -----*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 //  This file defines FunctionScopeInfo and BlockScopeInfo.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #ifndef LLVM_CLANG_SEMA_SCOPE_INFO_H
     15 #define LLVM_CLANG_SEMA_SCOPE_INFO_H
     16 
     17 #include "clang/AST/Type.h"
     18 #include "clang/Basic/PartialDiagnostic.h"
     19 #include "llvm/ADT/DenseMap.h"
     20 #include "llvm/ADT/SmallVector.h"
     21 #include "llvm/ADT/SetVector.h"
     22 
     23 namespace clang {
     24 
     25 class BlockDecl;
     26 class IdentifierInfo;
     27 class LabelDecl;
     28 class ReturnStmt;
     29 class Scope;
     30 class SwitchStmt;
     31 
     32 namespace sema {
     33 
     34 class PossiblyUnreachableDiag {
     35 public:
     36   PartialDiagnostic PD;
     37   SourceLocation Loc;
     38   const Stmt *stmt;
     39 
     40   PossiblyUnreachableDiag(const PartialDiagnostic &PD, SourceLocation Loc,
     41                           const Stmt *stmt)
     42     : PD(PD), Loc(Loc), stmt(stmt) {}
     43 };
     44 
     45 /// \brief Retains information about a function, method, or block that is
     46 /// currently being parsed.
     47 class FunctionScopeInfo {
     48 public:
     49 
     50   /// \brief Whether this scope information structure defined information for
     51   /// a block.
     52   bool IsBlockInfo;
     53 
     54   /// \brief Whether this function contains a VLA, @try, try, C++
     55   /// initializer, or anything else that can't be jumped past.
     56   bool HasBranchProtectedScope;
     57 
     58   /// \brief Whether this function contains any switches or direct gotos.
     59   bool HasBranchIntoScope;
     60 
     61   /// \brief Whether this function contains any indirect gotos.
     62   bool HasIndirectGoto;
     63 
     64   /// \brief Used to determine if errors occurred in this function or block.
     65   DiagnosticErrorTrap ErrorTrap;
     66 
     67   /// SwitchStack - This is the current set of active switch statements in the
     68   /// block.
     69   SmallVector<SwitchStmt*, 8> SwitchStack;
     70 
     71   /// \brief The list of return statements that occur within the function or
     72   /// block, if there is any chance of applying the named return value
     73   /// optimization.
     74   SmallVector<ReturnStmt*, 4> Returns;
     75 
     76   /// \brief A list of PartialDiagnostics created but delayed within the
     77   /// current function scope.  These diagnostics are vetted for reachability
     78   /// prior to being emitted.
     79   SmallVector<PossiblyUnreachableDiag, 4> PossiblyUnreachableDiags;
     80 
     81   void setHasBranchIntoScope() {
     82     HasBranchIntoScope = true;
     83   }
     84 
     85   void setHasBranchProtectedScope() {
     86     HasBranchProtectedScope = true;
     87   }
     88 
     89   void setHasIndirectGoto() {
     90     HasIndirectGoto = true;
     91   }
     92 
     93   bool NeedsScopeChecking() const {
     94     return HasIndirectGoto ||
     95           (HasBranchProtectedScope && HasBranchIntoScope);
     96   }
     97 
     98   FunctionScopeInfo(DiagnosticsEngine &Diag)
     99     : IsBlockInfo(false),
    100       HasBranchProtectedScope(false),
    101       HasBranchIntoScope(false),
    102       HasIndirectGoto(false),
    103       ErrorTrap(Diag) { }
    104 
    105   virtual ~FunctionScopeInfo();
    106 
    107   /// \brief Clear out the information in this function scope, making it
    108   /// suitable for reuse.
    109   void Clear();
    110 
    111   static bool classof(const FunctionScopeInfo *FSI) { return true; }
    112 };
    113 
    114 /// \brief Retains information about a block that is currently being parsed.
    115 class BlockScopeInfo : public FunctionScopeInfo {
    116 public:
    117   BlockDecl *TheDecl;
    118 
    119   /// TheScope - This is the scope for the block itself, which contains
    120   /// arguments etc.
    121   Scope *TheScope;
    122 
    123   /// ReturnType - The return type of the block, or null if the block
    124   /// signature didn't provide an explicit return type.
    125   QualType ReturnType;
    126 
    127   /// BlockType - The function type of the block, if one was given.
    128   /// Its return type may be BuiltinType::Dependent.
    129   QualType FunctionType;
    130 
    131   /// CaptureMap - A map of captured variables to (index+1) into Captures.
    132   llvm::DenseMap<VarDecl*, unsigned> CaptureMap;
    133 
    134   /// Captures - The captured variables.
    135   SmallVector<BlockDecl::Capture, 4> Captures;
    136 
    137   /// CapturesCXXThis - Whether this block captures 'this'.
    138   bool CapturesCXXThis;
    139 
    140   BlockScopeInfo(DiagnosticsEngine &Diag, Scope *BlockScope, BlockDecl *Block)
    141     : FunctionScopeInfo(Diag), TheDecl(Block), TheScope(BlockScope),
    142       CapturesCXXThis(false)
    143   {
    144     IsBlockInfo = true;
    145   }
    146 
    147   virtual ~BlockScopeInfo();
    148 
    149   static bool classof(const FunctionScopeInfo *FSI) { return FSI->IsBlockInfo; }
    150   static bool classof(const BlockScopeInfo *BSI) { return true; }
    151 };
    152 
    153 }
    154 }
    155 
    156 #endif
    157