contrib/llvm/tools/clang/lib/AST/Stmt.cpp

   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 }