SemaStmtAsm.cpp revision 358ab765f36f70d0744ede7dc35ce74c0911e77d
1//===--- SemaStmtAsm.cpp - Semantic Analysis for Asm Statements -----------===// 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 semantic analysis for inline asm statements. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Sema/SemaInternal.h" 15#include "clang/Sema/Scope.h" 16#include "clang/Sema/ScopeInfo.h" 17#include "clang/Sema/Initialization.h" 18#include "clang/Sema/Lookup.h" 19#include "clang/AST/TypeLoc.h" 20#include "clang/Lex/Preprocessor.h" 21#include "clang/Basic/TargetInfo.h" 22#include "llvm/ADT/ArrayRef.h" 23#include "llvm/ADT/BitVector.h" 24#include "llvm/ADT/SmallString.h" 25#include "llvm/MC/MCAsmInfo.h" 26#include "llvm/MC/MCContext.h" 27#include "llvm/MC/MCInst.h" 28#include "llvm/MC/MCInstPrinter.h" 29#include "llvm/MC/MCInstrInfo.h" 30#include "llvm/MC/MCObjectFileInfo.h" 31#include "llvm/MC/MCRegisterInfo.h" 32#include "llvm/MC/MCStreamer.h" 33#include "llvm/MC/MCSubtargetInfo.h" 34#include "llvm/MC/MCTargetAsmParser.h" 35#include "llvm/MC/MCParser/MCAsmLexer.h" 36#include "llvm/MC/MCParser/MCAsmParser.h" 37#include "llvm/Support/SourceMgr.h" 38#include "llvm/Support/TargetRegistry.h" 39#include "llvm/Support/TargetSelect.h" 40using namespace clang; 41using namespace sema; 42 43/// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently 44/// ignore "noop" casts in places where an lvalue is required by an inline asm. 45/// We emulate this behavior when -fheinous-gnu-extensions is specified, but 46/// provide a strong guidance to not use it. 47/// 48/// This method checks to see if the argument is an acceptable l-value and 49/// returns false if it is a case we can handle. 50static bool CheckAsmLValue(const Expr *E, Sema &S) { 51 // Type dependent expressions will be checked during instantiation. 52 if (E->isTypeDependent()) 53 return false; 54 55 if (E->isLValue()) 56 return false; // Cool, this is an lvalue. 57 58 // Okay, this is not an lvalue, but perhaps it is the result of a cast that we 59 // are supposed to allow. 60 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context); 61 if (E != E2 && E2->isLValue()) { 62 if (!S.getLangOpts().HeinousExtensions) 63 S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue) 64 << E->getSourceRange(); 65 else 66 S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue) 67 << E->getSourceRange(); 68 // Accept, even if we emitted an error diagnostic. 69 return false; 70 } 71 72 // None of the above, just randomly invalid non-lvalue. 73 return true; 74} 75 76/// isOperandMentioned - Return true if the specified operand # is mentioned 77/// anywhere in the decomposed asm string. 78static bool isOperandMentioned(unsigned OpNo, 79 ArrayRef<AsmStmt::AsmStringPiece> AsmStrPieces) { 80 for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) { 81 const AsmStmt::AsmStringPiece &Piece = AsmStrPieces[p]; 82 if (!Piece.isOperand()) continue; 83 84 // If this is a reference to the input and if the input was the smaller 85 // one, then we have to reject this asm. 86 if (Piece.getOperandNo() == OpNo) 87 return true; 88 } 89 return false; 90} 91 92StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, bool IsSimple, 93 bool IsVolatile, unsigned NumOutputs, 94 unsigned NumInputs, IdentifierInfo **Names, 95 MultiExprArg constraints, MultiExprArg exprs, 96 Expr *asmString, MultiExprArg clobbers, 97 SourceLocation RParenLoc) { 98 unsigned NumClobbers = clobbers.size(); 99 StringLiteral **Constraints = 100 reinterpret_cast<StringLiteral**>(constraints.get()); 101 Expr **Exprs = exprs.get(); 102 StringLiteral *AsmString = cast<StringLiteral>(asmString); 103 StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get()); 104 105 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos; 106 107 // The parser verifies that there is a string literal here. 108 if (!AsmString->isAscii()) 109 return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character) 110 << AsmString->getSourceRange()); 111 112 for (unsigned i = 0; i != NumOutputs; i++) { 113 StringLiteral *Literal = Constraints[i]; 114 if (!Literal->isAscii()) 115 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character) 116 << Literal->getSourceRange()); 117 118 StringRef OutputName; 119 if (Names[i]) 120 OutputName = Names[i]->getName(); 121 122 TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName); 123 if (!Context.getTargetInfo().validateOutputConstraint(Info)) 124 return StmtError(Diag(Literal->getLocStart(), 125 diag::err_asm_invalid_output_constraint) 126 << Info.getConstraintStr()); 127 128 // Check that the output exprs are valid lvalues. 129 Expr *OutputExpr = Exprs[i]; 130 if (CheckAsmLValue(OutputExpr, *this)) { 131 return StmtError(Diag(OutputExpr->getLocStart(), 132 diag::err_asm_invalid_lvalue_in_output) 133 << OutputExpr->getSourceRange()); 134 } 135 136 OutputConstraintInfos.push_back(Info); 137 } 138 139 SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos; 140 141 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) { 142 StringLiteral *Literal = Constraints[i]; 143 if (!Literal->isAscii()) 144 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character) 145 << Literal->getSourceRange()); 146 147 StringRef InputName; 148 if (Names[i]) 149 InputName = Names[i]->getName(); 150 151 TargetInfo::ConstraintInfo Info(Literal->getString(), InputName); 152 if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos.data(), 153 NumOutputs, Info)) { 154 return StmtError(Diag(Literal->getLocStart(), 155 diag::err_asm_invalid_input_constraint) 156 << Info.getConstraintStr()); 157 } 158 159 Expr *InputExpr = Exprs[i]; 160 161 // Only allow void types for memory constraints. 162 if (Info.allowsMemory() && !Info.allowsRegister()) { 163 if (CheckAsmLValue(InputExpr, *this)) 164 return StmtError(Diag(InputExpr->getLocStart(), 165 diag::err_asm_invalid_lvalue_in_input) 166 << Info.getConstraintStr() 167 << InputExpr->getSourceRange()); 168 } 169 170 if (Info.allowsRegister()) { 171 if (InputExpr->getType()->isVoidType()) { 172 return StmtError(Diag(InputExpr->getLocStart(), 173 diag::err_asm_invalid_type_in_input) 174 << InputExpr->getType() << Info.getConstraintStr() 175 << InputExpr->getSourceRange()); 176 } 177 } 178 179 ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]); 180 if (Result.isInvalid()) 181 return StmtError(); 182 183 Exprs[i] = Result.take(); 184 InputConstraintInfos.push_back(Info); 185 } 186 187 // Check that the clobbers are valid. 188 for (unsigned i = 0; i != NumClobbers; i++) { 189 StringLiteral *Literal = Clobbers[i]; 190 if (!Literal->isAscii()) 191 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character) 192 << Literal->getSourceRange()); 193 194 StringRef Clobber = Literal->getString(); 195 196 if (!Context.getTargetInfo().isValidClobber(Clobber)) 197 return StmtError(Diag(Literal->getLocStart(), 198 diag::err_asm_unknown_register_name) << Clobber); 199 } 200 201 AsmStmt *NS = 202 new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs, 203 NumInputs, Names, Constraints, Exprs, AsmString, 204 NumClobbers, Clobbers, RParenLoc); 205 // Validate the asm string, ensuring it makes sense given the operands we 206 // have. 207 SmallVector<AsmStmt::AsmStringPiece, 8> Pieces; 208 unsigned DiagOffs; 209 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) { 210 Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID) 211 << AsmString->getSourceRange(); 212 return StmtError(); 213 } 214 215 // Validate tied input operands for type mismatches. 216 for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) { 217 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i]; 218 219 // If this is a tied constraint, verify that the output and input have 220 // either exactly the same type, or that they are int/ptr operands with the 221 // same size (int/long, int*/long, are ok etc). 222 if (!Info.hasTiedOperand()) continue; 223 224 unsigned TiedTo = Info.getTiedOperand(); 225 unsigned InputOpNo = i+NumOutputs; 226 Expr *OutputExpr = Exprs[TiedTo]; 227 Expr *InputExpr = Exprs[InputOpNo]; 228 229 if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent()) 230 continue; 231 232 QualType InTy = InputExpr->getType(); 233 QualType OutTy = OutputExpr->getType(); 234 if (Context.hasSameType(InTy, OutTy)) 235 continue; // All types can be tied to themselves. 236 237 // Decide if the input and output are in the same domain (integer/ptr or 238 // floating point. 239 enum AsmDomain { 240 AD_Int, AD_FP, AD_Other 241 } InputDomain, OutputDomain; 242 243 if (InTy->isIntegerType() || InTy->isPointerType()) 244 InputDomain = AD_Int; 245 else if (InTy->isRealFloatingType()) 246 InputDomain = AD_FP; 247 else 248 InputDomain = AD_Other; 249 250 if (OutTy->isIntegerType() || OutTy->isPointerType()) 251 OutputDomain = AD_Int; 252 else if (OutTy->isRealFloatingType()) 253 OutputDomain = AD_FP; 254 else 255 OutputDomain = AD_Other; 256 257 // They are ok if they are the same size and in the same domain. This 258 // allows tying things like: 259 // void* to int* 260 // void* to int if they are the same size. 261 // double to long double if they are the same size. 262 // 263 uint64_t OutSize = Context.getTypeSize(OutTy); 264 uint64_t InSize = Context.getTypeSize(InTy); 265 if (OutSize == InSize && InputDomain == OutputDomain && 266 InputDomain != AD_Other) 267 continue; 268 269 // If the smaller input/output operand is not mentioned in the asm string, 270 // then we can promote the smaller one to a larger input and the asm string 271 // won't notice. 272 bool SmallerValueMentioned = false; 273 274 // If this is a reference to the input and if the input was the smaller 275 // one, then we have to reject this asm. 276 if (isOperandMentioned(InputOpNo, Pieces)) { 277 // This is a use in the asm string of the smaller operand. Since we 278 // codegen this by promoting to a wider value, the asm will get printed 279 // "wrong". 280 SmallerValueMentioned |= InSize < OutSize; 281 } 282 if (isOperandMentioned(TiedTo, Pieces)) { 283 // If this is a reference to the output, and if the output is the larger 284 // value, then it's ok because we'll promote the input to the larger type. 285 SmallerValueMentioned |= OutSize < InSize; 286 } 287 288 // If the smaller value wasn't mentioned in the asm string, and if the 289 // output was a register, just extend the shorter one to the size of the 290 // larger one. 291 if (!SmallerValueMentioned && InputDomain != AD_Other && 292 OutputConstraintInfos[TiedTo].allowsRegister()) 293 continue; 294 295 // Either both of the operands were mentioned or the smaller one was 296 // mentioned. One more special case that we'll allow: if the tied input is 297 // integer, unmentioned, and is a constant, then we'll allow truncating it 298 // down to the size of the destination. 299 if (InputDomain == AD_Int && OutputDomain == AD_Int && 300 !isOperandMentioned(InputOpNo, Pieces) && 301 InputExpr->isEvaluatable(Context)) { 302 CastKind castKind = 303 (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast); 304 InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take(); 305 Exprs[InputOpNo] = InputExpr; 306 NS->setInputExpr(i, InputExpr); 307 continue; 308 } 309 310 Diag(InputExpr->getLocStart(), 311 diag::err_asm_tying_incompatible_types) 312 << InTy << OutTy << OutputExpr->getSourceRange() 313 << InputExpr->getSourceRange(); 314 return StmtError(); 315 } 316 317 return Owned(NS); 318} 319 320// isMSAsmKeyword - Return true if this is an MS-style inline asm keyword. These 321// require special handling. 322static bool isMSAsmKeyword(StringRef Name) { 323 bool Ret = llvm::StringSwitch<bool>(Name) 324 .Cases("EVEN", "ALIGN", true) // Alignment directives. 325 .Cases("LENGTH", "SIZE", "TYPE", true) // Type and variable sizes. 326 .Case("_emit", true) // _emit Pseudoinstruction. 327 .Default(false); 328 return Ret; 329} 330 331// getSpelling - Get the spelling of the AsmTok token. 332static StringRef getSpelling(Sema &SemaRef, Token AsmTok) { 333 StringRef Asm; 334 SmallString<512> TokenBuf; 335 TokenBuf.resize(512); 336 bool StringInvalid = false; 337 Asm = SemaRef.PP.getSpelling(AsmTok, TokenBuf, &StringInvalid); 338 assert (!StringInvalid && "Expected valid string!"); 339 return Asm; 340} 341 342// Determine if we should bail on this MSAsm instruction. 343static bool bailOnMSAsm(std::vector<StringRef> Piece) { 344 for (unsigned i = 0, e = Piece.size(); i != e; ++i) 345 if (isMSAsmKeyword(Piece[i])) 346 return true; 347 return false; 348} 349 350// Determine if we should bail on this MSAsm block. 351static bool bailOnMSAsm(std::vector<std::vector<StringRef> > Pieces) { 352 for (unsigned i = 0, e = Pieces.size(); i != e; ++i) 353 if (bailOnMSAsm(Pieces[i])) 354 return true; 355 return false; 356} 357 358// Determine if this is a simple MSAsm instruction. 359static bool isSimpleMSAsm(std::vector<StringRef> &Pieces, 360 const TargetInfo &TI) { 361 if (isMSAsmKeyword(Pieces[0])) 362 return false; 363 364 for (unsigned i = 1, e = Pieces.size(); i != e; ++i) 365 if (!TI.isValidGCCRegisterName(Pieces[i])) 366 return false; 367 return true; 368} 369 370// Determine if this is a simple MSAsm block. 371static bool isSimpleMSAsm(std::vector<std::vector<StringRef> > Pieces, 372 const TargetInfo &TI) { 373 for (unsigned i = 0, e = Pieces.size(); i != e; ++i) 374 if (!isSimpleMSAsm(Pieces[i], TI)) 375 return false; 376 return true; 377} 378 379// Break the AsmSting into pieces (i.e., mnemonic and operands). 380static void buildMSAsmPieces(StringRef Asm, std::vector<StringRef> &Pieces) { 381 std::pair<StringRef,StringRef> Split = Asm.split(' '); 382 383 // Mnemonic 384 Pieces.push_back(Split.first); 385 Asm = Split.second; 386 387 // Operands 388 while (!Asm.empty()) { 389 Split = Asm.split(", "); 390 Pieces.push_back(Split.first); 391 Asm = Split.second; 392 } 393} 394 395static void buildMSAsmPieces(std::vector<std::string> &AsmStrings, 396 std::vector<std::vector<StringRef> > &Pieces) { 397 for (unsigned i = 0, e = AsmStrings.size(); i != e; ++i) 398 buildMSAsmPieces(AsmStrings[i], Pieces[i]); 399} 400 401// Build the unmodified MSAsmString. 402static std::string buildMSAsmString(Sema &SemaRef, ArrayRef<Token> AsmToks, 403 std::vector<std::string> &AsmStrings, 404 std::vector<std::pair<unsigned,unsigned> > &AsmTokRanges) { 405 assert (!AsmToks.empty() && "Didn't expect an empty AsmToks!"); 406 407 SmallString<512> Res; 408 SmallString<512> Asm; 409 unsigned startTok = 0; 410 for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) { 411 bool isNewAsm = i == 0 || AsmToks[i].isAtStartOfLine() || 412 AsmToks[i].is(tok::kw_asm); 413 414 if (isNewAsm) { 415 if (i) { 416 AsmStrings.push_back(Asm.c_str()); 417 AsmTokRanges.push_back(std::make_pair(startTok, i-1)); 418 startTok = i; 419 Res += Asm; 420 Asm.clear(); 421 Res += '\n'; 422 } 423 if (AsmToks[i].is(tok::kw_asm)) { 424 i++; // Skip __asm 425 assert (i != e && "Expected another token"); 426 } 427 } 428 429 if (i && AsmToks[i].hasLeadingSpace() && !isNewAsm) 430 Asm += ' '; 431 432 Asm += getSpelling(SemaRef, AsmToks[i]); 433 } 434 AsmStrings.push_back(Asm.c_str()); 435 AsmTokRanges.push_back(std::make_pair(startTok, AsmToks.size()-1)); 436 Res += Asm; 437 return Res.c_str(); 438} 439 440#define DEF_SIMPLE_MSASM \ 441 MSAsmStmt *NS = \ 442 new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, /*IsSimple*/ true, \ 443 /*IsVolatile*/ true, AsmToks, Inputs, Outputs, \ 444 AsmString, Clobbers, EndLoc); 445 446StmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc, 447 SourceLocation LBraceLoc, 448 ArrayRef<Token> AsmToks, 449 SourceLocation EndLoc) { 450 // MS-style inline assembly is not fully supported, so emit a warning. 451 Diag(AsmLoc, diag::warn_unsupported_msasm); 452 SmallVector<StringRef,4> Clobbers; 453 std::set<std::string> ClobberRegs; 454 SmallVector<IdentifierInfo*, 4> Inputs; 455 SmallVector<IdentifierInfo*, 4> Outputs; 456 457 // Empty asm statements don't need to instantiate the AsmParser, etc. 458 if (AsmToks.empty()) { 459 StringRef AsmString; 460 DEF_SIMPLE_MSASM; 461 return Owned(NS); 462 } 463 464 std::vector<std::string> AsmStrings; 465 std::vector<std::pair<unsigned,unsigned> > AsmTokRanges; 466 std::string AsmString = buildMSAsmString(*this, AsmToks, AsmStrings, AsmTokRanges); 467 468 std::vector<std::vector<StringRef> > Pieces(AsmStrings.size()); 469 buildMSAsmPieces(AsmStrings, Pieces); 470 471 bool IsSimple = isSimpleMSAsm(Pieces, Context.getTargetInfo()); 472 473 // AsmParser doesn't fully support these asm statements. 474 if (bailOnMSAsm(Pieces)) { DEF_SIMPLE_MSASM; return Owned(NS); } 475 476 // Initialize targets and assembly printers/parsers. 477 llvm::InitializeAllTargetInfos(); 478 llvm::InitializeAllTargetMCs(); 479 llvm::InitializeAllAsmParsers(); 480 481 // Get the target specific parser. 482 std::string Error; 483 const std::string &TT = Context.getTargetInfo().getTriple().getTriple(); 484 const llvm::Target *TheTarget(llvm::TargetRegistry::lookupTarget(TT, Error)); 485 486 OwningPtr<llvm::MCAsmInfo> MAI(TheTarget->createMCAsmInfo(TT)); 487 OwningPtr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT)); 488 OwningPtr<llvm::MCObjectFileInfo> MOFI(new llvm::MCObjectFileInfo()); 489 OwningPtr<llvm::MCSubtargetInfo> 490 STI(TheTarget->createMCSubtargetInfo(TT, "", "")); 491 492 for (unsigned i = 0, e = AsmStrings.size(); i != e; ++i) { 493 llvm::SourceMgr SrcMgr; 494 llvm::MCContext Ctx(*MAI, *MRI, MOFI.get(), &SrcMgr); 495 llvm::MemoryBuffer *Buffer = 496 llvm::MemoryBuffer::getMemBuffer(AsmStrings[i], "<inline asm>"); 497 498 // Tell SrcMgr about this buffer, which is what the parser will pick up. 499 SrcMgr.AddNewSourceBuffer(Buffer, llvm::SMLoc()); 500 501 OwningPtr<llvm::MCStreamer> Str(createNullStreamer(Ctx)); 502 OwningPtr<llvm::MCAsmParser> 503 Parser(createMCAsmParser(SrcMgr, Ctx, *Str.get(), *MAI)); 504 OwningPtr<llvm::MCTargetAsmParser> 505 TargetParser(TheTarget->createMCAsmParser(*STI, *Parser)); 506 // Change to the Intel dialect. 507 Parser->setAssemblerDialect(1); 508 Parser->setTargetParser(*TargetParser.get()); 509 510 // Prime the lexer. 511 Parser->Lex(); 512 513 // Parse the opcode. 514 StringRef IDVal; 515 Parser->ParseIdentifier(IDVal); 516 517 // Canonicalize the opcode to lower case. 518 SmallString<128> Opcode; 519 for (unsigned i = 0, e = IDVal.size(); i != e; ++i) 520 Opcode.push_back(tolower(IDVal[i])); 521 522 // Parse the operands. 523 llvm::SMLoc IDLoc; 524 SmallVector<llvm::MCParsedAsmOperand*, 8> Operands; 525 bool HadError = TargetParser->ParseInstruction(Opcode.str(), IDLoc, 526 Operands); 527 // If we had an error parsing the operands, fail gracefully. 528 if (HadError) { DEF_SIMPLE_MSASM; return Owned(NS); } 529 530 // Match the MCInstr. 531 unsigned ErrorInfo; 532 SmallVector<llvm::MCInst, 2> Instrs; 533 HadError = TargetParser->MatchInstruction(IDLoc, Operands, Instrs, 534 ErrorInfo, 535 /*matchingInlineAsm*/ true); 536 // If we had an error parsing the operands, fail gracefully. 537 if (HadError) { DEF_SIMPLE_MSASM; return Owned(NS); } 538 539 // Get the instruction descriptor. 540 llvm::MCInst Inst = Instrs[0]; 541 const llvm::MCInstrInfo *MII = TheTarget->createMCInstrInfo(); 542 const llvm::MCInstrDesc &Desc = MII->get(Inst.getOpcode()); 543 llvm::MCInstPrinter *IP = 544 TheTarget->createMCInstPrinter(1, *MAI, *MII, *MRI, *STI); 545 546 // Build the list of clobbers. 547 for (unsigned i = 0, e = Desc.getNumDefs(); i != e; ++i) { 548 const llvm::MCOperand &Op = Inst.getOperand(i); 549 if (!Op.isReg()) 550 continue; 551 552 std::string Reg; 553 llvm::raw_string_ostream OS(Reg); 554 IP->printRegName(OS, Op.getReg()); 555 556 StringRef Clobber(OS.str()); 557 if (!Context.getTargetInfo().isValidClobber(Clobber)) 558 return StmtError(Diag(AsmLoc, diag::err_asm_unknown_register_name) << 559 Clobber); 560 ClobberRegs.insert(Reg); 561 } 562 } 563 for (std::set<std::string>::iterator I = ClobberRegs.begin(), 564 E = ClobberRegs.end(); I != E; ++I) 565 Clobbers.push_back(*I); 566 567 MSAsmStmt *NS = 568 new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, IsSimple, 569 /*IsVolatile*/ true, AsmToks, Inputs, Outputs, 570 AsmString, Clobbers, EndLoc); 571 return Owned(NS); 572} 573