Diagnose jumping from one MS inline assembly block to another.

[• ehsan]

Summary

This addresses PR21035. For now, we are unable to represent the
possibility of jumping between asm IR blocks in LLVM, so these kinds of
jumps don't play well with the SSA model. This patch adds a diagnostic
that detect those kinds of jumps, based on the information that the LLVM
side patch exposes from MC.

Note that we currently lose the SourceLocation for the branch statement
and the label definition statement, so the diagnostic is at inline
assembly block granularity. This issue will be addressed in a
follow-up.

[rnk]

lib/Sema/JumpDiagnostics.cpp

496

At a high level, I feel like we shouldn't need this map. It basically reinvents the label name lookup that sema is already performing for us.

What if we changed LabelDecl to hold an MSAsmStmt*? Conceptually, we could make TheStmt be a Stmt* and getStmt() could be 'return dyn_cast_or_null<LabelStmt>(TheStmt);'.

[• ehsan]

lib/Sema/JumpDiagnostics.cpp

496

How do we get the corresponding MSAsmStmt* though? LookupInlineAsmLabel doesn't have access to that information.

[rnk]

lib/Sema/JumpDiagnostics.cpp

496

Right, but it could record them in the ClangAsmParserCallback and forward it on to ActOnMSAsmStmt. At that point if there are any label decls that weren't provided by the current asm statement, we can diagnose them.

[• ehsan]

http://reviews.llvm.org/D5694 provides a simpler version of rnk's suggestion.

include/clang/AST/Stmt.h

 
 /// This represents a Microsoft inline-assembly statement extension.
 ///
 class MSAsmStmt : public AsmStmt {
   SourceLocation LBraceLoc, EndLoc;
   StringRef AsmStr;
 
   unsigned NumAsmToks;
+  unsigned NumBranchTargets;
+  unsigned NumLabelsDefined;
 
   Token *AsmToks;
   StringRef *Constraints;
   StringRef *Clobbers;
+  StringRef *BranchTargets;
+  StringRef *LabelsDefined;
 
   friend class ASTStmtReader;
 
 public:
   MSAsmStmt(const ASTContext &C, SourceLocation asmloc,
             SourceLocation lbraceloc, bool issimple, bool isvolatile,
             ArrayRef<Token> asmtoks, unsigned numoutputs, unsigned numinputs,
             ArrayRef<StringRef> constraints,
             ArrayRef<Expr*> exprs, StringRef asmstr,
-            ArrayRef<StringRef> clobbers, SourceLocation endloc);
+            ArrayRef<StringRef> clobbers,
+            ArrayRef<StringRef> branchTargets,
+            ArrayRef<StringRef> labelsDefined, SourceLocation endloc);
 
   /// \brief Build an empty MS-style inline-assembly statement.
   explicit MSAsmStmt(EmptyShell Empty) : AsmStmt(MSAsmStmtClass, Empty),
-    NumAsmToks(0), AsmToks(nullptr), Constraints(nullptr), Clobbers(nullptr) { }
+    NumAsmToks(0), NumBranchTargets(0), NumLabelsDefined(0),
+    AsmToks(nullptr), Constraints(nullptr), Clobbers(nullptr) { }
 
   SourceLocation getLBraceLoc() const { return LBraceLoc; }
   void setLBraceLoc(SourceLocation L) { LBraceLoc = L; }
   SourceLocation getEndLoc() const { return EndLoc; }
   void setEndLoc(SourceLocation L) { EndLoc = L; }
 
   bool hasBraces() const { return LBraceLoc.isValid(); }
 
public:
   //===--- Other ---===//
 
   ArrayRef<StringRef> getAllConstraints() const {
     return llvm::makeArrayRef(Constraints, NumInputs + NumOutputs);
   }
   ArrayRef<StringRef> getClobbers() const {
     return llvm::makeArrayRef(Clobbers, NumClobbers);
   }
+  ArrayRef<StringRef> getBranchTargets() const {
+    return llvm::makeArrayRef(BranchTargets, NumBranchTargets);
+  }
+  ArrayRef<StringRef> getLabelsDefined() const {
+    return llvm::makeArrayRef(LabelsDefined, NumLabelsDefined);
+  }
   ArrayRef<Expr*> getAllExprs() const {
     return llvm::makeArrayRef(reinterpret_cast<Expr**>(Exprs),
                               NumInputs + NumOutputs);
   }
 
   StringRef getClobber(unsigned i) const { return getClobbers()[i]; }
 
 private:
   void initialize(const ASTContext &C, StringRef AsmString,
                   ArrayRef<Token> AsmToks, ArrayRef<StringRef> Constraints,
-                  ArrayRef<Expr*> Exprs, ArrayRef<StringRef> Clobbers);
+                  ArrayRef<Expr*> Exprs, ArrayRef<StringRef> Clobbers,
+                  ArrayRef<StringRef> BranchTargets,
+                  ArrayRef<StringRef> LabelsDefined);
 public:
 
   SourceLocation getLocStart() const LLVM_READONLY { return AsmLoc; }
   SourceLocation getLocEnd() const LLVM_READONLY { return EndLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == MSAsmStmtClass;
   }

include/clang/Basic/DiagnosticSemaKinds.td

def warn_missing_braces : Warning<
   InGroup<MissingBraces>, DefaultIgnore;
 
 def err_redefinition_of_label : Error<"redefinition of label %0">;
 def err_undeclared_label_use : Error<"use of undeclared label %0">;
 def err_goto_ms_asm_label : Error<
   "cannot jump from this goto statement to label %0 inside an inline assembly block">;
 def note_goto_ms_asm_label : Note<
   "inline assembly label %0 declared here">;
+def err_cross_block_asm_jump : Error<
+  "cannot jump from one inline assembly block to label %0 defined inside another one">;
+def note_cross_block_asm_jump : Note <
+  "label %0 defined in an inline assembly block defined here">;
 def warn_unused_label : Warning<"unused label %0">,
   InGroup<UnusedLabel>, DefaultIgnore;
 
 def err_goto_into_protected_scope : Error<
   "cannot jump from this goto statement to its label">;
 def ext_goto_into_protected_scope : ExtWarn<
   "jump from this goto statement to its label is a Microsoft extension">,
   InGroup<Microsoft>;

include/clang/Sema/Sema.h

public:
   bool LookupInlineAsmField(StringRef Base, StringRef Member,
                             unsigned &Offset, SourceLocation AsmLoc);
   StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
                             ArrayRef<Token> AsmToks,
                             StringRef AsmString,
                             unsigned NumOutputs, unsigned NumInputs,
                             ArrayRef<StringRef> Constraints,
                             ArrayRef<StringRef> Clobbers,
+                            ArrayRef<StringRef> BranchTargets,
+                            ArrayRef<StringRef> LabelsDefined,
                             ArrayRef<Expr*> Exprs,
                             SourceLocation EndLoc);
   LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
                                    SourceLocation Location,
                                    bool AlwaysCreate);
 
   VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
                                   SourceLocation StartLoc,

lib/AST/Stmt.cpp

 }
 
 MSAsmStmt::MSAsmStmt(const ASTContext &C, SourceLocation asmloc,
                      SourceLocation lbraceloc, bool issimple, bool isvolatile,
                      ArrayRef<Token> asmtoks, unsigned numoutputs,
                      unsigned numinputs,
                      ArrayRef<StringRef> constraints, ArrayRef<Expr*> exprs,
                      StringRef asmstr, ArrayRef<StringRef> clobbers,
-                     SourceLocation endloc)
+                     ArrayRef<StringRef> branchTargets,
+                     ArrayRef<StringRef> labelsDefined, SourceLocation endloc)
   : AsmStmt(MSAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
             numinputs, clobbers.size()), LBraceLoc(lbraceloc),
-            EndLoc(endloc), NumAsmToks(asmtoks.size()) {
+            EndLoc(endloc), NumAsmToks(asmtoks.size()),
+            NumBranchTargets(branchTargets.size()),
+            NumLabelsDefined(labelsDefined.size()) {
 
-  initialize(C, asmstr, asmtoks, constraints, exprs, clobbers);
+  initialize(C, asmstr, asmtoks, constraints, exprs, clobbers,
+             branchTargets, labelsDefined);
 }
 
 static StringRef copyIntoContext(const ASTContext &C, StringRef str) {
   size_t size = str.size();
   char *buffer = new (C) char[size];
   memcpy(buffer, str.data(), size);
   return StringRef(buffer, size);
 }
 
 void MSAsmStmt::initialize(const ASTContext &C, StringRef asmstr,
                            ArrayRef<Token> asmtoks,
                            ArrayRef<StringRef> constraints,
                            ArrayRef<Expr*> exprs,
-                           ArrayRef<StringRef> clobbers) {
+                           ArrayRef<StringRef> clobbers,
+                           ArrayRef<StringRef> branchTargets,
+                           ArrayRef<StringRef> labelsDefined) {
   assert(NumAsmToks == asmtoks.size());
   assert(NumClobbers == clobbers.size());
+  assert(NumBranchTargets == branchTargets.size());
+  assert(NumLabelsDefined == labelsDefined.size());
 
   unsigned NumExprs = exprs.size();
   assert(NumExprs == NumOutputs + NumInputs);
   assert(NumExprs == constraints.size());
 
   AsmStr = copyIntoContext(C, asmstr);
 
   Exprs = new (C) Stmt*[NumExprs];
for (unsigned i = 0, e = NumExprs; i != e; ++i) {
     Constraints[i] = copyIntoContext(C, constraints[i]);
   }
 
   Clobbers = new (C) StringRef[NumClobbers];
   for (unsigned i = 0, e = NumClobbers; i != e; ++i) {
     // FIXME: Avoid the allocation/copy if at all possible.
     Clobbers[i] = copyIntoContext(C, clobbers[i]);
   }
+
+  BranchTargets = new (C) StringRef[NumBranchTargets];
+  for (unsigned i = 0, e = NumBranchTargets; i != e; ++i) {
+    // FIXME: Avoid the allocation/copy if at all possible.
+    BranchTargets[i] = copyIntoContext(C, branchTargets[i]);
+  }
+
+  LabelsDefined = new (C) StringRef[NumLabelsDefined];
+  for (unsigned i = 0, e = NumLabelsDefined; i != e; ++i) {
+    // FIXME: Avoid the allocation/copy if at all possible.
+    LabelsDefined[i] = copyIntoContext(C, labelsDefined[i]);
+  }
 }
 
 ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
                                              Stmt *Body,  SourceLocation FCL,
                                              SourceLocation RPL)
 : Stmt(ObjCForCollectionStmtClass) {
   SubExprs[ELEM] = Elem;
   SubExprs[COLLECTION] = Collect;

lib/Parse/ParseStmtAsm.cpp

if (BraceNesting && BraceCount != savedBraceCount) {
     Diag(Tok, diag::err_expected) << tok::l_brace;
     return StmtError();
   }
 
   // Okay, prepare to use MC to parse the assembly.
   SmallVector<StringRef, 4> ConstraintRefs;
   SmallVector<Expr *, 4> Exprs;
   SmallVector<StringRef, 4> ClobberRefs;
+  SmallVector<StringRef, 4> BranchTargetRefs;
+  SmallVector<StringRef, 4> LabelsDefinedRefs;
 
   // We need an actual supported target.
   const llvm::Triple &TheTriple = Actions.Context.getTargetInfo().getTriple();
   llvm::Triple::ArchType ArchTy = TheTriple.getArch();
   const std::string &TT = TheTriple.getTriple();
   const llvm::Target *TheTarget = nullptr;
   bool UnsupportedArch =
       (ArchTy != llvm::Triple::x86 && ArchTy != llvm::Triple::x86_64);
   if (UnsupportedArch) {
     Diag(AsmLoc, diag::err_msasm_unsupported_arch) << TheTriple.getArchName();
   } else {
     std::string Error;
     TheTarget = llvm::TargetRegistry::lookupTarget(TT, Error);
     if (!TheTarget)
       Diag(AsmLoc, diag::err_msasm_unable_to_create_target) << Error;
   }
 
   assert(!LBraceLocs.empty() && "Should have at least one location here");
 
   // If we don't support assembly, or the assembly is empty, we don't
   // need to instantiate the AsmParser, etc.
   if (!TheTarget || AsmToks.empty()) {
     return Actions.ActOnMSAsmStmt(AsmLoc, LBraceLocs[0], AsmToks, StringRef(),
                                   /*NumOutputs*/ 0, /*NumInputs*/ 0,
-                                  ConstraintRefs, ClobberRefs, Exprs, EndLoc);
+                                  ConstraintRefs, ClobberRefs, BranchTargetRefs,
+                                  LabelsDefinedRefs, Exprs, EndLoc);
   }
 
   // Expand the tokens into a string buffer.
   SmallString<512> AsmString;
   SmallVector<unsigned, 8> TokOffsets;
   if (buildMSAsmString(PP, AsmLoc, AsmToks, TokOffsets, AsmString))
     return StmtError();
 
TempSrcMgr.setDiagHandler(ClangAsmParserCallback::DiagHandlerCallback,
                             &Callback);
 
   unsigned NumOutputs;
   unsigned NumInputs;
   std::string AsmStringIR;
   SmallVector<std::pair<void *, bool>, 4> OpExprs;
   SmallVector<std::string, 4> Constraints;
   SmallVector<std::string, 4> Clobbers;
+  SmallVector<std::string, 4> BranchTargets;
+  SmallVector<std::string, 4> LabelsDefined;
   if (Parser->parseMSInlineAsm(AsmLoc.getPtrEncoding(), AsmStringIR, NumOutputs,
                                NumInputs, OpExprs, Constraints, Clobbers,
-                               MII.get(), IP.get(), Callback))
+                               BranchTargets, LabelsDefined, MII.get(), IP.get(),
+                               Callback))
     return StmtError();
 
   // Filter out "fpsw".  Clang doesn't accept it, and it always lists flags and
   // fpsr as clobbers.
   auto End = std::remove(Clobbers.begin(), Clobbers.end(), "fpsw");
   Clobbers.erase(End, Clobbers.end());
 
   // Build the vector of clobber StringRefs.
   ClobberRefs.insert(ClobberRefs.end(), Clobbers.begin(), Clobbers.end());
+  BranchTargetRefs.insert(BranchTargetRefs.end(), BranchTargets.begin(), BranchTargets.end());
+  LabelsDefinedRefs.insert(LabelsDefinedRefs.end(), LabelsDefined.begin(), LabelsDefined.end());
 
   // Recast the void pointers and build the vector of constraint StringRefs.
   unsigned NumExprs = NumOutputs + NumInputs;
   ConstraintRefs.resize(NumExprs);
   Exprs.resize(NumExprs);
   for (unsigned i = 0, e = NumExprs; i != e; ++i) {
     Expr *OpExpr = static_cast<Expr *>(OpExprs[i].first);
     if (!OpExpr)
       return StmtError();
 
     // Need address of variable.
     if (OpExprs[i].second)
       OpExpr =
           Actions.BuildUnaryOp(getCurScope(), AsmLoc, UO_AddrOf, OpExpr).get();
 
     ConstraintRefs[i] = StringRef(Constraints[i]);
     Exprs[i] = OpExpr;
   }
 
   // FIXME: We should be passing source locations for better diagnostics.
   return Actions.ActOnMSAsmStmt(AsmLoc, LBraceLocs[0], AsmToks, AsmStringIR,
                                 NumOutputs, NumInputs, ConstraintRefs,
-                                ClobberRefs, Exprs, EndLoc);
+                                ClobberRefs, BranchTargetRefs,
+                                LabelsDefinedRefs, Exprs, EndLoc);
 }
 
 /// ParseAsmStatement - Parse a GNU extended asm statement.
 ///       asm-statement:
 ///         gnu-asm-statement
 ///         ms-asm-statement
 ///
 /// [GNU] gnu-asm-statement:

lib/Sema/JumpDiagnostics.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Sema/SemaInternal.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
+#include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/BitVector.h"
 using namespace clang;
 
 namespace {
 
 /// JumpScopeChecker - This object is used by Sema to diagnose invalid jumps
 /// into VLA and other protected scopes.  For example, this rejects:
 ///    goto L;
private:
   void VerifyIndirectJumps();
   void NoteJumpIntoScopes(ArrayRef<unsigned> ToScopes);
   void DiagnoseIndirectJump(IndirectGotoStmt *IG, unsigned IGScope,
                             LabelDecl *Target, unsigned TargetScope);
   void CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
                  unsigned JumpDiag, unsigned JumpDiagWarning,
                  unsigned JumpDiagCXX98Compat);
   void CheckGotoStmt(GotoStmt *GS);
+  void CheckMSAsmStmt(MSAsmStmt *AsmStmt,
+                      const std::map<StringRef, MSAsmStmt*> &LabelProvider);
 
   unsigned GetDeepestCommonScope(unsigned A, unsigned B);
 };
 } // end anonymous namespace
 
 #define CHECK_PERMISSIVE(x) (assert(Permissive || !(x)), (Permissive && (x)))
 
 JumpScopeChecker::JumpScopeChecker(Stmt *Body, Sema &s)
void JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {
       
   case Stmt::GotoStmtClass:
     // Remember both what scope a goto is in as well as the fact that we have
     // it.  This makes the second scan not have to walk the AST again.
     LabelAndGotoScopes[S] = ParentScope;
     Jumps.push_back(S);
     break;
 
+  case Stmt::MSAsmStmtClass:
+    // Verify possible jumps from within MS inline asm blocks.
+    Jumps.push_back(S);
+    break;
+
   case Stmt::CXXTryStmtClass: {
     CXXTryStmt *TS = cast<CXXTryStmt>(S);
     unsigned newParentScope;
     Scopes.push_back(GotoScope(ParentScope,
                                diag::note_protected_by_cxx_try,
                                diag::note_exits_cxx_try,
                                TS->getSourceRange().getBegin()));
     if (Stmt *TryBlock = TS->getTryBlock())
for (Stmt::child_range CI = S->children(); CI; ++CI) {
     // Recursively walk the AST.
     BuildScopeInformation(SubStmt, ParentScope);
   }
 }
 
 /// VerifyJumps - Verify each element of the Jumps array to see if they are
 /// valid, emitting diagnostics if not.
 void JumpScopeChecker::VerifyJumps() {
+  std::map<StringRef, MSAsmStmt*> LabelProvider;
+  for (Stmt *J : Jumps) {
+    if (isa<MSAsmStmt>(J)) {
+      for (const auto &L : cast<MSAsmStmt>(J)->getLabelsDefined()) {
+        LabelProvider.insert(std::make_pair(L, cast<MSAsmStmt>(J)));
+      }
+    }
+  }
+
   while (!Jumps.empty()) {
     Stmt *Jump = Jumps.pop_back_val();
 
     // With a goto,
     if (GotoStmt *GS = dyn_cast<GotoStmt>(Jump)) {
       // The label may not have a statement if it's coming from inline MS ASM.
       if (GS->getLabel()->getStmt()) {
         CheckJump(GS, GS->getLabel()->getStmt(), GS->getGotoLoc(),
if (IndirectGotoStmt *IGS = dyn_cast<IndirectGotoStmt>(Jump)) {
       LabelDecl *Target = IGS->getConstantTarget();
       CheckJump(IGS, Target->getStmt(), IGS->getGotoLoc(),
                 diag::err_goto_into_protected_scope,
                 diag::ext_goto_into_protected_scope,
                 diag::warn_cxx98_compat_goto_into_protected_scope);
       continue;
     }
 
+    if (MSAsmStmt *AsmStmt = dyn_cast<MSAsmStmt>(Jump)) {
+      CheckMSAsmStmt(AsmStmt, LabelProvider);
+      continue;
+    }
+
     SwitchStmt *SS = cast<SwitchStmt>(Jump);
     for (SwitchCase *SC = SS->getSwitchCaseList(); SC;
          SC = SC->getNextSwitchCase()) {
       if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(SC)))
         continue;
       SourceLocation Loc;
       if (CaseStmt *CS = dyn_cast<CaseStmt>(SC))
         Loc = CS->getLocStart();
void JumpScopeChecker::CheckGotoStmt(GotoStmt *GS) {
   if (GS->getLabel()->isMSAsmLabel()) {
     S.Diag(GS->getGotoLoc(), diag::err_goto_ms_asm_label)
         << GS->getLabel()->getIdentifier();
     S.Diag(GS->getLabel()->getLocation(), diag::note_goto_ms_asm_label)
         << GS->getLabel()->getIdentifier();
   }
 }
 
+void JumpScopeChecker::CheckMSAsmStmt(MSAsmStmt *AsmStmt,
+    const std::map<StringRef, MSAsmStmt*> &LabelProvider) {
+  for (const auto &BT : AsmStmt->getBranchTargets()) {
+    const auto &LabelProviderStmt = LabelProvider.find(BT);
+    if (LabelProviderStmt != LabelProvider.end() &&
+        LabelProviderStmt->second != AsmStmt) {
+      S.Diag(AsmStmt->getLocStart(), diag::err_cross_block_asm_jump)
+          << S.getPreprocessor().getIdentifierInfo(BT);
+      S.Diag(LabelProviderStmt->second->getLocStart(), diag::note_cross_block_asm_jump)
+          << S.getPreprocessor().getIdentifierInfo(BT);
+    }
+  }
+}
+
 void Sema::DiagnoseInvalidJumps(Stmt *Body) {
   (void)JumpScopeChecker(Body, *this);
 }

lib/Sema/SemaStmtAsm.cpp

 }
 
 StmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
                                 ArrayRef<Token> AsmToks,
                                 StringRef AsmString,
                                 unsigned NumOutputs, unsigned NumInputs,
                                 ArrayRef<StringRef> Constraints,
                                 ArrayRef<StringRef> Clobbers,
+                                ArrayRef<StringRef> BranchTargets,
+                                ArrayRef<StringRef> LabelsDefined,
                                 ArrayRef<Expr*> Exprs,
                                 SourceLocation EndLoc) {
   bool IsSimple = (NumOutputs != 0 || NumInputs != 0);
   getCurFunction()->setHasBranchProtectedScope();
   MSAsmStmt *NS =
     new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, IsSimple,
                             /*IsVolatile*/ true, AsmToks, NumOutputs, NumInputs,
                             Constraints, Exprs, AsmString,
-                            Clobbers, EndLoc);
+                            Clobbers, BranchTargets, LabelsDefined, EndLoc);
   return NS;
 }
 
 LabelDecl *Sema::GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
                                        SourceLocation Location,
                                        bool AlwaysCreate) {
   LabelDecl* Label = LookupOrCreateLabel(PP.getIdentifierInfo(ExternalLabelName),
                                          Location);
 
   if (!Label->isMSAsmLabel()) {
     // Otherwise, insert it, but only resolve it if we have seen the label itself.
     std::string InternalName;
     llvm::raw_string_ostream OS(InternalName);
     // Create an internal name for the label.  The name should not be a valid mangled
     // name, and should be unique.  We use a dot to make the name an invalid mangled
     // name.
     OS << "__MSASMLABEL_." << MSAsmLabelNameCounter++ << "__" << ExternalLabelName;
     Label->setMSAsmLabel(OS.str());
+    // We need to check possible cross inline MS asm block jumps when we encounter an
+    // MS asm label being defined.
+    getCurFunction()->setHasIndirectGoto();
   }
   if (AlwaysCreate) {
     // The label might have been created implicitly from a previously encountered
     // goto statement.  So, for both newly created and looked up labels, we mark
     // them as resolved.
     Label->setMSAsmLabelResolved();
   }
   // Adjust their location for being able to generate accurate diagnostics.
   Label->setLocation(Location);
 
   return Label;
 }

lib/Sema/TreeTransform.h

#include "clang/Basic/OpenMPKinds.def"
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
                               ArrayRef<Token> AsmToks,
                               StringRef AsmString,
                               unsigned NumOutputs, unsigned NumInputs,
                               ArrayRef<StringRef> Constraints,
                               ArrayRef<StringRef> Clobbers,
+                              ArrayRef<StringRef> BranchTargets,
+                              ArrayRef<StringRef> LabelsDefined,
                               ArrayRef<Expr*> Exprs,
                               SourceLocation EndLoc) {
     return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
                                     NumOutputs, NumInputs,
-                                    Constraints, Clobbers, Exprs, EndLoc);
+                                    Constraints, Clobbers, BranchTargets,
+                                    LabelsDefined, Exprs, EndLoc);
   }
 
   /// \brief Build a new Objective-C \@try statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
                                         Stmt *TryBody,
TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
   if (HadError) return StmtError();
   if (!HadChange && !getDerived().AlwaysRebuild())
     return Owned(S);
 
   return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
                                        AsmToks, S->getAsmString(),
                                        S->getNumOutputs(), S->getNumInputs(),
                                        S->getAllConstraints(), S->getClobbers(),
+                                       S->getBranchTargets(),
+                                       S->getLabelsDefined(),
                                        TransformedExprs, S->getEndLoc());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
   // Transform the body of the @try.
   StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());

lib/Serialization/ASTReaderStmt.cpp

for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
     Clobbers.push_back(ClobbersData.back());
   }
 
   // Read the operands.
   unsigned NumOperands = S->NumOutputs + S->NumInputs;
   SmallVector<Expr*, 16> Exprs;
   SmallVector<std::string, 16> ConstraintsData;
   SmallVector<StringRef, 16> Constraints;
+  SmallVector<StringRef, 16> BranchTargets;
+  SmallVector<StringRef, 16> LabelsDefined;
   Exprs.reserve(NumOperands);
   ConstraintsData.reserve(NumOperands);
   Constraints.reserve(NumOperands);
   for (unsigned i = 0; i != NumOperands; ++i) {
     Exprs.push_back(cast<Expr>(Reader.ReadSubStmt()));
     ConstraintsData.push_back(ReadString(Record, Idx));
     Constraints.push_back(ConstraintsData.back());
   }
 
   S->initialize(Reader.getContext(), AsmStr, AsmToks,
-                Constraints, Exprs, Clobbers);
+                Constraints, Exprs, Clobbers, BranchTargets,
+                LabelsDefined);
 }
 
 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
   VisitStmt(S);
   ++Idx;
   S->setCapturedDecl(ReadDeclAs<CapturedDecl>(Record, Idx));
   S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record[Idx++]));
   S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>(Record, Idx));

test/Parser/ms-inline-asm.c

void t10() {
   }
 }
 void t11() {
   do { __asm mov eax, 0 __asm { __asm mov edx, 1 } } while(0);
 }
 void t12() {
   __asm jmp label // expected-error {{use of undeclared label 'label'}}
 }
+void t13() {
+  __asm { // expected-error {{cannot jump from one inline assembly block to label 'lbl1' defined inside another one}}
+    jmp lbl1;
+  }
+  __asm { // expected-note {{label 'lbl1' defined in an inline assembly block defined here}}
+    lbl1:
+    nop
+  }
+}
+void t14() {
+  __asm { // expected-error {{cannot jump from one inline assembly block to label 'lbl2' defined inside another one}}
+    jmp lbl2;
+  }
+  for (;;) {
+    __asm { // expected-note {{label 'lbl2' defined in an inline assembly block defined here}}
+      lbl2:
+      nop
+    }
+  }
+}
+void t15() {
+  for (;;) {
+    __asm { // expected-error {{cannot jump from one inline assembly block to label 'lbl2' defined inside another one}}
+      jmp lbl2;
+    }
+  }
+  __asm { // expected-note {{label 'lbl2' defined in an inline assembly block defined here}}
+    lbl2:
+    nop
+  }
+}
 int t_fail() { // expected-note {{to match this}}
   __asm 
   __asm { // expected-error 2 {{expected}} expected-note {{to match this}}