Home | History | Annotate | Download | only in AST 
      1 //===--- Stmt.cpp - Statement AST Node Implementation ---------------------===//
      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 implements the Stmt class and statement subclasses.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "clang/AST/ASTContext.h"
     15 #include "clang/AST/ASTDiagnostic.h"
     16 #include "clang/AST/ExprCXX.h"
     17 #include "clang/AST/ExprObjC.h"
     18 #include "clang/AST/Stmt.h"
     19 #include "clang/AST/StmtCXX.h"
     20 #include "clang/AST/StmtObjC.h"
     21 #include "clang/AST/Type.h"
     22 #include "clang/Basic/CharInfo.h"
     23 #include "clang/Basic/TargetInfo.h"
     24 #include "clang/Lex/Token.h"
     25 #include "llvm/ADT/StringExtras.h"
     26 #include "llvm/Support/raw_ostream.h"
     27 using namespace clang;
     28 
     29 static struct StmtClassNameTable {
     30   const char *Name;
     31   unsigned Counter;
     32   unsigned Size;
     33 } StmtClassInfo[Stmt::lastStmtConstant+1];
     34 
     35 static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
     36   static bool Initialized = false;
     37   if (Initialized)
     38     return StmtClassInfo[E];
     39 
     40   // Intialize the table on the first use.
     41   Initialized = true;
     42 #define ABSTRACT_STMT(STMT)
     43 #define STMT(CLASS, PARENT) \
     44   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS;    \
     45   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS);
     46 #include "clang/AST/StmtNodes.inc"
     47 
     48   return StmtClassInfo[E];
     49 }
     50 
     51 void *Stmt::operator new(size_t bytes, ASTContext& C,
     52                          unsigned alignment) throw() {
     53   return ::operator new(bytes, C, alignment);
     54 }
     55 
     56 void *Stmt::operator new(size_t bytes, ASTContext* C,
     57                          unsigned alignment) throw() {
     58   return ::operator new(bytes, *C, alignment);
     59 }
     60 
     61 const char *Stmt::getStmtClassName() const {
     62   return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
     63 }
     64 
     65 void Stmt::PrintStats() {
     66   // Ensure the table is primed.
     67   getStmtInfoTableEntry(Stmt::NullStmtClass);
     68 
     69   unsigned sum = 0;
     70   llvm::errs() << "\n*** Stmt/Expr Stats:\n";
     71   for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
     72     if (StmtClassInfo[i].Name == 0) continue;
     73     sum += StmtClassInfo[i].Counter;
     74   }
     75   llvm::errs() << "  " << sum << " stmts/exprs total.\n";
     76   sum = 0;
     77   for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
     78     if (StmtClassInfo[i].Name == 0) continue;
     79     if (StmtClassInfo[i].Counter == 0) continue;
     80     llvm::errs() << "    " << StmtClassInfo[i].Counter << " "
     81                  << StmtClassInfo[i].Name << ", " << StmtClassInfo[i].Size
     82                  << " each (" << StmtClassInfo[i].Counter*StmtClassInfo[i].Size
     83                  << " bytes)\n";
     84     sum += StmtClassInfo[i].Counter*StmtClassInfo[i].Size;
     85   }
     86 
     87   llvm::errs() << "Total bytes = " << sum << "\n";
     88 }
     89 
     90 void Stmt::addStmtClass(StmtClass s) {
     91   ++getStmtInfoTableEntry(s).Counter;
     92 }
     93 
     94 bool Stmt::StatisticsEnabled = false;
     95 void Stmt::EnableStatistics() {
     96   StatisticsEnabled = true;
     97 }
     98 
     99 Stmt *Stmt::IgnoreImplicit() {
    100   Stmt *s = this;
    101 
    102   if (ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(s))
    103     s = ewc->getSubExpr();
    104 
    105   while (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(s))
    106     s = ice->getSubExpr();
    107 
    108   return s;
    109 }
    110 
    111 /// \brief Strip off all label-like statements.
    112 ///
    113 /// This will strip off label statements, case statements, attributed
    114 /// statements and default statements recursively.
    115 const Stmt *Stmt::stripLabelLikeStatements() const {
    116   const Stmt *S = this;
    117   while (true) {
    118     if (const LabelStmt *LS = dyn_cast<LabelStmt>(S))
    119       S = LS->getSubStmt();
    120     else if (const SwitchCase *SC = dyn_cast<SwitchCase>(S))
    121       S = SC->getSubStmt();
    122     else if (const AttributedStmt *AS = dyn_cast<AttributedStmt>(S))
    123       S = AS->getSubStmt();
    124     else
    125       return S;
    126   }
    127 }
    128 
    129 namespace {
    130   struct good {};
    131   struct bad {};
    132 
    133   // These silly little functions have to be static inline to suppress
    134   // unused warnings, and they have to be defined to suppress other
    135   // warnings.
    136   static inline good is_good(good) { return good(); }
    137 
    138   typedef Stmt::child_range children_t();
    139   template <class T> good implements_children(children_t T::*) {
    140     return good();
    141   }
    142   static inline bad implements_children(children_t Stmt::*) {
    143     return bad();
    144   }
    145 
    146   typedef SourceLocation getLocStart_t() const;
    147   template <class T> good implements_getLocStart(getLocStart_t T::*) {
    148     return good();
    149   }
    150   static inline bad implements_getLocStart(getLocStart_t Stmt::*) {
    151     return bad();
    152   }
    153 
    154   typedef SourceLocation getLocEnd_t() const;
    155   template <class T> good implements_getLocEnd(getLocEnd_t T::*) {
    156     return good();
    157   }
    158   static inline bad implements_getLocEnd(getLocEnd_t Stmt::*) {
    159     return bad();
    160   }
    161 
    162 #define ASSERT_IMPLEMENTS_children(type) \
    163   (void) sizeof(is_good(implements_children(&type::children)))
    164 #define ASSERT_IMPLEMENTS_getLocStart(type) \
    165   (void) sizeof(is_good(implements_getLocStart(&type::getLocStart)))
    166 #define ASSERT_IMPLEMENTS_getLocEnd(type) \
    167   (void) sizeof(is_good(implements_getLocEnd(&type::getLocEnd)))
    168 }
    169 
    170 /// Check whether the various Stmt classes implement their member
    171 /// functions.
    172 static inline void check_implementations() {
    173 #define ABSTRACT_STMT(type)
    174 #define STMT(type, base) \
    175   ASSERT_IMPLEMENTS_children(type); \
    176   ASSERT_IMPLEMENTS_getLocStart(type); \
    177   ASSERT_IMPLEMENTS_getLocEnd(type);
    178 #include "clang/AST/StmtNodes.inc"
    179 }
    180 
    181 Stmt::child_range Stmt::children() {
    182   switch (getStmtClass()) {
    183   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
    184 #define ABSTRACT_STMT(type)
    185 #define STMT(type, base) \
    186   case Stmt::type##Class: \
    187     return static_cast<type*>(this)->children();
    188 #include "clang/AST/StmtNodes.inc"
    189   }
    190   llvm_unreachable("unknown statement kind!");
    191 }
    192 
    193 // Amusing macro metaprogramming hack: check whether a class provides
    194 // a more specific implementation of getSourceRange.
    195 //
    196 // See also Expr.cpp:getExprLoc().
    197 namespace {
    198   /// This implementation is used when a class provides a custom
    199   /// implementation of getSourceRange.
    200   template <class S, class T>
    201   SourceRange getSourceRangeImpl(const Stmt *stmt,
    202                                  SourceRange (T::*v)() const) {
    203     return static_cast<const S*>(stmt)->getSourceRange();
    204   }
    205 
    206   /// This implementation is used when a class doesn't provide a custom
    207   /// implementation of getSourceRange.  Overload resolution should pick it over
    208   /// the implementation above because it's more specialized according to
    209   /// function template partial ordering.
    210   template <class S>
    211   SourceRange getSourceRangeImpl(const Stmt *stmt,
    212                                  SourceRange (Stmt::*v)() const) {
    213     return SourceRange(static_cast<const S*>(stmt)->getLocStart(),
    214                        static_cast<const S*>(stmt)->getLocEnd());
    215   }
    216 }
    217 
    218 SourceRange Stmt::getSourceRange() const {
    219   switch (getStmtClass()) {
    220   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
    221 #define ABSTRACT_STMT(type)
    222 #define STMT(type, base) \
    223   case Stmt::type##Class: \
    224     return getSourceRangeImpl<type>(this, &type::getSourceRange);
    225 #include "clang/AST/StmtNodes.inc"
    226   }
    227   llvm_unreachable("unknown statement kind!");
    228 }
    229 
    230 SourceLocation Stmt::getLocStart() const {
    231 //  llvm::errs() << "getLocStart() for " << getStmtClassName() << "\n";
    232   switch (getStmtClass()) {
    233   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
    234 #define ABSTRACT_STMT(type)
    235 #define STMT(type, base) \
    236   case Stmt::type##Class: \
    237     return static_cast<const type*>(this)->getLocStart();
    238 #include "clang/AST/StmtNodes.inc"
    239   }
    240   llvm_unreachable("unknown statement kind");
    241 }
    242 
    243 SourceLocation Stmt::getLocEnd() const {
    244   switch (getStmtClass()) {
    245   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
    246 #define ABSTRACT_STMT(type)
    247 #define STMT(type, base) \
    248   case Stmt::type##Class: \
    249     return static_cast<const type*>(this)->getLocEnd();
    250 #include "clang/AST/StmtNodes.inc"
    251   }
    252   llvm_unreachable("unknown statement kind");
    253 }
    254 
    255 CompoundStmt::CompoundStmt(ASTContext &C, ArrayRef<Stmt*> Stmts,
    256                            SourceLocation LB, SourceLocation RB)
    257   : Stmt(CompoundStmtClass), LBracLoc(LB), RBracLoc(RB) {
    258   CompoundStmtBits.NumStmts = Stmts.size();
    259   assert(CompoundStmtBits.NumStmts == Stmts.size() &&
    260          "NumStmts doesn't fit in bits of CompoundStmtBits.NumStmts!");
    261 
    262   if (Stmts.size() == 0) {
    263     Body = 0;
    264     return;
    265   }
    266 
    267   Body = new (C) Stmt*[Stmts.size()];
    268   std::copy(Stmts.begin(), Stmts.end(), Body);
    269 }
    270 
    271 void CompoundStmt::setStmts(ASTContext &C, Stmt **Stmts, unsigned NumStmts) {
    272   if (this->Body)
    273     C.Deallocate(Body);
    274   this->CompoundStmtBits.NumStmts = NumStmts;
    275 
    276   Body = new (C) Stmt*[NumStmts];
    277   memcpy(Body, Stmts, sizeof(Stmt *) * NumStmts);
    278 }
    279 
    280 const char *LabelStmt::getName() const {
    281   return getDecl()->getIdentifier()->getNameStart();
    282 }
    283 
    284 AttributedStmt *AttributedStmt::Create(ASTContext &C, SourceLocation Loc,
    285                                        ArrayRef<const Attr*> Attrs,
    286                                        Stmt *SubStmt) {
    287   void *Mem = C.Allocate(sizeof(AttributedStmt) +
    288                          sizeof(Attr*) * (Attrs.size() - 1),
    289                          llvm::alignOf<AttributedStmt>());
    290   return new (Mem) AttributedStmt(Loc, Attrs, SubStmt);
    291 }
    292 
    293 AttributedStmt *AttributedStmt::CreateEmpty(ASTContext &C, unsigned NumAttrs) {
    294   assert(NumAttrs > 0 && "NumAttrs should be greater than zero");
    295   void *Mem = C.Allocate(sizeof(AttributedStmt) +
    296                          sizeof(Attr*) * (NumAttrs - 1),
    297                          llvm::alignOf<AttributedStmt>());
    298   return new (Mem) AttributedStmt(EmptyShell(), NumAttrs);
    299 }
    300 
    301 bool Stmt::hasImplicitControlFlow() const {
    302   switch (StmtBits.sClass) {
    303     default:
    304       return false;
    305 
    306     case CallExprClass:
    307     case ConditionalOperatorClass:
    308     case ChooseExprClass:
    309     case StmtExprClass:
    310     case DeclStmtClass:
    311       return true;
    312 
    313     case Stmt::BinaryOperatorClass: {
    314       const BinaryOperator* B = cast<BinaryOperator>(this);
    315       if (B->isLogicalOp() || B->getOpcode() == BO_Comma)
    316         return true;
    317       else
    318         return false;
    319     }
    320   }
    321 }
    322 
    323 std::string AsmStmt::generateAsmString(ASTContext &C) const {
    324   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    325     return gccAsmStmt->generateAsmString(C);
    326   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    327     return msAsmStmt->generateAsmString(C);
    328   llvm_unreachable("unknown asm statement kind!");
    329 }
    330 
    331 StringRef AsmStmt::getOutputConstraint(unsigned i) const {
    332   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    333     return gccAsmStmt->getOutputConstraint(i);
    334   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    335     return msAsmStmt->getOutputConstraint(i);
    336   llvm_unreachable("unknown asm statement kind!");
    337 }
    338 
    339 const Expr *AsmStmt::getOutputExpr(unsigned i) const {
    340   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    341     return gccAsmStmt->getOutputExpr(i);
    342   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    343     return msAsmStmt->getOutputExpr(i);
    344   llvm_unreachable("unknown asm statement kind!");
    345 }
    346 
    347 StringRef AsmStmt::getInputConstraint(unsigned i) const {
    348   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    349     return gccAsmStmt->getInputConstraint(i);
    350   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    351     return msAsmStmt->getInputConstraint(i);
    352   llvm_unreachable("unknown asm statement kind!");
    353 }
    354 
    355 const Expr *AsmStmt::getInputExpr(unsigned i) const {
    356   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    357     return gccAsmStmt->getInputExpr(i);
    358   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    359     return msAsmStmt->getInputExpr(i);
    360   llvm_unreachable("unknown asm statement kind!");
    361 }
    362 
    363 StringRef AsmStmt::getClobber(unsigned i) const {
    364   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    365     return gccAsmStmt->getClobber(i);
    366   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    367     return msAsmStmt->getClobber(i);
    368   llvm_unreachable("unknown asm statement kind!");
    369 }
    370 
    371 /// getNumPlusOperands - Return the number of output operands that have a "+"
    372 /// constraint.
    373 unsigned AsmStmt::getNumPlusOperands() const {
    374   unsigned Res = 0;
    375   for (unsigned i = 0, e = getNumOutputs(); i != e; ++i)
    376     if (isOutputPlusConstraint(i))
    377       ++Res;
    378   return Res;
    379 }
    380 
    381 StringRef GCCAsmStmt::getClobber(unsigned i) const {
    382   return getClobberStringLiteral(i)->getString();
    383 }
    384 
    385 Expr *GCCAsmStmt::getOutputExpr(unsigned i) {
    386   return cast<Expr>(Exprs[i]);
    387 }
    388 
    389 /// getOutputConstraint - Return the constraint string for the specified
    390 /// output operand.  All output constraints are known to be non-empty (either
    391 /// '=' or '+').
    392 StringRef GCCAsmStmt::getOutputConstraint(unsigned i) const {
    393   return getOutputConstraintLiteral(i)->getString();
    394 }
    395 
    396 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
    397   return cast<Expr>(Exprs[i + NumOutputs]);
    398 }
    399 void GCCAsmStmt::setInputExpr(unsigned i, Expr *E) {
    400   Exprs[i + NumOutputs] = E;
    401 }
    402 
    403 /// getInputConstraint - Return the specified input constraint.  Unlike output
    404 /// constraints, these can be empty.
    405 StringRef GCCAsmStmt::getInputConstraint(unsigned i) const {
    406   return getInputConstraintLiteral(i)->getString();
    407 }
    408 
    409 void GCCAsmStmt::setOutputsAndInputsAndClobbers(ASTContext &C,
    410                                              IdentifierInfo **Names,
    411                                              StringLiteral **Constraints,
    412                                              Stmt **Exprs,
    413                                              unsigned NumOutputs,
    414                                              unsigned NumInputs,
    415                                              StringLiteral **Clobbers,
    416                                              unsigned NumClobbers) {
    417   this->NumOutputs = NumOutputs;
    418   this->NumInputs = NumInputs;
    419   this->NumClobbers = NumClobbers;
    420 
    421   unsigned NumExprs = NumOutputs + NumInputs;
    422 
    423   C.Deallocate(this->Names);
    424   this->Names = new (C) IdentifierInfo*[NumExprs];
    425   std::copy(Names, Names + NumExprs, this->Names);
    426 
    427   C.Deallocate(this->Exprs);
    428   this->Exprs = new (C) Stmt*[NumExprs];
    429   std::copy(Exprs, Exprs + NumExprs, this->Exprs);
    430 
    431   C.Deallocate(this->Constraints);
    432   this->Constraints = new (C) StringLiteral*[NumExprs];
    433   std::copy(Constraints, Constraints + NumExprs, this->Constraints);
    434 
    435   C.Deallocate(this->Clobbers);
    436   this->Clobbers = new (C) StringLiteral*[NumClobbers];
    437   std::copy(Clobbers, Clobbers + NumClobbers, this->Clobbers);
    438 }
    439 
    440 /// getNamedOperand - Given a symbolic operand reference like %[foo],
    441 /// translate this into a numeric value needed to reference the same operand.
    442 /// This returns -1 if the operand name is invalid.
    443 int GCCAsmStmt::getNamedOperand(StringRef SymbolicName) const {
    444   unsigned NumPlusOperands = 0;
    445 
    446   // Check if this is an output operand.
    447   for (unsigned i = 0, e = getNumOutputs(); i != e; ++i) {
    448     if (getOutputName(i) == SymbolicName)
    449       return i;
    450   }
    451 
    452   for (unsigned i = 0, e = getNumInputs(); i != e; ++i)
    453     if (getInputName(i) == SymbolicName)
    454       return getNumOutputs() + NumPlusOperands + i;
    455 
    456   // Not found.
    457   return -1;
    458 }
    459 
    460 /// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing
    461 /// it into pieces.  If the asm string is erroneous, emit errors and return
    462 /// true, otherwise return false.
    463 unsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece>&Pieces,
    464                                    ASTContext &C, unsigned &DiagOffs) const {
    465   StringRef Str = getAsmString()->getString();
    466   const char *StrStart = Str.begin();
    467   const char *StrEnd = Str.end();
    468   const char *CurPtr = StrStart;
    469 
    470   // "Simple" inline asms have no constraints or operands, just convert the asm
    471   // string to escape $'s.
    472   if (isSimple()) {
    473     std::string Result;
    474     for (; CurPtr != StrEnd; ++CurPtr) {
    475       switch (*CurPtr) {
    476       case '$':
    477         Result += "$$";
    478         break;
    479       default:
    480         Result += *CurPtr;
    481         break;
    482       }
    483     }
    484     Pieces.push_back(AsmStringPiece(Result));
    485     return 0;
    486   }
    487 
    488   // CurStringPiece - The current string that we are building up as we scan the
    489   // asm string.
    490   std::string CurStringPiece;
    491 
    492   bool HasVariants = !C.getTargetInfo().hasNoAsmVariants();
    493 
    494   while (1) {
    495     // Done with the string?
    496     if (CurPtr == StrEnd) {
    497       if (!CurStringPiece.empty())
    498         Pieces.push_back(AsmStringPiece(CurStringPiece));
    499       return 0;
    500     }
    501 
    502     char CurChar = *CurPtr++;
    503     switch (CurChar) {
    504     case '$': CurStringPiece += "$$"; continue;
    505     case '{': CurStringPiece += (HasVariants ? "$(" : "{"); continue;
    506     case '|': CurStringPiece += (HasVariants ? "$|" : "|"); continue;
    507     case '}': CurStringPiece += (HasVariants ? "$)" : "}"); continue;
    508     case '%':
    509       break;
    510     default:
    511       CurStringPiece += CurChar;
    512       continue;
    513     }
    514 
    515     // Escaped "%" character in asm string.
    516     if (CurPtr == StrEnd) {
    517       // % at end of string is invalid (no escape).
    518       DiagOffs = CurPtr-StrStart-1;
    519       return diag::err_asm_invalid_escape;
    520     }
    521 
    522     char EscapedChar = *CurPtr++;
    523     if (EscapedChar == '%') {  // %% -> %
    524       // Escaped percentage sign.
    525       CurStringPiece += '%';
    526       continue;
    527     }
    528 
    529     if (EscapedChar == '=') {  // %= -> Generate an unique ID.
    530       CurStringPiece += "${:uid}";
    531       continue;
    532     }
    533 
    534     // Otherwise, we have an operand.  If we have accumulated a string so far,
    535     // add it to the Pieces list.
    536     if (!CurStringPiece.empty()) {
    537       Pieces.push_back(AsmStringPiece(CurStringPiece));
    538       CurStringPiece.clear();
    539     }
    540 
    541     // Handle %x4 and %x[foo] by capturing x as the modifier character.
    542     char Modifier = '\0';
    543     if (isLetter(EscapedChar)) {
    544       if (CurPtr == StrEnd) { // Premature end.
    545         DiagOffs = CurPtr-StrStart-1;
    546         return diag::err_asm_invalid_escape;
    547       }
    548       Modifier = EscapedChar;
    549       EscapedChar = *CurPtr++;
    550     }
    551 
    552     if (isDigit(EscapedChar)) {
    553       // %n - Assembler operand n
    554       unsigned N = 0;
    555 
    556       --CurPtr;
    557       while (CurPtr != StrEnd && isDigit(*CurPtr))
    558         N = N*10 + ((*CurPtr++)-'0');
    559 
    560       unsigned NumOperands =
    561         getNumOutputs() + getNumPlusOperands() + getNumInputs();
    562       if (N >= NumOperands) {
    563         DiagOffs = CurPtr-StrStart-1;
    564         return diag::err_asm_invalid_operand_number;
    565       }
    566 
    567       Pieces.push_back(AsmStringPiece(N, Modifier));
    568       continue;
    569     }
    570 
    571     // Handle %[foo], a symbolic operand reference.
    572     if (EscapedChar == '[') {
    573       DiagOffs = CurPtr-StrStart-1;
    574 
    575       // Find the ']'.
    576       const char *NameEnd = (const char*)memchr(CurPtr, ']', StrEnd-CurPtr);
    577       if (NameEnd == 0)
    578         return diag::err_asm_unterminated_symbolic_operand_name;
    579       if (NameEnd == CurPtr)
    580         return diag::err_asm_empty_symbolic_operand_name;
    581 
    582       StringRef SymbolicName(CurPtr, NameEnd - CurPtr);
    583 
    584       int N = getNamedOperand(SymbolicName);
    585       if (N == -1) {
    586         // Verify that an operand with that name exists.
    587         DiagOffs = CurPtr-StrStart;
    588         return diag::err_asm_unknown_symbolic_operand_name;
    589       }
    590       Pieces.push_back(AsmStringPiece(N, Modifier));
    591 
    592       CurPtr = NameEnd+1;
    593       continue;
    594     }
    595 
    596     DiagOffs = CurPtr-StrStart-1;
    597     return diag::err_asm_invalid_escape;
    598   }
    599 }
    600 
    601 /// Assemble final IR asm string (GCC-style).
    602 std::string GCCAsmStmt::generateAsmString(ASTContext &C) const {
    603   // Analyze the asm string to decompose it into its pieces.  We know that Sema
    604   // has already done this, so it is guaranteed to be successful.
    605   SmallVector<GCCAsmStmt::AsmStringPiece, 4> Pieces;
    606   unsigned DiagOffs;
    607   AnalyzeAsmString(Pieces, C, DiagOffs);
    608 
    609   std::string AsmString;
    610   for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {
    611     if (Pieces[i].isString())
    612       AsmString += Pieces[i].getString();
    613     else if (Pieces[i].getModifier() == '\0')
    614       AsmString += '$' + llvm::utostr(Pieces[i].getOperandNo());
    615     else
    616       AsmString += "${" + llvm::utostr(Pieces[i].getOperandNo()) + ':' +
    617                    Pieces[i].getModifier() + '}';
    618   }
    619   return AsmString;
    620 }
    621 
    622 /// Assemble final IR asm string (MS-style).
    623 std::string MSAsmStmt::generateAsmString(ASTContext &C) const {
    624   // FIXME: This needs to be translated into the IR string representation.
    625   return AsmStr;
    626 }
    627 
    628 Expr *MSAsmStmt::getOutputExpr(unsigned i) {
    629   return cast<Expr>(Exprs[i]);
    630 }
    631 
    632 Expr *MSAsmStmt::getInputExpr(unsigned i) {
    633   return cast<Expr>(Exprs[i + NumOutputs]);
    634 }
    635 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
    636   Exprs[i + NumOutputs] = E;
    637 }
    638 
    639 QualType CXXCatchStmt::getCaughtType() const {
    640   if (ExceptionDecl)
    641     return ExceptionDecl->getType();
    642   return QualType();
    643 }
    644 
    645 //===----------------------------------------------------------------------===//
    646 // Constructors
    647 //===----------------------------------------------------------------------===//
    648 
    649 GCCAsmStmt::GCCAsmStmt(ASTContext &C, SourceLocation asmloc, bool issimple,
    650                        bool isvolatile, unsigned numoutputs, unsigned numinputs,
    651                        IdentifierInfo **names, StringLiteral **constraints,
    652                        Expr **exprs, StringLiteral *asmstr,
    653                        unsigned numclobbers, StringLiteral **clobbers,
    654                        SourceLocation rparenloc)
    655   : AsmStmt(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
    656             numinputs, numclobbers), RParenLoc(rparenloc), AsmStr(asmstr) {
    657 
    658   unsigned NumExprs = NumOutputs + NumInputs;
    659 
    660   Names = new (C) IdentifierInfo*[NumExprs];
    661   std::copy(names, names + NumExprs, Names);
    662 
    663   Exprs = new (C) Stmt*[NumExprs];
    664   std::copy(exprs, exprs + NumExprs, Exprs);
    665 
    666   Constraints = new (C) StringLiteral*[NumExprs];
    667   std::copy(constraints, constraints + NumExprs, Constraints);
    668 
    669   Clobbers = new (C) StringLiteral*[NumClobbers];
    670   std::copy(clobbers, clobbers + NumClobbers, Clobbers);
    671 }
    672 
    673 MSAsmStmt::MSAsmStmt(ASTContext &C, SourceLocation asmloc,
    674                      SourceLocation lbraceloc, bool issimple, bool isvolatile,
    675                      ArrayRef<Token> asmtoks, unsigned numoutputs,
    676                      unsigned numinputs, ArrayRef<IdentifierInfo*> names,
    677                      ArrayRef<StringRef> constraints, ArrayRef<Expr*> exprs,
    678                      StringRef asmstr, ArrayRef<StringRef> clobbers,
    679                      SourceLocation endloc)
    680   : AsmStmt(MSAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
    681             numinputs, clobbers.size()), LBraceLoc(lbraceloc),
    682             EndLoc(endloc), AsmStr(asmstr.str()), NumAsmToks(asmtoks.size()) {
    683 
    684   unsigned NumExprs = NumOutputs + NumInputs;
    685 
    686   Names = new (C) IdentifierInfo*[NumExprs];
    687   for (unsigned i = 0, e = NumExprs; i != e; ++i)
    688     Names[i] = names[i];
    689 
    690   Exprs = new (C) Stmt*[NumExprs];
    691   for (unsigned i = 0, e = NumExprs; i != e; ++i)
    692     Exprs[i] = exprs[i];
    693 
    694   AsmToks = new (C) Token[NumAsmToks];
    695   for (unsigned i = 0, e = NumAsmToks; i != e; ++i)
    696     AsmToks[i] = asmtoks[i];
    697 
    698   Constraints = new (C) StringRef[NumExprs];
    699   for (unsigned i = 0, e = NumExprs; i != e; ++i) {
    700     size_t size = constraints[i].size();
    701     char *dest = new (C) char[size];
    702     std::strncpy(dest, constraints[i].data(), size);
    703     Constraints[i] = StringRef(dest, size);
    704   }
    705 
    706   Clobbers = new (C) StringRef[NumClobbers];
    707   for (unsigned i = 0, e = NumClobbers; i != e; ++i) {
    708     // FIXME: Avoid the allocation/copy if at all possible.
    709     size_t size = clobbers[i].size();
    710     char *dest = new (C) char[size];
    711     std::strncpy(dest, clobbers[i].data(), size);
    712     Clobbers[i] = StringRef(dest, size);
    713   }
    714 }
    715 
    716 ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
    717                                              Stmt *Body,  SourceLocation FCL,
    718                                              SourceLocation RPL)
    719 : Stmt(ObjCForCollectionStmtClass) {
    720   SubExprs[ELEM] = Elem;
    721   SubExprs[COLLECTION] = reinterpret_cast<Stmt*>(Collect);
    722   SubExprs[BODY] = Body;
    723   ForLoc = FCL;
    724   RParenLoc = RPL;
    725 }
    726 
    727 ObjCAtTryStmt::ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
    728                              Stmt **CatchStmts, unsigned NumCatchStmts,
    729                              Stmt *atFinallyStmt)
    730   : Stmt(ObjCAtTryStmtClass), AtTryLoc(atTryLoc),
    731     NumCatchStmts(NumCatchStmts), HasFinally(atFinallyStmt != 0)
    732 {
    733   Stmt **Stmts = getStmts();
    734   Stmts[0] = atTryStmt;
    735   for (unsigned I = 0; I != NumCatchStmts; ++I)
    736     Stmts[I + 1] = CatchStmts[I];
    737 
    738   if (HasFinally)
    739     Stmts[NumCatchStmts + 1] = atFinallyStmt;
    740 }
    741 
    742 ObjCAtTryStmt *ObjCAtTryStmt::Create(ASTContext &Context,
    743                                      SourceLocation atTryLoc,
    744                                      Stmt *atTryStmt,
    745                                      Stmt **CatchStmts,
    746                                      unsigned NumCatchStmts,
    747                                      Stmt *atFinallyStmt) {
    748   unsigned Size = sizeof(ObjCAtTryStmt) +
    749     (1 + NumCatchStmts + (atFinallyStmt != 0)) * sizeof(Stmt *);
    750   void *Mem = Context.Allocate(Size, llvm::alignOf<ObjCAtTryStmt>());
    751   return new (Mem) ObjCAtTryStmt(atTryLoc, atTryStmt, CatchStmts, NumCatchStmts,
    752                                  atFinallyStmt);
    753 }
    754 
    755 ObjCAtTryStmt *ObjCAtTryStmt::CreateEmpty(ASTContext &Context,
    756                                                  unsigned NumCatchStmts,
    757                                                  bool HasFinally) {
    758   unsigned Size = sizeof(ObjCAtTryStmt) +
    759     (1 + NumCatchStmts + HasFinally) * sizeof(Stmt *);
    760   void *Mem = Context.Allocate(Size, llvm::alignOf<ObjCAtTryStmt>());
    761   return new (Mem) ObjCAtTryStmt(EmptyShell(), NumCatchStmts, HasFinally);
    762 }
    763 
    764 SourceLocation ObjCAtTryStmt::getLocEnd() const {
    765   if (HasFinally)
    766     return getFinallyStmt()->getLocEnd();
    767   if (NumCatchStmts)
    768     return getCatchStmt(NumCatchStmts - 1)->getLocEnd();
    769   return getTryBody()->getLocEnd();
    770 }
    771 
    772 CXXTryStmt *CXXTryStmt::Create(ASTContext &C, SourceLocation tryLoc,
    773                                Stmt *tryBlock, ArrayRef<Stmt*> handlers) {
    774   std::size_t Size = sizeof(CXXTryStmt);
    775   Size += ((handlers.size() + 1) * sizeof(Stmt));
    776 
    777   void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
    778   return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers);
    779 }
    780 
    781 CXXTryStmt *CXXTryStmt::Create(ASTContext &C, EmptyShell Empty,
    782                                unsigned numHandlers) {
    783   std::size_t Size = sizeof(CXXTryStmt);
    784   Size += ((numHandlers + 1) * sizeof(Stmt));
    785 
    786   void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
    787   return new (Mem) CXXTryStmt(Empty, numHandlers);
    788 }
    789 
    790 CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
    791                        ArrayRef<Stmt*> handlers)
    792   : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
    793   Stmt **Stmts = reinterpret_cast<Stmt **>(this + 1);
    794   Stmts[0] = tryBlock;
    795   std::copy(handlers.begin(), handlers.end(), Stmts + 1);
    796 }
    797 
    798 CXXForRangeStmt::CXXForRangeStmt(DeclStmt *Range, DeclStmt *BeginEndStmt,
    799                                  Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
    800                                  Stmt *Body, SourceLocation FL,
    801                                  SourceLocation CL, SourceLocation RPL)
    802   : Stmt(CXXForRangeStmtClass), ForLoc(FL), ColonLoc(CL), RParenLoc(RPL) {
    803   SubExprs[RANGE] = Range;
    804   SubExprs[BEGINEND] = BeginEndStmt;
    805   SubExprs[COND] = reinterpret_cast<Stmt*>(Cond);
    806   SubExprs[INC] = reinterpret_cast<Stmt*>(Inc);
    807   SubExprs[LOOPVAR] = LoopVar;
    808   SubExprs[BODY] = Body;
    809 }
    810 
    811 Expr *CXXForRangeStmt::getRangeInit() {
    812   DeclStmt *RangeStmt = getRangeStmt();
    813   VarDecl *RangeDecl = dyn_cast_or_null<VarDecl>(RangeStmt->getSingleDecl());
    814   assert(RangeDecl &&& "for-range should have a single var decl");
    815   return RangeDecl->getInit();
    816 }
    817 
    818 const Expr *CXXForRangeStmt::getRangeInit() const {
    819   return const_cast<CXXForRangeStmt*>(this)->getRangeInit();
    820 }
    821 
    822 VarDecl *CXXForRangeStmt::getLoopVariable() {
    823   Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl();
    824   assert(LV && "No loop variable in CXXForRangeStmt");
    825   return cast<VarDecl>(LV);
    826 }
    827 
    828 const VarDecl *CXXForRangeStmt::getLoopVariable() const {
    829   return const_cast<CXXForRangeStmt*>(this)->getLoopVariable();
    830 }
    831 
    832 IfStmt::IfStmt(ASTContext &C, SourceLocation IL, VarDecl *var, Expr *cond,
    833                Stmt *then, SourceLocation EL, Stmt *elsev)
    834   : Stmt(IfStmtClass), IfLoc(IL), ElseLoc(EL)
    835 {
    836   setConditionVariable(C, var);
    837   SubExprs[COND] = reinterpret_cast<Stmt*>(cond);
    838   SubExprs[THEN] = then;
    839   SubExprs[ELSE] = elsev;
    840 }
    841 
    842 VarDecl *IfStmt::getConditionVariable() const {
    843   if (!SubExprs[VAR])
    844     return 0;
    845 
    846   DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
    847   return cast<VarDecl>(DS->getSingleDecl());
    848 }
    849 
    850 void IfStmt::setConditionVariable(ASTContext &C, VarDecl *V) {
    851   if (!V) {
    852     SubExprs[VAR] = 0;
    853     return;
    854   }
    855 
    856   SourceRange VarRange = V->getSourceRange();
    857   SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
    858                                    VarRange.getEnd());
    859 }
    860 
    861 ForStmt::ForStmt(ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
    862                  Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
    863                  SourceLocation RP)
    864   : Stmt(ForStmtClass), ForLoc(FL), LParenLoc(LP), RParenLoc(RP)
    865 {
    866   SubExprs[INIT] = Init;
    867   setConditionVariable(C, condVar);
    868   SubExprs[COND] = reinterpret_cast<Stmt*>(Cond);
    869   SubExprs[INC] = reinterpret_cast<Stmt*>(Inc);
    870   SubExprs[BODY] = Body;
    871 }
    872 
    873 VarDecl *ForStmt::getConditionVariable() const {
    874   if (!SubExprs[CONDVAR])
    875     return 0;
    876 
    877   DeclStmt *DS = cast<DeclStmt>(SubExprs[CONDVAR]);
    878   return cast<VarDecl>(DS->getSingleDecl());
    879 }
    880 
    881 void ForStmt::setConditionVariable(ASTContext &C, VarDecl *V) {
    882   if (!V) {
    883     SubExprs[CONDVAR] = 0;
    884     return;
    885   }
    886 
    887   SourceRange VarRange = V->getSourceRange();
    888   SubExprs[CONDVAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
    889                                        VarRange.getEnd());
    890 }
    891 
    892 SwitchStmt::SwitchStmt(ASTContext &C, VarDecl *Var, Expr *cond)
    893   : Stmt(SwitchStmtClass), FirstCase(0), AllEnumCasesCovered(0)
    894 {
    895   setConditionVariable(C, Var);
    896   SubExprs[COND] = reinterpret_cast<Stmt*>(cond);
    897   SubExprs[BODY] = NULL;
    898 }
    899 
    900 VarDecl *SwitchStmt::getConditionVariable() const {
    901   if (!SubExprs[VAR])
    902     return 0;
    903 
    904   DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
    905   return cast<VarDecl>(DS->getSingleDecl());
    906 }
    907 
    908 void SwitchStmt::setConditionVariable(ASTContext &C, VarDecl *V) {
    909   if (!V) {
    910     SubExprs[VAR] = 0;
    911     return;
    912   }
    913 
    914   SourceRange VarRange = V->getSourceRange();
    915   SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
    916                                    VarRange.getEnd());
    917 }
    918 
    919 Stmt *SwitchCase::getSubStmt() {
    920   if (isa<CaseStmt>(this))
    921     return cast<CaseStmt>(this)->getSubStmt();
    922   return cast<DefaultStmt>(this)->getSubStmt();
    923 }
    924 
    925 WhileStmt::WhileStmt(ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body,
    926                      SourceLocation WL)
    927   : Stmt(WhileStmtClass) {
    928   setConditionVariable(C, Var);
    929   SubExprs[COND] = reinterpret_cast<Stmt*>(cond);
    930   SubExprs[BODY] = body;
    931   WhileLoc = WL;
    932 }
    933 
    934 VarDecl *WhileStmt::getConditionVariable() const {
    935   if (!SubExprs[VAR])
    936     return 0;
    937 
    938   DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
    939   return cast<VarDecl>(DS->getSingleDecl());
    940 }
    941 
    942 void WhileStmt::setConditionVariable(ASTContext &C, VarDecl *V) {
    943   if (!V) {
    944     SubExprs[VAR] = 0;
    945     return;
    946   }
    947 
    948   SourceRange VarRange = V->getSourceRange();
    949   SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
    950                                    VarRange.getEnd());
    951 }
    952 
    953 // IndirectGotoStmt
    954 LabelDecl *IndirectGotoStmt::getConstantTarget() {
    955   if (AddrLabelExpr *E =
    956         dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts()))
    957     return E->getLabel();
    958   return 0;
    959 }
    960 
    961 // ReturnStmt
    962 const Expr* ReturnStmt::getRetValue() const {
    963   return cast_or_null<Expr>(RetExpr);
    964 }
    965 Expr* ReturnStmt::getRetValue() {
    966   return cast_or_null<Expr>(RetExpr);
    967 }
    968 
    969 SEHTryStmt::SEHTryStmt(bool IsCXXTry,
    970                        SourceLocation TryLoc,
    971                        Stmt *TryBlock,
    972                        Stmt *Handler)
    973   : Stmt(SEHTryStmtClass),
    974     IsCXXTry(IsCXXTry),
    975     TryLoc(TryLoc)
    976 {
    977   Children[TRY]     = TryBlock;
    978   Children[HANDLER] = Handler;
    979 }
    980 
    981 SEHTryStmt* SEHTryStmt::Create(ASTContext &C,
    982                                bool IsCXXTry,
    983                                SourceLocation TryLoc,
    984                                Stmt *TryBlock,
    985                                Stmt *Handler) {
    986   return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler);
    987 }
    988 
    989 SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
    990   return dyn_cast<SEHExceptStmt>(getHandler());
    991 }
    992 
    993 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
    994   return dyn_cast<SEHFinallyStmt>(getHandler());
    995 }
    996 
    997 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc,
    998                              Expr *FilterExpr,
    999                              Stmt *Block)
   1000   : Stmt(SEHExceptStmtClass),
   1001     Loc(Loc)
   1002 {
   1003   Children[FILTER_EXPR] = reinterpret_cast<Stmt*>(FilterExpr);
   1004   Children[BLOCK]       = Block;
   1005 }
   1006 
   1007 SEHExceptStmt* SEHExceptStmt::Create(ASTContext &C,
   1008                                      SourceLocation Loc,
   1009                                      Expr *FilterExpr,
   1010                                      Stmt *Block) {
   1011   return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
   1012 }
   1013 
   1014 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc,
   1015                                Stmt *Block)
   1016   : Stmt(SEHFinallyStmtClass),
   1017     Loc(Loc),
   1018     Block(Block)
   1019 {}
   1020 
   1021 SEHFinallyStmt* SEHFinallyStmt::Create(ASTContext &C,
   1022                                        SourceLocation Loc,
   1023                                        Stmt *Block) {
   1024   return new(C)SEHFinallyStmt(Loc,Block);
   1025 }
   1026