SemaStmtAsm.cpp revision 1e7ca6211c77208c8a339c2a26e612be81c70ec5
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/AST/RecordLayout.h" 16#include "clang/AST/TypeLoc.h" 17#include "clang/Basic/TargetInfo.h" 18#include "clang/Lex/Preprocessor.h" 19#include "clang/Sema/Initialization.h" 20#include "clang/Sema/Lookup.h" 21#include "clang/Sema/Scope.h" 22#include "clang/Sema/ScopeInfo.h" 23#include "llvm/ADT/ArrayRef.h" 24#include "llvm/ADT/BitVector.h" 25#include "llvm/ADT/SmallString.h" 26#include "llvm/MC/MCAsmInfo.h" 27#include "llvm/MC/MCContext.h" 28#include "llvm/MC/MCObjectFileInfo.h" 29#include "llvm/MC/MCParser/MCAsmParser.h" 30#include "llvm/MC/MCRegisterInfo.h" 31#include "llvm/MC/MCStreamer.h" 32#include "llvm/MC/MCSubtargetInfo.h" 33#include "llvm/MC/MCTargetAsmParser.h" 34#include "llvm/Support/SourceMgr.h" 35#include "llvm/Support/TargetRegistry.h" 36#include "llvm/Support/TargetSelect.h" 37using namespace clang; 38using namespace sema; 39 40/// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently 41/// ignore "noop" casts in places where an lvalue is required by an inline asm. 42/// We emulate this behavior when -fheinous-gnu-extensions is specified, but 43/// provide a strong guidance to not use it. 44/// 45/// This method checks to see if the argument is an acceptable l-value and 46/// returns false if it is a case we can handle. 47static bool CheckAsmLValue(const Expr *E, Sema &S) { 48 // Type dependent expressions will be checked during instantiation. 49 if (E->isTypeDependent()) 50 return false; 51 52 if (E->isLValue()) 53 return false; // Cool, this is an lvalue. 54 55 // Okay, this is not an lvalue, but perhaps it is the result of a cast that we 56 // are supposed to allow. 57 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context); 58 if (E != E2 && E2->isLValue()) { 59 if (!S.getLangOpts().HeinousExtensions) 60 S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue) 61 << E->getSourceRange(); 62 else 63 S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue) 64 << E->getSourceRange(); 65 // Accept, even if we emitted an error diagnostic. 66 return false; 67 } 68 69 // None of the above, just randomly invalid non-lvalue. 70 return true; 71} 72 73/// isOperandMentioned - Return true if the specified operand # is mentioned 74/// anywhere in the decomposed asm string. 75static bool isOperandMentioned(unsigned OpNo, 76 ArrayRef<GCCAsmStmt::AsmStringPiece> AsmStrPieces) { 77 for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) { 78 const GCCAsmStmt::AsmStringPiece &Piece = AsmStrPieces[p]; 79 if (!Piece.isOperand()) continue; 80 81 // If this is a reference to the input and if the input was the smaller 82 // one, then we have to reject this asm. 83 if (Piece.getOperandNo() == OpNo) 84 return true; 85 } 86 return false; 87} 88 89StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, 90 bool IsVolatile, unsigned NumOutputs, 91 unsigned NumInputs, IdentifierInfo **Names, 92 MultiExprArg constraints, MultiExprArg exprs, 93 Expr *asmString, MultiExprArg clobbers, 94 SourceLocation RParenLoc) { 95 unsigned NumClobbers = clobbers.size(); 96 StringLiteral **Constraints = 97 reinterpret_cast<StringLiteral**>(constraints.data()); 98 Expr **Exprs = exprs.data(); 99 StringLiteral *AsmString = cast<StringLiteral>(asmString); 100 StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.data()); 101 102 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos; 103 104 // The parser verifies that there is a string literal here. 105 if (!AsmString->isAscii()) 106 return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character) 107 << AsmString->getSourceRange()); 108 109 for (unsigned i = 0; i != NumOutputs; i++) { 110 StringLiteral *Literal = Constraints[i]; 111 if (!Literal->isAscii()) 112 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character) 113 << Literal->getSourceRange()); 114 115 StringRef OutputName; 116 if (Names[i]) 117 OutputName = Names[i]->getName(); 118 119 TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName); 120 if (!Context.getTargetInfo().validateOutputConstraint(Info)) 121 return StmtError(Diag(Literal->getLocStart(), 122 diag::err_asm_invalid_output_constraint) 123 << Info.getConstraintStr()); 124 125 // Check that the output exprs are valid lvalues. 126 Expr *OutputExpr = Exprs[i]; 127 if (CheckAsmLValue(OutputExpr, *this)) 128 return StmtError(Diag(OutputExpr->getLocStart(), 129 diag::err_asm_invalid_lvalue_in_output) 130 << OutputExpr->getSourceRange()); 131 132 if (RequireCompleteType(OutputExpr->getLocStart(), Exprs[i]->getType(), 133 diag::err_dereference_incomplete_type)) 134 return StmtError(); 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 const Type *Ty = Exprs[i]->getType().getTypePtr(); 187 if (Ty->isDependentType()) 188 continue; 189 190 if (!Ty->isVoidType() || !Info.allowsMemory()) 191 if (RequireCompleteType(InputExpr->getLocStart(), Exprs[i]->getType(), 192 diag::err_dereference_incomplete_type)) 193 return StmtError(); 194 195 unsigned Size = Context.getTypeSize(Ty); 196 if (!Context.getTargetInfo().validateInputSize(Literal->getString(), 197 Size)) 198 return StmtError(Diag(InputExpr->getLocStart(), 199 diag::err_asm_invalid_input_size) 200 << Info.getConstraintStr()); 201 } 202 203 // Check that the clobbers are valid. 204 for (unsigned i = 0; i != NumClobbers; i++) { 205 StringLiteral *Literal = Clobbers[i]; 206 if (!Literal->isAscii()) 207 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character) 208 << Literal->getSourceRange()); 209 210 StringRef Clobber = Literal->getString(); 211 212 if (!Context.getTargetInfo().isValidClobber(Clobber)) 213 return StmtError(Diag(Literal->getLocStart(), 214 diag::err_asm_unknown_register_name) << Clobber); 215 } 216 217 GCCAsmStmt *NS = 218 new (Context) GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs, 219 NumInputs, Names, Constraints, Exprs, AsmString, 220 NumClobbers, Clobbers, RParenLoc); 221 // Validate the asm string, ensuring it makes sense given the operands we 222 // have. 223 SmallVector<GCCAsmStmt::AsmStringPiece, 8> Pieces; 224 unsigned DiagOffs; 225 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) { 226 Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID) 227 << AsmString->getSourceRange(); 228 return StmtError(); 229 } 230 231 // Validate constraints and modifiers. 232 for (unsigned i = 0, e = Pieces.size(); i != e; ++i) { 233 GCCAsmStmt::AsmStringPiece &Piece = Pieces[i]; 234 if (!Piece.isOperand()) continue; 235 236 // Look for the correct constraint index. 237 unsigned Idx = 0; 238 unsigned ConstraintIdx = 0; 239 for (unsigned i = 0, e = NS->getNumOutputs(); i != e; ++i, ++ConstraintIdx) { 240 TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i]; 241 if (Idx == Piece.getOperandNo()) 242 break; 243 ++Idx; 244 245 if (Info.isReadWrite()) { 246 if (Idx == Piece.getOperandNo()) 247 break; 248 ++Idx; 249 } 250 } 251 252 for (unsigned i = 0, e = NS->getNumInputs(); i != e; ++i, ++ConstraintIdx) { 253 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i]; 254 if (Idx == Piece.getOperandNo()) 255 break; 256 ++Idx; 257 258 if (Info.isReadWrite()) { 259 if (Idx == Piece.getOperandNo()) 260 break; 261 ++Idx; 262 } 263 } 264 265 // Now that we have the right indexes go ahead and check. 266 StringLiteral *Literal = Constraints[ConstraintIdx]; 267 const Type *Ty = Exprs[ConstraintIdx]->getType().getTypePtr(); 268 if (Ty->isDependentType() || Ty->isIncompleteType()) 269 continue; 270 271 unsigned Size = Context.getTypeSize(Ty); 272 if (!Context.getTargetInfo() 273 .validateConstraintModifier(Literal->getString(), Piece.getModifier(), 274 Size)) 275 Diag(Exprs[ConstraintIdx]->getLocStart(), 276 diag::warn_asm_mismatched_size_modifier); 277 } 278 279 // Validate tied input operands for type mismatches. 280 for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) { 281 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i]; 282 283 // If this is a tied constraint, verify that the output and input have 284 // either exactly the same type, or that they are int/ptr operands with the 285 // same size (int/long, int*/long, are ok etc). 286 if (!Info.hasTiedOperand()) continue; 287 288 unsigned TiedTo = Info.getTiedOperand(); 289 unsigned InputOpNo = i+NumOutputs; 290 Expr *OutputExpr = Exprs[TiedTo]; 291 Expr *InputExpr = Exprs[InputOpNo]; 292 293 if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent()) 294 continue; 295 296 QualType InTy = InputExpr->getType(); 297 QualType OutTy = OutputExpr->getType(); 298 if (Context.hasSameType(InTy, OutTy)) 299 continue; // All types can be tied to themselves. 300 301 // Decide if the input and output are in the same domain (integer/ptr or 302 // floating point. 303 enum AsmDomain { 304 AD_Int, AD_FP, AD_Other 305 } InputDomain, OutputDomain; 306 307 if (InTy->isIntegerType() || InTy->isPointerType()) 308 InputDomain = AD_Int; 309 else if (InTy->isRealFloatingType()) 310 InputDomain = AD_FP; 311 else 312 InputDomain = AD_Other; 313 314 if (OutTy->isIntegerType() || OutTy->isPointerType()) 315 OutputDomain = AD_Int; 316 else if (OutTy->isRealFloatingType()) 317 OutputDomain = AD_FP; 318 else 319 OutputDomain = AD_Other; 320 321 // They are ok if they are the same size and in the same domain. This 322 // allows tying things like: 323 // void* to int* 324 // void* to int if they are the same size. 325 // double to long double if they are the same size. 326 // 327 uint64_t OutSize = Context.getTypeSize(OutTy); 328 uint64_t InSize = Context.getTypeSize(InTy); 329 if (OutSize == InSize && InputDomain == OutputDomain && 330 InputDomain != AD_Other) 331 continue; 332 333 // If the smaller input/output operand is not mentioned in the asm string, 334 // then we can promote the smaller one to a larger input and the asm string 335 // won't notice. 336 bool SmallerValueMentioned = false; 337 338 // If this is a reference to the input and if the input was the smaller 339 // one, then we have to reject this asm. 340 if (isOperandMentioned(InputOpNo, Pieces)) { 341 // This is a use in the asm string of the smaller operand. Since we 342 // codegen this by promoting to a wider value, the asm will get printed 343 // "wrong". 344 SmallerValueMentioned |= InSize < OutSize; 345 } 346 if (isOperandMentioned(TiedTo, Pieces)) { 347 // If this is a reference to the output, and if the output is the larger 348 // value, then it's ok because we'll promote the input to the larger type. 349 SmallerValueMentioned |= OutSize < InSize; 350 } 351 352 // If the smaller value wasn't mentioned in the asm string, and if the 353 // output was a register, just extend the shorter one to the size of the 354 // larger one. 355 if (!SmallerValueMentioned && InputDomain != AD_Other && 356 OutputConstraintInfos[TiedTo].allowsRegister()) 357 continue; 358 359 // Either both of the operands were mentioned or the smaller one was 360 // mentioned. One more special case that we'll allow: if the tied input is 361 // integer, unmentioned, and is a constant, then we'll allow truncating it 362 // down to the size of the destination. 363 if (InputDomain == AD_Int && OutputDomain == AD_Int && 364 !isOperandMentioned(InputOpNo, Pieces) && 365 InputExpr->isEvaluatable(Context)) { 366 CastKind castKind = 367 (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast); 368 InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take(); 369 Exprs[InputOpNo] = InputExpr; 370 NS->setInputExpr(i, InputExpr); 371 continue; 372 } 373 374 Diag(InputExpr->getLocStart(), 375 diag::err_asm_tying_incompatible_types) 376 << InTy << OutTy << OutputExpr->getSourceRange() 377 << InputExpr->getSourceRange(); 378 return StmtError(); 379 } 380 381 return Owned(NS); 382} 383 384// getSpelling - Get the spelling of the AsmTok token. 385static StringRef getSpelling(Sema &SemaRef, Token AsmTok) { 386 StringRef Asm; 387 SmallString<512> TokenBuf; 388 TokenBuf.resize(512); 389 bool StringInvalid = false; 390 Asm = SemaRef.PP.getSpelling(AsmTok, TokenBuf, &StringInvalid); 391 assert (!StringInvalid && "Expected valid string!"); 392 return Asm; 393} 394 395// Build the inline assembly string. Returns true on error. 396static bool buildMSAsmString(Sema &SemaRef, 397 SourceLocation AsmLoc, 398 ArrayRef<Token> AsmToks, 399 SmallVectorImpl<unsigned> &TokOffsets, 400 std::string &AsmString) { 401 assert (!AsmToks.empty() && "Didn't expect an empty AsmToks!"); 402 403 SmallString<512> Asm; 404 for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) { 405 bool isNewAsm = ((i == 0) || 406 AsmToks[i].isAtStartOfLine() || 407 AsmToks[i].is(tok::kw_asm)); 408 if (isNewAsm) { 409 if (i != 0) 410 Asm += "\n\t"; 411 412 if (AsmToks[i].is(tok::kw_asm)) { 413 i++; // Skip __asm 414 if (i == e) { 415 SemaRef.Diag(AsmLoc, diag::err_asm_empty); 416 return true; 417 } 418 419 } 420 } 421 422 if (i && AsmToks[i].hasLeadingSpace() && !isNewAsm) 423 Asm += ' '; 424 425 StringRef Spelling = getSpelling(SemaRef, AsmToks[i]); 426 Asm += Spelling; 427 TokOffsets.push_back(Asm.size()); 428 } 429 AsmString = Asm.str(); 430 return false; 431} 432 433namespace { 434 435class MCAsmParserSemaCallbackImpl : public llvm::MCAsmParserSemaCallback { 436 Sema &SemaRef; 437 SourceLocation AsmLoc; 438 ArrayRef<Token> AsmToks; 439 ArrayRef<unsigned> TokOffsets; 440 441public: 442 MCAsmParserSemaCallbackImpl(Sema &Ref, SourceLocation Loc, 443 ArrayRef<Token> Toks, 444 ArrayRef<unsigned> Offsets) 445 : SemaRef(Ref), AsmLoc(Loc), AsmToks(Toks), TokOffsets(Offsets) { } 446 ~MCAsmParserSemaCallbackImpl() {} 447 448 void *LookupInlineAsmIdentifier(StringRef &LineBuf, 449 InlineAsmIdentifierInfo &Info) { 450 SourceLocation Loc = SourceLocation::getFromPtrEncoding(LineBuf.data()); 451 NamedDecl *OpDecl = SemaRef.LookupInlineAsmIdentifier(LineBuf, Loc, Info); 452 return static_cast<void *>(OpDecl); 453 } 454 455 bool LookupInlineAsmField(StringRef Base, StringRef Member, 456 unsigned &Offset) { 457 return SemaRef.LookupInlineAsmField(Base, Member, Offset, AsmLoc); 458 } 459 460 static void MSAsmDiagHandlerCallback(const llvm::SMDiagnostic &D, 461 void *Context) { 462 ((MCAsmParserSemaCallbackImpl*)Context)->MSAsmDiagHandler(D); 463 } 464 void MSAsmDiagHandler(const llvm::SMDiagnostic &D) { 465 // Compute an offset into the inline asm buffer. 466 // FIXME: This isn't right if .macro is involved (but hopefully, no 467 // real-world code does that). 468 const llvm::SourceMgr &LSM = *D.getSourceMgr(); 469 const llvm::MemoryBuffer *LBuf = 470 LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc())); 471 unsigned Offset = D.getLoc().getPointer() - LBuf->getBufferStart(); 472 473 // Figure out which token that offset points into. 474 const unsigned *OffsetPtr = 475 std::lower_bound(TokOffsets.begin(), TokOffsets.end(), Offset); 476 unsigned TokIndex = OffsetPtr - TokOffsets.begin(); 477 478 // If we come up with an answer which seems sane, use it; otherwise, 479 // just point at the __asm keyword. 480 // FIXME: Assert the answer is sane once we handle .macro correctly. 481 SourceLocation Loc = AsmLoc; 482 if (TokIndex < AsmToks.size()) { 483 const Token *Tok = &AsmToks[TokIndex]; 484 Loc = Tok->getLocation(); 485 Loc = Loc.getLocWithOffset(Offset - (*OffsetPtr - Tok->getLength())); 486 } 487 SemaRef.Diag(Loc, diag::err_inline_ms_asm_parsing) << D.getMessage(); 488 } 489}; 490 491} 492 493// FIXME: Temporary hack until the frontend parser is hooked up to parse 494// variables. 495static bool isIdentifierChar(char c) { 496 return isalnum(c) || c == '_' || c == '$' || c == '.' || c == '@'; 497} 498 499static void lexIdentifier(const char *&CurPtr) { 500 while (isIdentifierChar(*CurPtr)) 501 ++CurPtr; 502} 503 504static StringRef parseIdentifier(StringRef Identifier) { 505 const char *StartPtr = Identifier.data(), *EndPtr, *CurPtr; 506 EndPtr = StartPtr + Identifier.size(); 507 CurPtr = StartPtr; 508 while(CurPtr <= EndPtr) { 509 if (isIdentifierChar(*CurPtr)) 510 lexIdentifier(CurPtr); 511 else if (CurPtr[0] == ':' && CurPtr[1] == ':') 512 CurPtr += 2; 513 else 514 break; 515 } 516 return StringRef(StartPtr, CurPtr - StartPtr); 517} 518 519NamedDecl *Sema::LookupInlineAsmIdentifier(StringRef &LineBuf, SourceLocation Loc, 520 InlineAsmIdentifierInfo &Info) { 521 Info.clear(); 522 // FIXME: Temporary hack until the frontend parser is hooked up to parse 523 // variables. 524 LineBuf = parseIdentifier(LineBuf); 525 LookupResult Result(*this, &Context.Idents.get(LineBuf), Loc, 526 Sema::LookupOrdinaryName); 527 528 if (!LookupName(Result, getCurScope())) { 529 // If we don't find anything, return null; the AsmParser will assume 530 // it is a label of some sort. 531 return 0; 532 } 533 534 if (!Result.isSingleResult()) { 535 // FIXME: Diagnose result. 536 return 0; 537 } 538 539 NamedDecl *FoundDecl = Result.getFoundDecl(); 540 if (isa<FunctionDecl>(FoundDecl)) 541 return FoundDecl; 542 if (VarDecl *Var = dyn_cast<VarDecl>(FoundDecl)) { 543 QualType Ty = Var->getType(); 544 Info.Type = Info.Size = Context.getTypeSizeInChars(Ty).getQuantity(); 545 if (Ty->isArrayType()) { 546 const ArrayType *ATy = Context.getAsArrayType(Ty); 547 Info.Type = Context.getTypeSizeInChars(ATy->getElementType()).getQuantity(); 548 Info.Length = Info.Size / Info.Type; 549 } 550 Info.IsVarDecl = true; 551 return FoundDecl; 552 } 553 554 // FIXME: Handle other kinds of results? (FieldDecl, etc.) 555 // FIXME: Diagnose if we find something we can't handle, like a typedef. 556 return 0; 557} 558 559bool Sema::LookupInlineAsmField(StringRef Base, StringRef Member, 560 unsigned &Offset, SourceLocation AsmLoc) { 561 Offset = 0; 562 LookupResult BaseResult(*this, &Context.Idents.get(Base), SourceLocation(), 563 LookupOrdinaryName); 564 565 if (!LookupName(BaseResult, getCurScope())) 566 return true; 567 568 if (!BaseResult.isSingleResult()) 569 return true; 570 571 const RecordType *RT = 0; 572 NamedDecl *FoundDecl = BaseResult.getFoundDecl(); 573 if (VarDecl *VD = dyn_cast<VarDecl>(FoundDecl)) 574 RT = VD->getType()->getAs<RecordType>(); 575 else if (TypedefDecl *TD = dyn_cast<TypedefDecl>(FoundDecl)) 576 RT = TD->getUnderlyingType()->getAs<RecordType>(); 577 if (!RT) 578 return true; 579 580 if (RequireCompleteType(AsmLoc, QualType(RT, 0), 0)) 581 return true; 582 583 LookupResult FieldResult(*this, &Context.Idents.get(Member), SourceLocation(), 584 LookupMemberName); 585 586 if (!LookupQualifiedName(FieldResult, RT->getDecl())) 587 return true; 588 589 // FIXME: Handle IndirectFieldDecl? 590 FieldDecl *FD = dyn_cast<FieldDecl>(FieldResult.getFoundDecl()); 591 if (!FD) 592 return true; 593 594 const ASTRecordLayout &RL = Context.getASTRecordLayout(RT->getDecl()); 595 unsigned i = FD->getFieldIndex(); 596 CharUnits Result = Context.toCharUnitsFromBits(RL.getFieldOffset(i)); 597 Offset = (unsigned)Result.getQuantity(); 598 599 return false; 600} 601 602StmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, 603 ArrayRef<Token> AsmToks,SourceLocation EndLoc) { 604 SmallVector<IdentifierInfo*, 4> Names; 605 SmallVector<StringRef, 4> ConstraintRefs; 606 SmallVector<Expr*, 4> Exprs; 607 SmallVector<StringRef, 4> ClobberRefs; 608 609 llvm::Triple TheTriple = Context.getTargetInfo().getTriple(); 610 llvm::Triple::ArchType ArchTy = TheTriple.getArch(); 611 bool UnsupportedArch = ArchTy != llvm::Triple::x86 && 612 ArchTy != llvm::Triple::x86_64; 613 if (UnsupportedArch) 614 Diag(AsmLoc, diag::err_msasm_unsupported_arch) << TheTriple.getArchName(); 615 616 // Empty asm statements don't need to instantiate the AsmParser, etc. 617 if (UnsupportedArch || AsmToks.empty()) { 618 StringRef EmptyAsmStr; 619 MSAsmStmt *NS = 620 new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, /*IsSimple*/ true, 621 /*IsVolatile*/ true, AsmToks, /*NumOutputs*/ 0, 622 /*NumInputs*/ 0, Names, ConstraintRefs, Exprs, 623 EmptyAsmStr, ClobberRefs, EndLoc); 624 return Owned(NS); 625 } 626 627 std::string AsmString; 628 SmallVector<unsigned, 8> TokOffsets; 629 if (buildMSAsmString(*this, AsmLoc, AsmToks, TokOffsets, AsmString)) 630 return StmtError(); 631 632 // Get the target specific parser. 633 std::string Error; 634 const std::string &TT = TheTriple.getTriple(); 635 const llvm::Target *TheTarget(llvm::TargetRegistry::lookupTarget(TT, Error)); 636 637 OwningPtr<llvm::MCAsmInfo> MAI(TheTarget->createMCAsmInfo(TT)); 638 OwningPtr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT)); 639 OwningPtr<llvm::MCObjectFileInfo> MOFI(new llvm::MCObjectFileInfo()); 640 OwningPtr<llvm::MCSubtargetInfo> 641 STI(TheTarget->createMCSubtargetInfo(TT, "", "")); 642 643 llvm::SourceMgr SrcMgr; 644 llvm::MCContext Ctx(*MAI, *MRI, MOFI.get(), &SrcMgr); 645 llvm::MemoryBuffer *Buffer = 646 llvm::MemoryBuffer::getMemBuffer(AsmString, "<MS inline asm>"); 647 648 // Tell SrcMgr about this buffer, which is what the parser will pick up. 649 SrcMgr.AddNewSourceBuffer(Buffer, llvm::SMLoc()); 650 651 OwningPtr<llvm::MCStreamer> Str(createNullStreamer(Ctx)); 652 OwningPtr<llvm::MCAsmParser> 653 Parser(createMCAsmParser(SrcMgr, Ctx, *Str.get(), *MAI)); 654 OwningPtr<llvm::MCTargetAsmParser> 655 TargetParser(TheTarget->createMCAsmParser(*STI, *Parser)); 656 657 // Get the instruction descriptor. 658 const llvm::MCInstrInfo *MII = TheTarget->createMCInstrInfo(); 659 llvm::MCInstPrinter *IP = 660 TheTarget->createMCInstPrinter(1, *MAI, *MII, *MRI, *STI); 661 662 // Change to the Intel dialect. 663 Parser->setAssemblerDialect(1); 664 Parser->setTargetParser(*TargetParser.get()); 665 Parser->setParsingInlineAsm(true); 666 TargetParser->setParsingInlineAsm(true); 667 668 MCAsmParserSemaCallbackImpl MCAPSI(*this, AsmLoc, AsmToks, TokOffsets); 669 TargetParser->setSemaCallback(&MCAPSI); 670 SrcMgr.setDiagHandler(MCAsmParserSemaCallbackImpl::MSAsmDiagHandlerCallback, 671 &MCAPSI); 672 673 unsigned NumOutputs; 674 unsigned NumInputs; 675 std::string AsmStringIR; 676 SmallVector<std::pair<void *, bool>, 4> OpDecls; 677 SmallVector<std::string, 4> Constraints; 678 SmallVector<std::string, 4> Clobbers; 679 if (Parser->parseMSInlineAsm(AsmLoc.getPtrEncoding(), AsmStringIR, 680 NumOutputs, NumInputs, OpDecls, Constraints, 681 Clobbers, MII, IP, MCAPSI)) 682 return StmtError(); 683 684 // Build the vector of clobber StringRefs. 685 unsigned NumClobbers = Clobbers.size(); 686 ClobberRefs.resize(NumClobbers); 687 for (unsigned i = 0; i != NumClobbers; ++i) 688 ClobberRefs[i] = StringRef(Clobbers[i]); 689 690 // Recast the void pointers and build the vector of constraint StringRefs. 691 unsigned NumExprs = NumOutputs + NumInputs; 692 Names.resize(NumExprs); 693 ConstraintRefs.resize(NumExprs); 694 Exprs.resize(NumExprs); 695 for (unsigned i = 0, e = NumExprs; i != e; ++i) { 696 NamedDecl *OpDecl = static_cast<NamedDecl *>(OpDecls[i].first); 697 if (!OpDecl) 698 return StmtError(); 699 700 DeclarationNameInfo NameInfo(OpDecl->getDeclName(), AsmLoc); 701 ExprResult OpExpr = BuildDeclarationNameExpr(CXXScopeSpec(), NameInfo, 702 OpDecl); 703 if (OpExpr.isInvalid()) 704 return StmtError(); 705 706 // Need address of variable. 707 if (OpDecls[i].second) 708 OpExpr = BuildUnaryOp(getCurScope(), AsmLoc, clang::UO_AddrOf, 709 OpExpr.take()); 710 711 Names[i] = OpDecl->getIdentifier(); 712 ConstraintRefs[i] = StringRef(Constraints[i]); 713 Exprs[i] = OpExpr.take(); 714 } 715 716 bool IsSimple = NumExprs > 0; 717 MSAsmStmt *NS = 718 new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, IsSimple, 719 /*IsVolatile*/ true, AsmToks, NumOutputs, NumInputs, 720 Names, ConstraintRefs, Exprs, AsmStringIR, 721 ClobberRefs, EndLoc); 722 return Owned(NS); 723} 724