contrib/llvm/tools/clang/lib/Sema/SemaStmtAsm.cpp

   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/AST/ExprCXX.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 "clang/Sema/SemaInternal.h"
  24 #include "llvm/ADT/ArrayRef.h"
  25 #include "llvm/ADT/StringSet.h"
  26 #include "llvm/MC/MCParser/MCAsmParser.h"
  27 using namespace clang;
  28 using namespace sema;
  29
  30 /// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
  31 /// ignore "noop" casts in places where an lvalue is required by an inline asm.
  32 /// We emulate this behavior when -fheinous-gnu-extensions is specified, but
  33 /// provide a strong guidance to not use it.
  34 ///
  35 /// This method checks to see if the argument is an acceptable l-value and
  36 /// returns false if it is a case we can handle.
  37 static bool CheckAsmLValue(const Expr *E, Sema &S) {
  38   // Type dependent expressions will be checked during instantiation.
  39   if (E->isTypeDependent())
  40     return false;
  41
  42   if (E->isLValue())
  43     return false;  // Cool, this is an lvalue.
  44
  45   // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
  46   // are supposed to allow.
  47   const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
  48   if (E != E2 && E2->isLValue()) {
  49     if (!S.getLangOpts().HeinousExtensions)
  50       S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
  51           << E->getSourceRange();
  52     else
  53       S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
  54           << E->getSourceRange();
  55     // Accept, even if we emitted an error diagnostic.
  56     return false;
  57   }
  58
  59   // None of the above, just randomly invalid non-lvalue.
  60   return true;
  61 }
  62
  63 /// isOperandMentioned - Return true if the specified operand # is mentioned
  64 /// anywhere in the decomposed asm string.
  65 static bool
  66 isOperandMentioned(unsigned OpNo,
  67                    ArrayRef<GCCAsmStmt::AsmStringPiece> AsmStrPieces) {
  68   for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
  69     const GCCAsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
  70     if (!Piece.isOperand())
  71       continue;
  72
  73     // If this is a reference to the input and if the input was the smaller
  74     // one, then we have to reject this asm.
  75     if (Piece.getOperandNo() == OpNo)
  76       return true;
  77   }
  78   return false;
  79 }
  80
  81 static bool CheckNakedParmReference(Expr *E, Sema &S) {
  82   FunctionDecl *Func = dyn_cast<FunctionDecl>(S.CurContext);
  83   if (!Func)
  84     return false;
  85   if (!Func->hasAttr<NakedAttr>())
  86     return false;
  87
  88   SmallVector<Expr*, 4> WorkList;
  89   WorkList.push_back(E);
  90   while (WorkList.size()) {
  91     Expr *E = WorkList.pop_back_val();
  92     if (isa<CXXThisExpr>(E)) {
  93       S.Diag(E->getLocStart(), diag::err_asm_naked_this_ref);
  94       S.Diag(Func->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
  95       return true;
  96     }
  97     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
  98       if (isa<ParmVarDecl>(DRE->getDecl())) {
  99         S.Diag(DRE->getLocStart(), diag::err_asm_naked_parm_ref);
 100         S.Diag(Func->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
 101         return true;
 102       }
 103     }
 104     for (Stmt *Child : E->children()) {
 105       if (Expr *E = dyn_cast_or_null<Expr>(Child))
 106         WorkList.push_back(E);
 107     }
 108   }
 109   return false;
 110 }
 111
 112 /// \brief Returns true if given expression is not compatible with inline
 113 /// assembly's memory constraint; false otherwise.
 114 static bool checkExprMemoryConstraintCompat(Sema &S, Expr *E,
 115                                             TargetInfo::ConstraintInfo &Info,
 116                                             bool is_input_expr) {
 117   enum {
 118     ExprBitfield = 0,
 119     ExprVectorElt,
 120     ExprGlobalRegVar,
 121     ExprSafeType
 122   } EType = ExprSafeType;
 123
 124   // Bitfields, vector elements and global register variables are not
 125   // compatible.
 126   if (E->refersToBitField())
 127     EType = ExprBitfield;
 128   else if (E->refersToVectorElement())
 129     EType = ExprVectorElt;
 130   else if (E->refersToGlobalRegisterVar())
 131     EType = ExprGlobalRegVar;
 132
 133   if (EType != ExprSafeType) {
 134     S.Diag(E->getLocStart(), diag::err_asm_non_addr_value_in_memory_constraint)
 135         << EType << is_input_expr << Info.getConstraintStr()
 136         << E->getSourceRange();
 137     return true;
 138   }
 139
 140   return false;
 141 }
 142
 143 // Extracting the register name from the Expression value,
 144 // if there is no register name to extract, returns ""
 145 static StringRef extractRegisterName(const Expr *Expression,
 146                                      const TargetInfo &Target) {
 147   Expression = Expression->IgnoreImpCasts();
 148   if (const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(Expression)) {
 149     // Handle cases where the expression is a variable
 150     const VarDecl *Variable = dyn_cast<VarDecl>(AsmDeclRef->getDecl());
 151     if (Variable && Variable->getStorageClass() == SC_Register) {
 152       if (AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>())
 153         if (Target.isValidGCCRegisterName(Attr->getLabel()))
 154           return Target.getNormalizedGCCRegisterName(Attr->getLabel(), true);
 155     }
 156   }
 157   return "";
 158 }
 159
 160 // Checks if there is a conflict between the input and output lists with the
 161 // clobbers list. If there's a conflict, returns the location of the
 162 // conflicted clobber, else returns nullptr
 163 static SourceLocation
 164 getClobberConflictLocation(MultiExprArg Exprs, StringLiteral **Constraints,
 165                            StringLiteral **Clobbers, int NumClobbers,
 166                            const TargetInfo &Target, ASTContext &Cont) {
 167   llvm::StringSet<> InOutVars;
 168   // Collect all the input and output registers from the extended asm
 169   // statement in order to check for conflicts with the clobber list
 170   for (unsigned int i = 0; i < Exprs.size(); ++i) {
 171     StringRef Constraint = Constraints[i]->getString();
 172     StringRef InOutReg = Target.getConstraintRegister(
 173         Constraint, extractRegisterName(Exprs[i], Target));
 174     if (InOutReg != "")
 175       InOutVars.insert(InOutReg);
 176   }
 177   // Check for each item in the clobber list if it conflicts with the input
 178   // or output
 179   for (int i = 0; i < NumClobbers; ++i) {
 180     StringRef Clobber = Clobbers[i]->getString();
 181     // We only check registers, therefore we don't check cc and memory
 182     // clobbers
 183     if (Clobber == "cc" || Clobber == "memory")
 184       continue;
 185     Clobber = Target.getNormalizedGCCRegisterName(Clobber, true);
 186     // Go over the output's registers we collected
 187     if (InOutVars.count(Clobber))
 188       return Clobbers[i]->getLocStart();
 189   }
 190   return SourceLocation();
 191 }
 192
 193 StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
 194                                  bool IsVolatile, unsigned NumOutputs,
 195                                  unsigned NumInputs, IdentifierInfo **Names,
 196                                  MultiExprArg constraints, MultiExprArg Exprs,
 197                                  Expr *asmString, MultiExprArg clobbers,
 198                                  SourceLocation RParenLoc) {
 199   unsigned NumClobbers = clobbers.size();
 200   StringLiteral **Constraints =
 201     reinterpret_cast<StringLiteral**>(constraints.data());
 202   StringLiteral *AsmString = cast<StringLiteral>(asmString);
 203   StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.data());
 204
 205   SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
 206
 207   // The parser verifies that there is a string literal here.
 208   assert(AsmString->isAscii());
 209
 210   // If we're compiling CUDA file and function attributes indicate that it's not
 211   // for this compilation side, skip all the checks.
 212   if (!DeclAttrsMatchCUDAMode(getLangOpts(), getCurFunctionDecl())) {
 213     GCCAsmStmt *NS = new (Context) GCCAsmStmt(
 214         Context, AsmLoc, IsSimple, IsVolatile, NumOutputs, NumInputs, Names,
 215         Constraints, Exprs.data(), AsmString, NumClobbers, Clobbers, RParenLoc);
 216     return NS;
 217   }
 218
 219   for (unsigned i = 0; i != NumOutputs; i++) {
 220     StringLiteral *Literal = Constraints[i];
 221     assert(Literal->isAscii());
 222
 223     StringRef OutputName;
 224     if (Names[i])
 225       OutputName = Names[i]->getName();
 226
 227     TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
 228     if (!Context.getTargetInfo().validateOutputConstraint(Info))
 229       return StmtError(Diag(Literal->getLocStart(),
 230                             diag::err_asm_invalid_output_constraint)
 231                        << Info.getConstraintStr());
 232
 233     ExprResult ER = CheckPlaceholderExpr(Exprs[i]);
 234     if (ER.isInvalid())
 235       return StmtError();
 236     Exprs[i] = ER.get();
 237
 238     // Check that the output exprs are valid lvalues.
 239     Expr *OutputExpr = Exprs[i];
 240
 241     // Referring to parameters is not allowed in naked functions.
 242     if (CheckNakedParmReference(OutputExpr, *this))
 243       return StmtError();
 244
 245     // Check that the output expression is compatible with memory constraint.
 246     if (Info.allowsMemory() &&
 247         checkExprMemoryConstraintCompat(*this, OutputExpr, Info, false))
 248       return StmtError();
 249
 250     OutputConstraintInfos.push_back(Info);
 251
 252     // If this is dependent, just continue.
 253     if (OutputExpr->isTypeDependent())
 254       continue;
 255
 256     Expr::isModifiableLvalueResult IsLV =
 257         OutputExpr->isModifiableLvalue(Context, /*Loc=*/nullptr);
 258     switch (IsLV) {
 259     case Expr::MLV_Valid:
 260       // Cool, this is an lvalue.
 261       break;
 262     case Expr::MLV_ArrayType:
 263       // This is OK too.
 264       break;
 265     case Expr::MLV_LValueCast: {
 266       const Expr *LVal = OutputExpr->IgnoreParenNoopCasts(Context);
 267       if (!getLangOpts().HeinousExtensions) {
 268         Diag(LVal->getLocStart(), diag::err_invalid_asm_cast_lvalue)
 269             << OutputExpr->getSourceRange();
 270       } else {
 271         Diag(LVal->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
 272             << OutputExpr->getSourceRange();
 273       }
 274       // Accept, even if we emitted an error diagnostic.
 275       break;
 276     }
 277     case Expr::MLV_IncompleteType:
 278     case Expr::MLV_IncompleteVoidType:
 279       if (RequireCompleteType(OutputExpr->getLocStart(), Exprs[i]->getType(),
 280                               diag::err_dereference_incomplete_type))
 281         return StmtError();
 282       LLVM_FALLTHROUGH;
 283     default:
 284       return StmtError(Diag(OutputExpr->getLocStart(),
 285                             diag::err_asm_invalid_lvalue_in_output)
 286                        << OutputExpr->getSourceRange());
 287     }
 288
 289     unsigned Size = Context.getTypeSize(OutputExpr->getType());
 290     if (!Context.getTargetInfo().validateOutputSize(Literal->getString(),
 291                                                     Size))
 292       return StmtError(Diag(OutputExpr->getLocStart(),
 293                             diag::err_asm_invalid_output_size)
 294                        << Info.getConstraintStr());
 295   }
 296
 297   SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
 298
 299   for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
 300     StringLiteral *Literal = Constraints[i];
 301     assert(Literal->isAscii());
 302
 303     StringRef InputName;
 304     if (Names[i])
 305       InputName = Names[i]->getName();
 306
 307     TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
 308     if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos,
 309                                                          Info)) {
 310       return StmtError(Diag(Literal->getLocStart(),
 311                             diag::err_asm_invalid_input_constraint)
 312                        << Info.getConstraintStr());
 313     }
 314
 315     ExprResult ER = CheckPlaceholderExpr(Exprs[i]);
 316     if (ER.isInvalid())
 317       return StmtError();
 318     Exprs[i] = ER.get();
 319
 320     Expr *InputExpr = Exprs[i];
 321
 322     // Referring to parameters is not allowed in naked functions.
 323     if (CheckNakedParmReference(InputExpr, *this))
 324       return StmtError();
 325
 326     // Check that the input expression is compatible with memory constraint.
 327     if (Info.allowsMemory() &&
 328         checkExprMemoryConstraintCompat(*this, InputExpr, Info, true))
 329       return StmtError();
 330
 331     // Only allow void types for memory constraints.
 332     if (Info.allowsMemory() && !Info.allowsRegister()) {
 333       if (CheckAsmLValue(InputExpr, *this))
 334         return StmtError(Diag(InputExpr->getLocStart(),
 335                               diag::err_asm_invalid_lvalue_in_input)
 336                          << Info.getConstraintStr()
 337                          << InputExpr->getSourceRange());
 338     } else if (Info.requiresImmediateConstant() && !Info.allowsRegister()) {
 339       if (!InputExpr->isValueDependent()) {
 340         llvm::APSInt Result;
 341         if (!InputExpr->EvaluateAsInt(Result, Context))
 342            return StmtError(
 343                Diag(InputExpr->getLocStart(), diag::err_asm_immediate_expected)
 344                 << Info.getConstraintStr() << InputExpr->getSourceRange());
 345          if (!Info.isValidAsmImmediate(Result))
 346            return StmtError(Diag(InputExpr->getLocStart(),
 347                                  diag::err_invalid_asm_value_for_constraint)
 348                             << Result.toString(10) << Info.getConstraintStr()
 349                             << InputExpr->getSourceRange());
 350       }
 351
 352     } else {
 353       ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
 354       if (Result.isInvalid())
 355         return StmtError();
 356
 357       Exprs[i] = Result.get();
 358     }
 359
 360     if (Info.allowsRegister()) {
 361       if (InputExpr->getType()->isVoidType()) {
 362         return StmtError(Diag(InputExpr->getLocStart(),
 363                               diag::err_asm_invalid_type_in_input)
 364           << InputExpr->getType() << Info.getConstraintStr()
 365           << InputExpr->getSourceRange());
 366       }
 367     }
 368
 369     InputConstraintInfos.push_back(Info);
 370
 371     const Type *Ty = Exprs[i]->getType().getTypePtr();
 372     if (Ty->isDependentType())
 373       continue;
 374
 375     if (!Ty->isVoidType() || !Info.allowsMemory())
 376       if (RequireCompleteType(InputExpr->getLocStart(), Exprs[i]->getType(),
 377                               diag::err_dereference_incomplete_type))
 378         return StmtError();
 379
 380     unsigned Size = Context.getTypeSize(Ty);
 381     if (!Context.getTargetInfo().validateInputSize(Literal->getString(),
 382                                                    Size))
 383       return StmtError(Diag(InputExpr->getLocStart(),
 384                             diag::err_asm_invalid_input_size)
 385                        << Info.getConstraintStr());
 386   }
 387
 388   // Check that the clobbers are valid.
 389   for (unsigned i = 0; i != NumClobbers; i++) {
 390     StringLiteral *Literal = Clobbers[i];
 391     assert(Literal->isAscii());
 392
 393     StringRef Clobber = Literal->getString();
 394
 395     if (!Context.getTargetInfo().isValidClobber(Clobber))
 396       return StmtError(Diag(Literal->getLocStart(),
 397                   diag::err_asm_unknown_register_name) << Clobber);
 398   }
 399
 400   GCCAsmStmt *NS =
 401     new (Context) GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
 402                              NumInputs, Names, Constraints, Exprs.data(),
 403                              AsmString, NumClobbers, Clobbers, RParenLoc);
 404   // Validate the asm string, ensuring it makes sense given the operands we
 405   // have.
 406   SmallVector<GCCAsmStmt::AsmStringPiece, 8> Pieces;
 407   unsigned DiagOffs;
 408   if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
 409     Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
 410            << AsmString->getSourceRange();
 411     return StmtError();
 412   }
 413
 414   // Validate constraints and modifiers.
 415   for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {
 416     GCCAsmStmt::AsmStringPiece &Piece = Pieces[i];
 417     if (!Piece.isOperand()) continue;
 418
 419     // Look for the correct constraint index.
 420     unsigned ConstraintIdx = Piece.getOperandNo();
 421     unsigned NumOperands = NS->getNumOutputs() + NS->getNumInputs();
 422
 423     // Look for the (ConstraintIdx - NumOperands + 1)th constraint with
 424     // modifier '+'.
 425     if (ConstraintIdx >= NumOperands) {
 426       unsigned I = 0, E = NS->getNumOutputs();
 427
 428       for (unsigned Cnt = ConstraintIdx - NumOperands; I != E; ++I)
 429         if (OutputConstraintInfos[I].isReadWrite() && Cnt-- == 0) {
 430           ConstraintIdx = I;
 431           break;
 432         }
 433
 434       assert(I != E && "Invalid operand number should have been caught in "
 435                        " AnalyzeAsmString");
 436     }
 437
 438     // Now that we have the right indexes go ahead and check.
 439     StringLiteral *Literal = Constraints[ConstraintIdx];
 440     const Type *Ty = Exprs[ConstraintIdx]->getType().getTypePtr();
 441     if (Ty->isDependentType() || Ty->isIncompleteType())
 442       continue;
 443
 444     unsigned Size = Context.getTypeSize(Ty);
 445     std::string SuggestedModifier;
 446     if (!Context.getTargetInfo().validateConstraintModifier(
 447             Literal->getString(), Piece.getModifier(), Size,
 448             SuggestedModifier)) {
 449       Diag(Exprs[ConstraintIdx]->getLocStart(),
 450            diag::warn_asm_mismatched_size_modifier);
 451
 452       if (!SuggestedModifier.empty()) {
 453         auto B = Diag(Piece.getRange().getBegin(),
 454                       diag::note_asm_missing_constraint_modifier)
 455                  << SuggestedModifier;
 456         SuggestedModifier = "%" + SuggestedModifier + Piece.getString();
 457         B.AddFixItHint(FixItHint::CreateReplacement(Piece.getRange(),
 458                                                     SuggestedModifier));
 459       }
 460     }
 461   }
 462
 463   // Validate tied input operands for type mismatches.
 464   unsigned NumAlternatives = ~0U;
 465   for (unsigned i = 0, e = OutputConstraintInfos.size(); i != e; ++i) {
 466     TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i];
 467     StringRef ConstraintStr = Info.getConstraintStr();
 468     unsigned AltCount = ConstraintStr.count(',') + 1;
 469     if (NumAlternatives == ~0U)
 470       NumAlternatives = AltCount;
 471     else if (NumAlternatives != AltCount)
 472       return StmtError(Diag(NS->getOutputExpr(i)->getLocStart(),
 473                             diag::err_asm_unexpected_constraint_alternatives)
 474                        << NumAlternatives << AltCount);
 475   }
 476   SmallVector<size_t, 4> InputMatchedToOutput(OutputConstraintInfos.size(),
 477                                               ~0U);
 478   for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
 479     TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
 480     StringRef ConstraintStr = Info.getConstraintStr();
 481     unsigned AltCount = ConstraintStr.count(',') + 1;
 482     if (NumAlternatives == ~0U)
 483       NumAlternatives = AltCount;
 484     else if (NumAlternatives != AltCount)
 485       return StmtError(Diag(NS->getInputExpr(i)->getLocStart(),
 486                             diag::err_asm_unexpected_constraint_alternatives)
 487                        << NumAlternatives << AltCount);
 488
 489     // If this is a tied constraint, verify that the output and input have
 490     // either exactly the same type, or that they are int/ptr operands with the
 491     // same size (int/long, int*/long, are ok etc).
 492     if (!Info.hasTiedOperand()) continue;
 493
 494     unsigned TiedTo = Info.getTiedOperand();
 495     unsigned InputOpNo = i+NumOutputs;
 496     Expr *OutputExpr = Exprs[TiedTo];
 497     Expr *InputExpr = Exprs[InputOpNo];
 498
 499     // Make sure no more than one input constraint matches each output.
 500     assert(TiedTo < InputMatchedToOutput.size() && "TiedTo value out of range");
 501     if (InputMatchedToOutput[TiedTo] != ~0U) {
 502       Diag(NS->getInputExpr(i)->getLocStart(),
 503            diag::err_asm_input_duplicate_match)
 504           << TiedTo;
 505       Diag(NS->getInputExpr(InputMatchedToOutput[TiedTo])->getLocStart(),
 506            diag::note_asm_input_duplicate_first)
 507           << TiedTo;
 508       return StmtError();
 509     }
 510     InputMatchedToOutput[TiedTo] = i;
 511
 512     if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent())
 513       continue;
 514
 515     QualType InTy = InputExpr->getType();
 516     QualType OutTy = OutputExpr->getType();
 517     if (Context.hasSameType(InTy, OutTy))
 518       continue;  // All types can be tied to themselves.
 519
 520     // Decide if the input and output are in the same domain (integer/ptr or
 521     // floating point.
 522     enum AsmDomain {
 523       AD_Int, AD_FP, AD_Other
 524     } InputDomain, OutputDomain;
 525
 526     if (InTy->isIntegerType() || InTy->isPointerType())
 527       InputDomain = AD_Int;
 528     else if (InTy->isRealFloatingType())
 529       InputDomain = AD_FP;
 530     else
 531       InputDomain = AD_Other;
 532
 533     if (OutTy->isIntegerType() || OutTy->isPointerType())
 534       OutputDomain = AD_Int;
 535     else if (OutTy->isRealFloatingType())
 536       OutputDomain = AD_FP;
 537     else
 538       OutputDomain = AD_Other;
 539
 540     // They are ok if they are the same size and in the same domain.  This
 541     // allows tying things like:
 542     //   void* to int*
 543     //   void* to int            if they are the same size.
 544     //   double to long double   if they are the same size.
 545     //
 546     uint64_t OutSize = Context.getTypeSize(OutTy);
 547     uint64_t InSize = Context.getTypeSize(InTy);
 548     if (OutSize == InSize && InputDomain == OutputDomain &&
 549         InputDomain != AD_Other)
 550       continue;
 551
 552     // If the smaller input/output operand is not mentioned in the asm string,
 553     // then we can promote the smaller one to a larger input and the asm string
 554     // won't notice.
 555     bool SmallerValueMentioned = false;
 556
 557     // If this is a reference to the input and if the input was the smaller
 558     // one, then we have to reject this asm.
 559     if (isOperandMentioned(InputOpNo, Pieces)) {
 560       // This is a use in the asm string of the smaller operand.  Since we
 561       // codegen this by promoting to a wider value, the asm will get printed
 562       // "wrong".
 563       SmallerValueMentioned |= InSize < OutSize;
 564     }
 565     if (isOperandMentioned(TiedTo, Pieces)) {
 566       // If this is a reference to the output, and if the output is the larger
 567       // value, then it's ok because we'll promote the input to the larger type.
 568       SmallerValueMentioned |= OutSize < InSize;
 569     }
 570
 571     // If the smaller value wasn't mentioned in the asm string, and if the
 572     // output was a register, just extend the shorter one to the size of the
 573     // larger one.
 574     if (!SmallerValueMentioned && InputDomain != AD_Other &&
 575         OutputConstraintInfos[TiedTo].allowsRegister())
 576       continue;
 577
 578     // Either both of the operands were mentioned or the smaller one was
 579     // mentioned.  One more special case that we'll allow: if the tied input is
 580     // integer, unmentioned, and is a constant, then we'll allow truncating it
 581     // down to the size of the destination.
 582     if (InputDomain == AD_Int && OutputDomain == AD_Int &&
 583         !isOperandMentioned(InputOpNo, Pieces) &&
 584         InputExpr->isEvaluatable(Context)) {
 585       CastKind castKind =
 586         (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
 587       InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).get();
 588       Exprs[InputOpNo] = InputExpr;
 589       NS->setInputExpr(i, InputExpr);
 590       continue;
 591     }
 592
 593     Diag(InputExpr->getLocStart(),
 594          diag::err_asm_tying_incompatible_types)
 595       << InTy << OutTy << OutputExpr->getSourceRange()
 596       << InputExpr->getSourceRange();
 597     return StmtError();
 598   }
 599
 600   // Check for conflicts between clobber list and input or output lists
 601   SourceLocation ConstraintLoc =
 602       getClobberConflictLocation(Exprs, Constraints, Clobbers, NumClobbers,
 603                                  Context.getTargetInfo(), Context);
 604   if (ConstraintLoc.isValid())
 605     return Diag(ConstraintLoc, diag::error_inoutput_conflict_with_clobber);
 606
 607   return NS;
 608 }
 609
 610 void Sema::FillInlineAsmIdentifierInfo(Expr *Res,
 611                                        llvm::InlineAsmIdentifierInfo &Info) {
 612   QualType T = Res->getType();
 613   Expr::EvalResult Eval;
 614   if (T->isFunctionType() || T->isDependentType())
 615     return Info.setLabel(Res);
 616   if (Res->isRValue()) {
 617     if (isa<clang::EnumType>(T) && Res->EvaluateAsRValue(Eval, Context))
 618       return Info.setEnum(Eval.Val.getInt().getSExtValue());
 619     return Info.setLabel(Res);
 620   }
 621   unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
 622   unsigned Type = Size;
 623   if (const auto *ATy = Context.getAsArrayType(T))
 624     Type = Context.getTypeSizeInChars(ATy->getElementType()).getQuantity();
 625   bool IsGlobalLV = false;
 626   if (Res->EvaluateAsLValue(Eval, Context))
 627     IsGlobalLV = Eval.isGlobalLValue();
 628   Info.setVar(Res, IsGlobalLV, Size, Type);
 629 }
 630
 631 ExprResult Sema::LookupInlineAsmIdentifier(CXXScopeSpec &SS,
 632                                            SourceLocation TemplateKWLoc,
 633                                            UnqualifiedId &Id,
 634                                            bool IsUnevaluatedContext) {
 635
 636   if (IsUnevaluatedContext)
 637     PushExpressionEvaluationContext(
 638         ExpressionEvaluationContext::UnevaluatedAbstract,
 639         ReuseLambdaContextDecl);
 640
 641   ExprResult Result = ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Id,
 642                                         /*trailing lparen*/ false,
 643                                         /*is & operand*/ false,
 644                                         /*CorrectionCandidateCallback=*/nullptr,
 645                                         /*IsInlineAsmIdentifier=*/ true);
 646
 647   if (IsUnevaluatedContext)
 648     PopExpressionEvaluationContext();
 649
 650   if (!Result.isUsable()) return Result;
 651
 652   Result = CheckPlaceholderExpr(Result.get());
 653   if (!Result.isUsable()) return Result;
 654
 655   // Referring to parameters is not allowed in naked functions.
 656   if (CheckNakedParmReference(Result.get(), *this))
 657     return ExprError();
 658
 659   QualType T = Result.get()->getType();
 660
 661   if (T->isDependentType()) {
 662     return Result;
 663   }
 664
 665   // Any sort of function type is fine.
 666   if (T->isFunctionType()) {
 667     return Result;
 668   }
 669
 670   // Otherwise, it needs to be a complete type.
 671   if (RequireCompleteExprType(Result.get(), diag::err_asm_incomplete_type)) {
 672     return ExprError();
 673   }
 674
 675   return Result;
 676 }
 677
 678 bool Sema::LookupInlineAsmField(StringRef Base, StringRef Member,
 679                                 unsigned &Offset, SourceLocation AsmLoc) {
 680   Offset = 0;
 681   SmallVector<StringRef, 2> Members;
 682   Member.split(Members, ".");
 683
 684   NamedDecl *FoundDecl = nullptr;
 685
 686   // MS InlineAsm uses 'this' as a base
 687   if (getLangOpts().CPlusPlus && Base.equals("this")) {
 688     if (const Type *PT = getCurrentThisType().getTypePtrOrNull())
 689       FoundDecl = PT->getPointeeType()->getAsTagDecl();
 690   } else {
 691     LookupResult BaseResult(*this, &Context.Idents.get(Base), SourceLocation(),
 692                             LookupOrdinaryName);
 693     if (LookupName(BaseResult, getCurScope()) && BaseResult.isSingleResult())
 694       FoundDecl = BaseResult.getFoundDecl();
 695   }
 696
 697   if (!FoundDecl)
 698     return true;
 699
 700   for (StringRef NextMember : Members) {
 701     const RecordType *RT = nullptr;
 702     if (VarDecl *VD = dyn_cast<VarDecl>(FoundDecl))
 703       RT = VD->getType()->getAs<RecordType>();
 704     else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(FoundDecl)) {
 705       MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
 706       // MS InlineAsm often uses struct pointer aliases as a base
 707       QualType QT = TD->getUnderlyingType();
 708       if (const auto *PT = QT->getAs<PointerType>())
 709         QT = PT->getPointeeType();
 710       RT = QT->getAs<RecordType>();
 711     } else if (TypeDecl *TD = dyn_cast<TypeDecl>(FoundDecl))
 712       RT = TD->getTypeForDecl()->getAs<RecordType>();
 713     else if (FieldDecl *TD = dyn_cast<FieldDecl>(FoundDecl))
 714       RT = TD->getType()->getAs<RecordType>();
 715     if (!RT)
 716       return true;
 717
 718     if (RequireCompleteType(AsmLoc, QualType(RT, 0),
 719                             diag::err_asm_incomplete_type))
 720       return true;
 721
 722     LookupResult FieldResult(*this, &Context.Idents.get(NextMember),
 723                              SourceLocation(), LookupMemberName);
 724
 725     if (!LookupQualifiedName(FieldResult, RT->getDecl()))
 726       return true;
 727
 728     if (!FieldResult.isSingleResult())
 729       return true;
 730     FoundDecl = FieldResult.getFoundDecl();
 731
 732     // FIXME: Handle IndirectFieldDecl?
 733     FieldDecl *FD = dyn_cast<FieldDecl>(FoundDecl);
 734     if (!FD)
 735       return true;
 736
 737     const ASTRecordLayout &RL = Context.getASTRecordLayout(RT->getDecl());
 738     unsigned i = FD->getFieldIndex();
 739     CharUnits Result = Context.toCharUnitsFromBits(RL.getFieldOffset(i));
 740     Offset += (unsigned)Result.getQuantity();
 741   }
 742
 743   return false;
 744 }
 745
 746 ExprResult
 747 Sema::LookupInlineAsmVarDeclField(Expr *E, StringRef Member,
 748                                   SourceLocation AsmLoc) {
 749
 750   QualType T = E->getType();
 751   if (T->isDependentType()) {
 752     DeclarationNameInfo NameInfo;
 753     NameInfo.setLoc(AsmLoc);
 754     NameInfo.setName(&Context.Idents.get(Member));
 755     return CXXDependentScopeMemberExpr::Create(
 756         Context, E, T, /*IsArrow=*/false, AsmLoc, NestedNameSpecifierLoc(),
 757         SourceLocation(),
 758         /*FirstQualifierInScope=*/nullptr, NameInfo, /*TemplateArgs=*/nullptr);
 759   }
 760
 761   const RecordType *RT = T->getAs<RecordType>();
 762   // FIXME: Diagnose this as field access into a scalar type.
 763   if (!RT)
 764     return ExprResult();
 765
 766   LookupResult FieldResult(*this, &Context.Idents.get(Member), AsmLoc,
 767                            LookupMemberName);
 768
 769   if (!LookupQualifiedName(FieldResult, RT->getDecl()))
 770     return ExprResult();
 771
 772   // Only normal and indirect field results will work.
 773   ValueDecl *FD = dyn_cast<FieldDecl>(FieldResult.getFoundDecl());
 774   if (!FD)
 775     FD = dyn_cast<IndirectFieldDecl>(FieldResult.getFoundDecl());
 776   if (!FD)
 777     return ExprResult();
 778
 779   // Make an Expr to thread through OpDecl.
 780   ExprResult Result = BuildMemberReferenceExpr(
 781       E, E->getType(), AsmLoc, /*IsArrow=*/false, CXXScopeSpec(),
 782       SourceLocation(), nullptr, FieldResult, nullptr, nullptr);
 783
 784   return Result;
 785 }
 786
 787 StmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
 788                                 ArrayRef<Token> AsmToks,
 789                                 StringRef AsmString,
 790                                 unsigned NumOutputs, unsigned NumInputs,
 791                                 ArrayRef<StringRef> Constraints,
 792                                 ArrayRef<StringRef> Clobbers,
 793                                 ArrayRef<Expr*> Exprs,
 794                                 SourceLocation EndLoc) {
 795   bool IsSimple = (NumOutputs != 0 || NumInputs != 0);
 796   getCurFunction()->setHasBranchProtectedScope();
 797   MSAsmStmt *NS =
 798     new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, IsSimple,
 799                             /*IsVolatile*/ true, AsmToks, NumOutputs, NumInputs,
 800                             Constraints, Exprs, AsmString,
 801                             Clobbers, EndLoc);
 802   return NS;
 803 }
 804
 805 LabelDecl *Sema::GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
 806                                        SourceLocation Location,
 807                                        bool AlwaysCreate) {
 808   LabelDecl* Label = LookupOrCreateLabel(PP.getIdentifierInfo(ExternalLabelName),
 809                                          Location);
 810
 811   if (Label->isMSAsmLabel()) {
 812     // If we have previously created this label implicitly, mark it as used.
 813     Label->markUsed(Context);
 814   } else {
 815     // Otherwise, insert it, but only resolve it if we have seen the label itself.
 816     std::string InternalName;
 817     llvm::raw_string_ostream OS(InternalName);
 818     // Create an internal name for the label.  The name should not be a valid
 819     // mangled name, and should be unique.  We use a dot to make the name an
 820     // invalid mangled name. We use LLVM's inline asm ${:uid} escape so that a
 821     // unique label is generated each time this blob is emitted, even after
 822     // inlining or LTO.
 823     OS << "__MSASMLABEL_.${:uid}__";
 824     for (char C : ExternalLabelName) {
 825       OS << C;
 826       // We escape '$' in asm strings by replacing it with "$$"
 827       if (C == '$')
 828         OS << '$';
 829     }
 830     Label->setMSAsmLabel(OS.str());
 831   }
 832   if (AlwaysCreate) {
 833     // The label might have been created implicitly from a previously encountered
 834     // goto statement.  So, for both newly created and looked up labels, we mark
 835     // them as resolved.
 836     Label->setMSAsmLabelResolved();
 837   }
 838   // Adjust their location for being able to generate accurate diagnostics.
 839   Label->setLocation(Location);
 840
 841   return Label;
 842 }