SemaStmtAsm.cpp revision 98ac608c79fb46e73715121018f0659fb3bbe3e8
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 331static StringRef getSpelling(Sema &SemaRef, Token AsmTok) { 332 StringRef Asm; 333 SmallString<512> TokenBuf; 334 TokenBuf.resize(512); 335 bool StringInvalid = false; 336 Asm = SemaRef.PP.getSpelling(AsmTok, TokenBuf, &StringInvalid); 337 assert (!StringInvalid && "Expected valid string!"); 338 return Asm; 339} 340 341static bool isSimpleMSAsm(std::vector<StringRef> &Pieces, 342 const TargetInfo &TI) { 343 if (isMSAsmKeyword(Pieces[0])) 344 return false; 345 346 for (unsigned i = 1, e = Pieces.size(); i != e; ++i) 347 if (!TI.isValidGCCRegisterName(Pieces[i])) 348 return false; 349 350 return true; 351} 352 353// Break the AsmSting into pieces. 354static void buildMSAsmPieces(StringRef Asm, std::vector<StringRef> &Pieces) { 355 std::pair<StringRef,StringRef> Split = Asm.split(' '); 356 357 // Mnemonic 358 Pieces.push_back(Split.first); 359 Asm = Split.second; 360 361 // Operands 362 while (!Asm.empty()) { 363 Split = Asm.split(", "); 364 Pieces.push_back(Split.first); 365 Asm = Split.second; 366 } 367} 368 369// Build the unmodified MSAsmString. 370static std::string buildMSAsmString(Sema &SemaRef, 371 ArrayRef<Token> AsmToks, 372 std::vector<std::string> &AsmStrings) { 373 assert (!AsmToks.empty() && "Didn't expect an empty AsmToks!"); 374 375 SmallString<512> Res; 376 SmallString<512> Asm; 377 for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) { 378 bool isNewAsm = i == 0 || AsmToks[i].isAtStartOfLine() || 379 AsmToks[i].is(tok::kw_asm); 380 381 if (isNewAsm) { 382 if (i) { 383 AsmStrings.push_back(Asm.c_str()); 384 Res += Asm; 385 Asm.clear(); 386 Res += '\n'; 387 } 388 if (AsmToks[i].is(tok::kw_asm)) { 389 i++; // Skip __asm 390 assert (i != e && "Expected another token"); 391 } 392 } 393 394 if (i && AsmToks[i].hasLeadingSpace() && !isNewAsm) 395 Asm += ' '; 396 397 Asm += getSpelling(SemaRef, AsmToks[i]); 398 } 399 AsmStrings.push_back(Asm.c_str()); 400 Res += Asm; 401 return Res.c_str(); 402} 403 404StmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc, 405 SourceLocation LBraceLoc, 406 ArrayRef<Token> AsmToks, 407 SourceLocation EndLoc) { 408 // MS-style inline assembly is not fully supported, so emit a warning. 409 Diag(AsmLoc, diag::warn_unsupported_msasm); 410 SmallVector<StringRef,4> Clobbers; 411 std::set<std::string> ClobberRegs; 412 SmallVector<IdentifierInfo*, 4> Inputs; 413 SmallVector<IdentifierInfo*, 4> Outputs; 414 415 // Empty asm statements don't need to instantiate the AsmParser, etc. 416 if (AsmToks.empty()) { 417 StringRef AsmString; 418 MSAsmStmt *NS = 419 new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, /*IsSimple*/ true, 420 /*IsVolatile*/ true, AsmToks, Inputs, Outputs, 421 AsmString, Clobbers, EndLoc); 422 return Owned(NS); 423 } 424 425 unsigned NumAsmStrings; 426 std::vector<std::string> AsmStrings; 427 std::string AsmString = buildMSAsmString(*this, AsmToks, AsmStrings); 428 NumAsmStrings = AsmStrings.size(); 429 430 std::vector<std::vector<StringRef> > Pieces; 431 Pieces.resize(NumAsmStrings); 432 433 bool IsSimple = true; 434 for (unsigned i = 0; i != NumAsmStrings; ++i) { 435 buildMSAsmPieces(AsmStrings[i], Pieces[i]); 436 if (IsSimple) 437 IsSimple = isSimpleMSAsm(Pieces[i], Context.getTargetInfo()); 438 } 439 440 // AsmParser doesn't fully support non-simple asm statements. 441 if (!IsSimple) { 442 MSAsmStmt *NS = 443 new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, /*IsSimple*/ true, 444 /*IsVolatile*/ true, AsmToks, Inputs, Outputs, 445 AsmString, Clobbers, EndLoc); 446 return Owned(NS); 447 } 448 449 // Initialize targets and assembly printers/parsers. 450 llvm::InitializeAllTargetInfos(); 451 llvm::InitializeAllTargetMCs(); 452 llvm::InitializeAllAsmParsers(); 453 454 // Get the target specific parser. 455 std::string Error; 456 const std::string &TT = Context.getTargetInfo().getTriple().getTriple(); 457 const llvm::Target *TheTarget(llvm::TargetRegistry::lookupTarget(TT, Error)); 458 459 OwningPtr<llvm::MCAsmInfo> MAI(TheTarget->createMCAsmInfo(TT)); 460 OwningPtr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT)); 461 OwningPtr<llvm::MCObjectFileInfo> MOFI(new llvm::MCObjectFileInfo()); 462 OwningPtr<llvm::MCSubtargetInfo> 463 STI(TheTarget->createMCSubtargetInfo(TT, "", "")); 464 465 for (unsigned i = 0, e = AsmStrings.size(); i != e; ++i) { 466 llvm::SourceMgr SrcMgr; 467 llvm::MCContext Ctx(*MAI, *MRI, MOFI.get(), &SrcMgr); 468 llvm::MemoryBuffer *Buffer = 469 llvm::MemoryBuffer::getMemBuffer(AsmStrings[i], "<inline asm>"); 470 471 // Tell SrcMgr about this buffer, which is what the parser will pick up. 472 SrcMgr.AddNewSourceBuffer(Buffer, llvm::SMLoc()); 473 474 OwningPtr<llvm::MCStreamer> Str(createNullStreamer(Ctx)); 475 OwningPtr<llvm::MCAsmParser> 476 Parser(createMCAsmParser(SrcMgr, Ctx, *Str.get(), *MAI)); 477 OwningPtr<llvm::MCTargetAsmParser> 478 TargetParser(TheTarget->createMCAsmParser(*STI, *Parser)); 479 // Change to the Intel dialect. 480 Parser->setAssemblerDialect(1); 481 Parser->setTargetParser(*TargetParser.get()); 482 483 // Prime the lexer. 484 Parser->Lex(); 485 486 // Parse the opcode. 487 StringRef IDVal; 488 Parser->ParseIdentifier(IDVal); 489 490 // Canonicalize the opcode to lower case. 491 SmallString<128> Opcode; 492 for (unsigned i = 0, e = IDVal.size(); i != e; ++i) 493 Opcode.push_back(tolower(IDVal[i])); 494 495 // Parse the operands. 496 llvm::SMLoc IDLoc; 497 SmallVector<llvm::MCParsedAsmOperand*, 8> Operands; 498 bool HadError = TargetParser->ParseInstruction(Opcode.str(), IDLoc, 499 Operands); 500 assert (!HadError && "Unexpected error parsing instruction"); 501 502 // Match the MCInstr. 503 unsigned ErrorInfo; 504 SmallVector<llvm::MCInst, 2> Instrs; 505 HadError = TargetParser->MatchInstruction(IDLoc, Operands, Instrs, 506 ErrorInfo, 507 /*matchingInlineAsm*/ true); 508 assert (!HadError && "Unexpected error matching instruction"); 509 assert ((Instrs.size() == 1) && "Expected only a single instruction."); 510 511 // Get the instruction descriptor. 512 llvm::MCInst Inst = Instrs[0]; 513 const llvm::MCInstrInfo *MII = TheTarget->createMCInstrInfo(); 514 const llvm::MCInstrDesc &Desc = MII->get(Inst.getOpcode()); 515 llvm::MCInstPrinter *IP = 516 TheTarget->createMCInstPrinter(1, *MAI, *MII, *MRI, *STI); 517 518 // Build the list of clobbers. 519 for (unsigned i = 0, e = Desc.getNumDefs(); i != e; ++i) { 520 const llvm::MCOperand &Op = Inst.getOperand(i); 521 if (!Op.isReg()) 522 continue; 523 524 std::string Reg; 525 llvm::raw_string_ostream OS(Reg); 526 IP->printRegName(OS, Op.getReg()); 527 528 StringRef Clobber(OS.str()); 529 if (!Context.getTargetInfo().isValidClobber(Clobber)) 530 return StmtError(Diag(AsmLoc, diag::err_asm_unknown_register_name) << 531 Clobber); 532 ClobberRegs.insert(Reg); 533 } 534 } 535 for (std::set<std::string>::iterator I = ClobberRegs.begin(), 536 E = ClobberRegs.end(); I != E; ++I) 537 Clobbers.push_back(*I); 538 539 MSAsmStmt *NS = 540 new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, IsSimple, 541 /*IsVolatile*/ true, AsmToks, Inputs, Outputs, 542 AsmString, Clobbers, EndLoc); 543 return Owned(NS); 544} 545