[RFC prototype] Implementation of asm-goto support in clang

[jyu2]

Summary

This patch accompanies the RFC posted here:
http://lists.llvm.org/pipermail/llvm-dev/2018-October/127239.html

This is the clang side. The llvm version is in D53765

[jyu2]

Change error message.

[nickdesaulniers]

Also of note: glib, a super popular library used across many Linux distro's will benefit from the implementation of asm goto (I will send them a patch to fix their version detection once we land in Clang): https://github.com/GNOME/glib/blob/1ba843b8a0585f20438d5617521f247071c6d94c/glib/gbitlock.c#L181

[jyu2]

Change test for BE IR change.

[craig.topper]

Commandeering so I can update to match an IRBuilder interface change in the llvm patch

[craig.topper]

Pass FunctionType into the IRBuilder::CreateCallBr to avoid needing to make an opaque pointer update later

[rsmith]

include/clang/AST/Stmt.h

997

Ugh. This cast violates strict aliasing, and even in the absence of strict aliasing won't work unless the Stmt base class is at offset 0 in T. The preceding assert is also wrong, as it's asserting that *I is an Expr, not that it's a T.

After r352925, you can use CastIterator<AddrLabelExpr> instead; that should substantially reduce the churn in this patch.

2840

This is already inside a class GCCAsmStmt; the GCC here seems unnecessary.

2858

Please give this a better name; getExpr is pretty meaningless.

lib/Analysis/CFG.cpp

1460

If this happens for every iteration of the loop, VD is used uninitialized after the loop.

1466

It is extremely suspicious to be overwriting the value of VD on each iteration of the loop like this. If you are assuming that the same value will be returned every time, please include an assert of that.

2121

This is not an appropriate function name for a function that is only called on asm goto. Given the convention here is to match the Stmt class hierarchy with the Visit functions, the branch on asm goto should be in the callee.

lib/CodeGen/CGStmt.cpp

1893

This is not a reasonable function name for a function that is specific to AsmStmts. Please also make this a (static) non-member function, since it cannot be called outside this source file.

2246–2253

No need to explicitly specify the template argument here; it's deducible.

lib/Parse/ParseStmtAsm.cpp

833–837

This should be inside the loop below.

839

while (true)

[efriedma]

lib/Analysis/CFG.cpp

3130

Passing add_successor=false seems suspect; this could probably use more test coverage.

lib/CodeGen/CGStmt.cpp

1893

Does this really need to be a template function? I think all the functions you're calling on "Result" are members of CallBase.

2197

The NumGccAsmGotoStmts variable is pointless; if names are enabled, createBasicBlock will automatically number all the blocks named "normal".

2199

Before the clobbers? I don't see the relationship; the clobbers are just a string.

Granted, it does need to be before we compute the type, which is shared code.

test/Parser/asm-goto.c

1 ↗

(On Diff #184447)

What is this testing?

[efriedma]

Forgot about protected scopes...

This patch is missing code and testcases for JumpScopeChecker. (The behavior should be roughly equivalent to what we do for indirect goto.)

[jyu2]

lib/Analysis/CFG.cpp

2121

Changed.

lib/CodeGen/CGStmt.cpp

1893

How about UpdateAsmCallInst?

1893

Yes. I am using CallBase instead template.

2197

Okay changed. Thanks.

2246–2253

Thanks. Changed.

lib/Parse/ParseStmtAsm.cpp

833–837

Yes. Change.

test/Parser/asm-goto.c

1 ↗

(On Diff #184447)

Just testing asm goto can parser those input operands and labels. Not error checking.

Error checking is in Sema/asm-goto

[jyu2]

1> Add code for scope checking
2> Using CastInterator
3> CFG change to remove duplicate Block list

[jyu2]

include/clang/AST/Stmt.h

997

Hi Richard,
Thanks for explain for this. And thank you so much for proving CastIterator!! I change the code to use this.

2840

Remove GCC

2858

should I change to getOperandExpr?
Thanks.

lib/Analysis/CFG.cpp

1460

I am totally wrong. Changed

1467

I did this during in VisitGCCAsmStmt by not call addSuccessor when we need backpatch the the labels.

lib/Parse/ParseStmtAsm.cpp

839

Yes. Changed.
Thanks.

[efriedma]

lib/Sema/JumpDiagnostics.cpp

350

This doesn't look right; I think we need to add it to IndirectJumps instead. This probably impacts a testcase like the following:

struct S { ~S(); };
int f() {
  {
    S s;
    asm goto(""::::BAR);
    return 1;
  }
BAR:
  return 0;
}

(gcc currently accepts this and skips running the destructor, but I'm pretty sure that's a bug.)

[jyu2]

lib/Sema/JumpDiagnostics.cpp

350

Hi Eli,
I see both g++ and clang++ with my change call ~S. Am I missing something? Thanks.

1>clang++ j.cpp
1>./a.out
~S()
1>g++ j.cpp
1>./a.out
~S()

Here is the test case:
1>cat j.cpp
extern "C" int printf (const char *,...);
struct S { ~S() {printf("~S()\n");}; };
int f() {

{
  S s;
  asm goto(""::::BAR);
  return 1;
}

BAR:

return 0;

}

int main()
{

f();

}

[rsmith]

lib/AST/Stmt.cpp

470–475

Please assert that you don't have both outputs and labels here. (If you did, you would assign them the same slots within Exprs.)

You also seem to be missing Sema enforcement of the rule that you cannot have both outputs and labels. (If you want to actually support that as an intentional extension to the GCC functionality, you should change the implementation of GCCAsmStmt to use different slots for outputs and labels, add some tests, and add a -Wgcc-compat warning for that case. Seems better to just add an error for it for now.)

lib/Analysis/CFG.cpp

1444–1457

Please factor out this duplicated code into a local lambda rather than copy-pasting it.

1455

This check is redundant; there will be no labels if it's not an asm goto so you can just perform the below loop unconditionally.

3138–3140

Do we not need the handling for the other labels if we hit this condition for one label?

lib/Sema/SemaStmtAsm.cpp

665

No space after pair, please.

668–671

Looping over all three lists of expressions here is effectively hardcoding an implementation detail of GCCAsmStmt into this code, violating its encapsulation. Instead, please write three loops (iterating over the inputs, outputs, and labels), and remove getOperandExpr entirely.

669

Checking whether the name is empty is redundant: we should never create an IdentifierInfo representing an empty string.

[efriedma]

lib/Sema/JumpDiagnostics.cpp

350

Oh, sorry, I wasn't paying attention to the actual contents of the asm. If you modify the asm goto slightly, to asm goto("jmp %0"::::BAR);, you'll see that the destructor doesn't run, at least with gcc. (This is different from the way goto BAR; works.)

[jyu2]

More review comments addressed.

[jyu2]

lib/AST/Stmt.cpp

470–475

This is enforcement during the parer.

for example:
a.c:12:23: error: expected ':'
asm goto ("decl %0;" :"a": "m"(cond) : "memory" );

Do you think this is enough for now?
Thanks.
Jennifer

lib/Analysis/CFG.cpp

1444–1457

Thanks. Changed.

1455

Okay removed. Thanks.

3138–3140

It is handled in backpatch processing which go though each label and build CFG.

lib/Sema/JumpDiagnostics.cpp

350

Thanks. I see, the cleanup code is not generated for asm goto.

For clang with our current implementation, llvm emit error for this. But the error message isn't clear.

You are right, we should emit error in clang. I will look into tomorrow.

Thanks.

lib/Sema/SemaStmtAsm.cpp

665

Sorry, changed.

668–671

changed.

669

Changed. Thanks.

[rsmith]

lib/AST/Stmt.cpp

470–475

Thanks, I see it now. Please still add the assert here.

I'd also like a custom diagnostic for that parse error; it'd seem easy and useful to add an "asm goto cannot have output constraints" error.

[craig.topper]

lib/CodeGen/CGStmt.cpp

2245

I don't think we need to pass FTy here now. I made that change before @jyknight added FunctionCallee that should be able to find the type from the InlineAsm. The CallBr IRBuilder code should have a FunctionCallee Create function as of yesterday.

[jyu2]

1>emit better error for use of output constraints.
2> Add assert for NumLabels and NumOutputs are both larger than 0.

[jyu2]

lib/AST/Stmt.cpp

470–475

Okay added.

lib/CodeGen/CGStmt.cpp

2245

Removed.

[rsmith]

lib/AST/Stmt.cpp

474–475

This can be simplified a little:

assert(!(NumOutputs && NumLabels) && "asm goto cannot have outputs");

639

N < NumOperands - getNumLabels()

641

I'm curious why we're checking this here, when all the other validation for the modifier letter happens in LLVM. Does this check need to be done differently from the others?

lib/CodeGen/CGStmt.cpp

2195

Nit: I think something like "asm.fallthrough" or "asm.cont" would be a more obvious name for the fall-through block.

lib/Sema/SemaStmtAsm.cpp

668–680

This is still exposing / relying on an implementation detail of GCCAsmStmt. Please replace getIdentifier with getOuptutIdentifier / getInputIdentifier / getLabelIdentifier, adjust the indexing to match, and remove GCCAsmStmt::getIdentifier. Or alternatively, iterate over Names here rather than walking the parts of the GCCAsmStmt.

[jyu2]

More change from review.

Add scope checking for asm-goto.

[jyu2]

lib/AST/Stmt.cpp

474–475

Thanks. Yes, this is better than me. Changed

641

This is to verify following in spec:

To reference a label in the assembler template, prefix it with ‘%l’ (lowercase ‘L’) followed by its (zero-based) position in GotoLabels plus the number of input operands. For example, if the asm has three inputs and references two labels, refer to the first label as ‘%l3’ and the second as ‘%l4’).

Was request from Eli.

lib/CodeGen/CGStmt.cpp

2195

Changed.

lib/Sema/SemaStmtAsm.cpp

668–680

Changed. Like this!!!

[jyu2]

small fix.

[kees]

Not sure if this is the fault of the LLVM half or the Clang half, but I'm seeing mis-compilations in the current patches (llvm ca1e713fdd4fab5273b36ba6f292a844fca4cb2d with D53765.185490 and clang 01879634f01bdbfac4636ebe03b68e85b20cd664 with D56571.185489). My earlier builds were okay (llvm b1650507d25d28a03f30626843b7b133796597b4 with D53765.183738 and clang 61738985ebe78eeff6cfae7f97543d3456bac25a with D56571.181973).

I narrowed the failure down to the kernel's move_addr_to_user() function:

static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,
                             void __user *uaddr, int __user *ulen)
{
        int err;
        int len;

        BUG_ON(klen > sizeof(struct sockaddr_storage));
        err = get_user(len, ulen);
        if (err)
                return err;
        if (len > klen)
                len = klen;
        if (len < 0)
                return -EINVAL;
        if (len) {
                if (audit_sockaddr(klen, kaddr))
                        return -ENOMEM;
                if (copy_to_user(uaddr, kaddr, len))
                        return -EFAULT;
        }
        return __put_user(klen, ulen);
}

Working build produces:

ffffffff81c217a0 <move_addr_to_user>:
ffffffff81c217a0:       e8 5b fc 3d 00          callq  ffffffff82001400 <__fentry__>
ffffffff81c217a5:       81 fe 81 00 00 00       cmp    $0x81,%esi
ffffffff81c217ab:       0f 83 c8 00 00 00       jae    ffffffff81c21879 <move_addr_to_user+0xd9>
ffffffff81c217b1:       55                      push   %rbp
ffffffff81c217b2:       48 89 e5                mov    %rsp,%rbp
ffffffff81c217b5:       41 57                   push   %r15
ffffffff81c217b7:       41 56                   push   %r14
ffffffff81c217b9:       41 55                   push   %r13
ffffffff81c217bb:       41 54                   push   %r12
ffffffff81c217bd:       53                      push   %rbx
ffffffff81c217be:       49 89 ce                mov    %rcx,%r14
ffffffff81c217c1:       49 89 d7                mov    %rdx,%r15
ffffffff81c217c4:       41 89 f5                mov    %esi,%r13d
ffffffff81c217c7:       49 89 fc                mov    %rdi,%r12
ffffffff81c217ca:       48 c7 c7 36 35 88 82    mov    $0xffffffff82883536,%rdi
ffffffff81c217d1:       be da 00 00 00          mov    $0xda,%esi
ffffffff81c217d6:       e8 25 8b 5c ff          callq  ffffffff811ea300 <__might_fault>
ffffffff81c217db:       4c 89 f0                mov    %r14,%rax
ffffffff81c217de:       e8 2d f6 2f 00          callq  ffffffff81f20e10 <__get_user_4>
ffffffff81c217e3:       85 c0                   test   %eax,%eax
ffffffff81c217e5:       75 68                   jne    ffffffff81c2184f <move_addr_to_user+0xaf>
ffffffff81c217e7:       48 89 d3                mov    %rdx,%rbx
ffffffff81c217ea:       44 39 eb                cmp    %r13d,%ebx
ffffffff81c217ed:       41 0f 4f dd             cmovg  %r13d,%ebx
ffffffff81c217f1:       85 db                   test   %ebx,%ebx
ffffffff81c217f3:       78 65                   js     ffffffff81c2185a <move_addr_to_user+0xba>
ffffffff81c217f5:       74 48                   je     ffffffff81c2183f <move_addr_to_user+0x9f>
ffffffff81c217f7:       65 48 8b 04 25 00 4e    mov    %gs:0x14e00,%rax
ffffffff81c217fe:       01 00 
ffffffff81c21800:       48 8b 80 38 07 00 00    mov    0x738(%rax),%rax
ffffffff81c21807:       48 85 c0                test   %rax,%rax
ffffffff81c2180a:       74 05                   je     ffffffff81c21811 <move_addr_to_user+0x71>
ffffffff81c2180c:       83 38 00                cmpl   $0x0,(%rax)
ffffffff81c2180f:       74 50                   je     ffffffff81c21861 <move_addr_to_user+0xc1>
ffffffff81c21811:       48 63 db                movslq %ebx,%rbx
ffffffff81c21814:       4c 89 e7                mov    %r12,%rdi
ffffffff81c21817:       48 89 de                mov    %rbx,%rsi
ffffffff81c2181a:       ba 01 00 00 00          mov    $0x1,%edx
ffffffff81c2181f:       e8 3c 75 5f ff          callq  ffffffff81218d60 <__check_object_size>
ffffffff81c21824:       4c 89 ff                mov    %r15,%rdi
ffffffff81c21827:       4c 89 e6                mov    %r12,%rsi
ffffffff81c2182a:       48 89 da                mov    %rbx,%rdx
ffffffff81c2182d:       e8 ae 84 99 ff          callq  ffffffff815b9ce0 <_copy_to_user>
ffffffff81c21832:       48 89 c1                mov    %rax,%rcx
ffffffff81c21835:       b8 f2 ff ff ff          mov    $0xfffffff2,%eax
ffffffff81c2183a:       48 85 c9                test   %rcx,%rcx
ffffffff81c2183d:       75 10                   jne    ffffffff81c2184f <move_addr_to_user+0xaf>
ffffffff81c2183f:       90                      nop
ffffffff81c21840:       90                      nop
ffffffff81c21841:       90                      nop
ffffffff81c21842:       b8 f2 ff ff ff          mov    $0xfffffff2,%eax
ffffffff81c21847:       45 89 2e                mov    %r13d,(%r14)
ffffffff81c2184a:       31 c0                   xor    %eax,%eax
ffffffff81c2184c:       90                      nop
ffffffff81c2184d:       90                      nop
ffffffff81c2184e:       90                      nop
ffffffff81c2184f:       5b                      pop    %rbx
ffffffff81c21850:       41 5c                   pop    %r12
ffffffff81c21852:       41 5d                   pop    %r13
ffffffff81c21854:       41 5e                   pop    %r14
ffffffff81c21856:       41 5f                   pop    %r15
ffffffff81c21858:       5d                      pop    %rbp
ffffffff81c21859:       c3                      retq   
ffffffff81c2185a:       b8 ea ff ff ff          mov    $0xffffffea,%eax
ffffffff81c2185f:       eb ee                   jmp    ffffffff81c2184f <move_addr_to_user+0xaf>
ffffffff81c21861:       44 89 ef                mov    %r13d,%edi
ffffffff81c21864:       4c 89 e6                mov    %r12,%rsi
ffffffff81c21867:       e8 f4 1c 52 ff          callq  ffffffff81143560 <__audit_sockaddr>
ffffffff81c2186c:       89 c1                   mov    %eax,%ecx
ffffffff81c2186e:       b8 f4 ff ff ff          mov    $0xfffffff4,%eax
ffffffff81c21873:       85 c9                   test   %ecx,%ecx
ffffffff81c21875:       75 d8                   jne    ffffffff81c2184f <move_addr_to_user+0xaf>
ffffffff81c21877:       eb 98                   jmp    ffffffff81c21811 <move_addr_to_user+0x71>
ffffffff81c21879:       0f 0b                   ud2    
ffffffff81c2187b:       0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)

The bad compilation produces:

ffffffff81c21700 <move_addr_to_user>:
ffffffff81c21700:       e8 fb fc 3d 00          callq  ffffffff82001400 <__fentry__>
ffffffff81c21705:       81 fe 81 00 00 00       cmp    $0x81,%esi
ffffffff81c2170b:       0f 83 cc 00 00 00       jae    ffffffff81c217dd <move_addr_to_user+0xdd>
ffffffff81c21711:       55                      push   %rbp
ffffffff81c21712:       48 89 e5                mov    %rsp,%rbp
ffffffff81c21715:       41 57                   push   %r15
ffffffff81c21717:       41 56                   push   %r14
ffffffff81c21719:       41 55                   push   %r13
ffffffff81c2171b:       41 54                   push   %r12
ffffffff81c2171d:       53                      push   %rbx
ffffffff81c2171e:       49 89 ce                mov    %rcx,%r14
ffffffff81c21721:       49 89 d7                mov    %rdx,%r15
ffffffff81c21724:       41 89 f5                mov    %esi,%r13d
ffffffff81c21727:       49 89 fc                mov    %rdi,%r12
ffffffff81c2172a:       48 c7 c7 36 35 88 82    mov    $0xffffffff82883536,%rdi
ffffffff81c21731:       be da 00 00 00          mov    $0xda,%esi
ffffffff81c21736:       e8 a5 8b 5c ff          callq  ffffffff811ea2e0 <__might_fault>
ffffffff81c2173b:       4c 89 f0                mov    %r14,%rax
ffffffff81c2173e:       e8 bd f5 2f 00          callq  ffffffff81f20d00 <__get_user_4>
ffffffff81c21743:       85 c0                   test   %eax,%eax
ffffffff81c21745:       0f 85 87 00 00 00       jne    ffffffff81c217d2 <move_addr_to_user+0xd2>
ffffffff81c2174b:       48 89 d3                mov    %rdx,%rbx
ffffffff81c2174e:       44 39 eb                cmp    %r13d,%ebx
ffffffff81c21751:       41 0f 4f dd             cmovg  %r13d,%ebx
ffffffff81c21755:       85 db                   test   %ebx,%ebx
ffffffff81c21757:       78 57                   js     ffffffff81c217b0 <move_addr_to_user+0xb0>
ffffffff81c21759:       74 48                   je     ffffffff81c217a3 <move_addr_to_user+0xa3>
ffffffff81c2175b:       65 48 8b 04 25 00 4e    mov    %gs:0x14e00,%rax
ffffffff81c21762:       01 00 
ffffffff81c21764:       48 8b 80 38 07 00 00    mov    0x738(%rax),%rax
ffffffff81c2176b:       48 85 c0                test   %rax,%rax
ffffffff81c2176e:       74 05                   je     ffffffff81c21775 <move_addr_to_user+0x75>
ffffffff81c21770:       83 38 00                cmpl   $0x0,(%rax)
ffffffff81c21773:       74 42                   je     ffffffff81c217b7 <move_addr_to_user+0xb7>
ffffffff81c21775:       48 63 db                movslq %ebx,%rbx
ffffffff81c21778:       4c 89 e7                mov    %r12,%rdi
ffffffff81c2177b:       48 89 de                mov    %rbx,%rsi
ffffffff81c2177e:       ba 01 00 00 00          mov    $0x1,%edx
ffffffff81c21783:       e8 b8 75 5f ff          callq  ffffffff81218d40 <__check_object_size>
ffffffff81c21788:       4c 89 ff                mov    %r15,%rdi
ffffffff81c2178b:       4c 89 e6                mov    %r12,%rsi
ffffffff81c2178e:       48 89 da                mov    %rbx,%rdx
ffffffff81c21791:       e8 4a 85 99 ff          callq  ffffffff815b9ce0 <_copy_to_user>
ffffffff81c21796:       48 89 c1                mov    %rax,%rcx
ffffffff81c21799:       b8 f2 ff ff ff          mov    $0xfffffff2,%eax
ffffffff81c2179e:       48 85 c9                test   %rcx,%rcx
ffffffff81c217a1:       75 2f                   jne    ffffffff81c217d2 <move_addr_to_user+0xd2>
ffffffff81c217a3:       90                      nop
ffffffff81c217a4:       90                      nop
ffffffff81c217a5:       90                      nop
ffffffff81c217a6:       b8 f2 ff ff ff          mov    $0xfffffff2,%eax
ffffffff81c217ab:       45 89 2e                mov    %r13d,(%r14)
ffffffff81c217ae:       31 c0                   xor    %eax,%eax
ffffffff81c217b0:       b8 ea ff ff ff          mov    $0xffffffea,%eax
ffffffff81c217b5:       eb 1b                   jmp    ffffffff81c217d2 <move_addr_to_user+0xd2>
ffffffff81c217b7:       44 89 ef                mov    %r13d,%edi
ffffffff81c217ba:       4c 89 e6                mov    %r12,%rsi
ffffffff81c217bd:       e8 9e 1d 52 ff          callq  ffffffff81143560 <__audit_sockaddr>
ffffffff81c217c2:       89 c1                   mov    %eax,%ecx
ffffffff81c217c4:       b8 f4 ff ff ff          mov    $0xfffffff4,%eax
ffffffff81c217c9:       85 c9                   test   %ecx,%ecx
ffffffff81c217cb:       75 05                   jne    ffffffff81c217d2 <move_addr_to_user+0xd2>
ffffffff81c217cd:       eb a6                   jmp    ffffffff81c21775 <move_addr_to_user+0x75>
ffffffff81c217cf:       90                      nop
ffffffff81c217d0:       90                      nop
ffffffff81c217d1:       90                      nop
ffffffff81c217d2:       5b                      pop    %rbx
ffffffff81c217d3:       41 5c                   pop    %r12
ffffffff81c217d5:       41 5d                   pop    %r13
ffffffff81c217d7:       41 5e                   pop    %r14
ffffffff81c217d9:       41 5f                   pop    %r15
ffffffff81c217db:       5d                      pop    %rbp
ffffffff81c217dc:       c3                      retq   
ffffffff81c217dd:       0f 0b                   ud2    
ffffffff81c217df:       90                      nop

The bad sequences starts at the je following js (at ffffffff81c217f5 in the good build and at ffffffff81c21759 in bad build). In the good build, the jump leads to:

ffffffff81c2183f:       90                      nop
ffffffff81c21840:       90                      nop
ffffffff81c21841:       90                      nop
ffffffff81c21842:       b8 f2 ff ff ff          mov    $0xfffffff2,%eax
ffffffff81c21847:       45 89 2e                mov    %r13d,(%r14)
ffffffff81c2184a:       31 c0                   xor    %eax,%eax
ffffffff81c2184c:       90                      nop
ffffffff81c2184d:       90                      nop
ffffffff81c2184e:       90                      nop
ffffffff81c2184f:       5b                      pop    %rbx
ffffffff81c21850:       41 5c                   pop    %r12
...

In the bad build, the mov, mov, xor block does not fall through to function exit, instead it overwrites %eax before jumping to function exit:

ffffffff81c217a3:       90                      nop
ffffffff81c217a4:       90                      nop
ffffffff81c217a5:       90                      nop
ffffffff81c217a6:       b8 f2 ff ff ff          mov    $0xfffffff2,%eax
ffffffff81c217ab:       45 89 2e                mov    %r13d,(%r14)
ffffffff81c217ae:       31 c0                   xor    %eax,%eax
ffffffff81c217b0:       b8 ea ff ff ff          mov    $0xffffffea,%eax
ffffffff81c217b5:       eb 1b                   jmp    ffffffff81c217d2 <move_addr_to_user+0xd2>
...
ffffffff81c217d2:       5b                      pop    %rbx
ffffffff81c217d3:       41 5c                   pop    %r12
...

I've not been able to narrow this down further -- most changes to the C code cause the behavior to vanish, so I assume some optimization pass or something is moving things around to avoid the bug.

[kees]

I reduced the C code to this:

volatile int mystery = 0;

static int noinline demo(int klen)
{
        int err;
        int len;

        err = mystery * klen;
        if (err)
                return err;
        if (len > klen)
                len = klen;
        if (len < 0)
                return -EINVAL;
        if (len)
                return -ENOMEM;
        return __put_user(klen, (int __user *)NULL);
}

Something in the compilation of the asm-goto in__put_user() broke here.

[rsmith]

lib/AST/Stmt.cpp

641

Sorry, I think my question was unclear. I understand why you need to do this check somewhere. My question is why this check needs to be *here*, given that all the other checks for the modifier letter are performed elsewhere. Splitting the checks up between multiple locations makes the system harder to maintain.

As it happens, there's a FIXME for this here: http://llvm.org/doxygen/AsmPrinterInlineAsm_8cpp_source.html#l00436 -- and a test case like void f(void *a) { asm("mov %l0, %%eax" :: "r"(a)); } currently causes LLVM to assert in a function that's supposed to be validating these modifier letters and producing a clean error if they're bad. So I think that's an LLVM bug, and fixing that LLVM bug would enforce the property we need here (that %lN only names labels).

[It's not clear to me whether we should be enforcing that %lN only names label operands, which would require the check to be in Clang rather than LLVM; GCC doesn't do that, and for instance accepts

void f() { asm goto("jmp %l0" :: "i"(&&foo)::foo); foo:; }

(at least for x86_64), though this construct doesn't seem hugely useful given that the input operand would need to be a literal address-of-label expression and you'd need to name the target label as a label operand anyway.]

[kees]

In D56571#1386973, @kees wrote:

Not sure if this is the fault of the LLVM half or the Clang half, but I'm seeing mis-compilations in the current patches (llvm ca1e713fdd4fab5273b36ba6f292a844fca4cb2d with D53765.185490 and clang 01879634f01bdbfac4636ebe03b68e85b20cd664 with D56571.185489). My earlier builds were okay (llvm b1650507d25d28a03f30626843b7b133796597b4 with D53765.183738 and clang 61738985ebe78eeff6cfae7f97543d3456bac25a with D56571.181973).

This appears to be fixed with latest llvm, clang, and D53765.185703.

[jyu2]

lib/AST/Stmt.cpp

641

Hi Richard,

Thanks for the detail explanation.
I agree with you. Our compiler FE don't emit error for this also.

I'd happy to remove this, If we all agree.

Hi Eli,
what do you think?

Thanks.
Jennifer

[efriedma]

lib/AST/Stmt.cpp

641

Yes, that's okay.

lib/Analysis/CFG.cpp

3130

Did you ever look at this?

[craig.topper]

lib/AST/Stmt.cpp

641

In the llvm asm-goto patch, I removed the FIXME from AsmPrinterInlineAsm.cpp and set the Error flag if the operand is not an MBB or BlockAddress. This prevents tripping an assert on Richard's case. The error message could probably be better, but at leasts it not a crash on release builds now.

[jyu2]

Remove check for %lN
Fix missing successor of asm goto in CFG build.

lib/Analysis/CFG.cpp

3130

Sorry, I missed this.

Yes. add_successor has to be true, since asm goto is kind of contional goto. I changed.

Thanks.

[nickdesaulniers]

test/CodeGen/asm.c

276

I don't understand why, but this particular test case I cannot compile standalone without -emit-llvm.

int t32(int cond) {
  asm goto("testl %0, %0; jne %l1;" :: "r"(cond)::label_true, loop);
  return 0;
loop:
  return 1;
label_true:
  return 2;
}

$ clang -target x86_64-linux-gnu -emit-llvm -c test.c
$ clang -target x86_64-linux-gnu -c test.c 
test.c:2:12: error: expected a symbol reference
  asm goto("testl %0, %0; jne %l1;" :: "r"(cond)::label_true, loop);
           ^
<inline asm>:1:26: note: instantiated into assembly here
        testl %edi, %edi; jne "";
                                ^
1 error generated.

The produced assembly doesn't seem to contain the jump destination. Am I doing something wrong?

[nickdesaulniers]

test/CodeGen/asm.c

276

ah, need -no-integrated-as.

[jyu2]

I find some ambiguous error for asm-goto out of scope.
Instead call VerifyIndirectOrAsmJumps one time, call that function twice one for indirect-goto one for asm-goto.

Let me know if you see any problems.

Thanks for all the review.
Jennifer

[jyu2]

Cleanup CFG code, remove obj-lifetime code when build CFE for asm-goto.

[efriedma]

I think this is in good shape.

lib/Sema/JumpDiagnostics.cpp

678

Commented-out code?

We probably don't need a diagnostic for an asm goto which doesn't have any labels. If we do, it shouldn't be here.

[jyu2]

Review comment addressed

lib/Sema/JumpDiagnostics.cpp

678

:-(!!!!

Yes, you are right! We don't need a diagnostic for asm goto. The error will be giving during parser. I changed.

Thank you so much for your review.

[rsmith]

lib/AST/StmtProfile.cpp

324

Don't we also need to profile the labels themselves?

lib/Analysis/CFG.cpp

1472

It looks like we're not modeling the destructors for local variables as running on these CFG edges any more. Is that intentional?

lib/Sema/JumpDiagnostics.cpp

810–814

isa<GCCAsmStmt>(Jump)

857–862

Use isa here too.

lib/Sema/SemaStmtAsm.cpp

665–666

MyItemType and MyList aren't useful names for a reader of this code. Please use a better name. Maybe NamedOperand and NamedOperandList?

[jyu2]

Review comments addressed.

[jyu2]

lib/AST/StmtProfile.cpp

324

How this can be lost? :-(

Changed.

lib/Analysis/CFG.cpp

1472

Yes. That it is my intention. Since clean up code are not generated for asm-goto.

lib/Sema/JumpDiagnostics.cpp

810–814

Yes!! changed.

857–862

changed

lib/Sema/SemaStmtAsm.cpp

665–666

Changed.

[jyu2]

Rebase

[nickdesaulniers]

Should the langref be updated (specifically the section on blockaddress):

This value only has defined behavior when used as an operand to the ‘indirectbr’ instruction, or for comparisons against null.

https://reviews.llvm.org/D53765 touched the langref, but I think the blockaddress section can be cleaned up.

[nickdesaulniers]

needs another rebase

[jyu2]

Rebased

[craig.topper]

@rsmith, @efriedma, @chandlerc, is this in good enough shape that we can commit and move to incremental fixes/improvement? Jennifer has had to rebase this a couple times which is making things hard for the folks testing this with the Linux kernel and needing to apply this patch themselves.

[efriedma]

I'm fine merging in this state... but please wait for rsmith to respond before you merge.

[nickdesaulniers]

which is making things hard for the folks testing this with the Linux kernel and needing to apply this patch themselves.

If we can get inlining of callbr working first before landing this, then all of our CI won't go immediately red (as it would from landing this first, then getting inlining support). Otherwise, we'll have to come up with hacks in the kernel to keep the CI green (I have one for x86. The one for aarch64 quickly became infeasible).

I'm anxious for this to land, and the rebases are work indeed. But if we can just wait a little longer and get inlining support working, then land this, it will be much less painful than the other way around.

I'm focused on inlining support in https://reviews.llvm.org/D58260 (which doesn't look like much now, but I have changes locally and have been actively working on it this week).

[nickdesaulniers]

Note that with:

1. https://reviews.llvm.org/D60208 ("[X86] Extend boolean arguments to

inline-asm according to getBooleanType")

2. https://reviews.llvm.org/D58260 ("[INLINER] allow inlining of

blockaddresses if sole uses are callbrs")

3. https://reviews.llvm.org/D56571 ("[RFC prototype] Implementation of

asm-goto support in clang")

I can compile a mainline x86 defconfig Linux kernel and boot it in QEMU.

[void]

This code:

; ModuleID = 'arch_static_branch.bc'
source_filename = "arch/x86/entry/vsyscall/vsyscall_64.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-grtev4-linux-gnu"

%struct.atomic_t = type { i32 }
%struct.jump_entry = type { i64, i64, i64 }
%struct.tracepoint_func = type { i8*, i8*, i32 }
%struct.static_key = type { %struct.atomic_t, %union.anon }
%union.anon = type { i64 }

@__tracepoint_emulate_vsyscall = external hidden global { i8*, { %struct.atomic_t, { %struct.jump_entry* } }, i32 ()*, void ()*, %struct.tracepoint_func* }, section "__tracepoints", align 8

; Function Attrs: alwaysinline noredzone nounwind sspstrong
define zeroext i1 @arch_static_branch(%struct.static_key* nocapture readnone %key, i1 zeroext %branch) {
entry:
  callbr void asm sideeffect "1:.byte 0x0f,0x1f,0x44,0x00,0\0A\09.pushsection __jump_table,  \22aw\22 \0A\09 .balign 8 \0A\09 .quad 1b, ${2:l}, ${0:c} + ${1:c} \0A\09.popsection \0A\09", "i,i,X,~{dirflag},~{fpsr},~{flags}"(%struct.static_key* bitcast (i32* getelementptr inbounds ({ i8*, { %struct.atomic_t, { %struct.jump_entry* } }, i32 ()*, void ()*, %struct.tracepoint_func* }, { i8*, { %struct.atomic_t, { %struct.j
ump_entry* } }, i32 ()*, void ()*, %struct.tracepoint_func* }* @__tracepoint_emulate_vsyscall, i64 0, i32 1, i32 0, i32 0) to %struct.static_key*), i1 false, i8* blockaddress(@arch_static_branch, %return))
          to label %asm.fallthrough [label %return]

asm.fallthrough:                                  ; preds = %entry
  call void asm sideeffect "", "~{dirflag},~{fpsr},~{flags}"()
  br label %return

return:                                           ; preds = %asm.fallthrough, %entry
  %retval.0 = phi i1 [ false, %asm.fallthrough ], [ true, %entry ]
  ret i1 %retval.0
}

gives me this with the asm-goto patches:

$ clang -o /dev/null arch_static_branch.ll
warning: overriding the module target triple with x86_64-unknown-linux-gnu [-Woverride-module]
<inline asm>:4:15: error: expected a symbol reference in '.quad' directive
         .quad 1b, "", __tracepoint_emulate_vsyscall+8 + 0 
                     ^
error: cannot compile inline asm
1 warning and 1 error generated.

[craig.topper]

In D56571#1467333, @void wrote:

This code:

; ModuleID = 'arch_static_branch.bc'
source_filename = "arch/x86/entry/vsyscall/vsyscall_64.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-grtev4-linux-gnu"

%struct.atomic_t = type { i32 }
%struct.jump_entry = type { i64, i64, i64 }
%struct.tracepoint_func = type { i8*, i8*, i32 }
%struct.static_key = type { %struct.atomic_t, %union.anon }
%union.anon = type { i64 }

@__tracepoint_emulate_vsyscall = external hidden global { i8*, { %struct.atomic_t, { %struct.jump_entry* } }, i32 ()*, void ()*, %struct.tracepoint_func* }, section "__tracepoints", align 8

; Function Attrs: alwaysinline noredzone nounwind sspstrong
define zeroext i1 @arch_static_branch(%struct.static_key* nocapture readnone %key, i1 zeroext %branch) {
entry:
  callbr void asm sideeffect "1:.byte 0x0f,0x1f,0x44,0x00,0\0A\09.pushsection __jump_table,  \22aw\22 \0A\09 .balign 8 \0A\09 .quad 1b, ${2:l}, ${0:c} + ${1:c} \0A\09.popsection \0A\09", "i,i,X,~{dirflag},~{fpsr},~{flags}"(%struct.static_key* bitcast (i32* getelementptr inbounds ({ i8*, { %struct.atomic_t, { %struct.jump_entry* } }, i32 ()*, void ()*, %struct.tracepoint_func* }, { i8*, { %struct.atomic_t, { %struct.j
ump_entry* } }, i32 ()*, void ()*, %struct.tracepoint_func* }* @__tracepoint_emulate_vsyscall, i64 0, i32 1, i32 0, i32 0) to %struct.static_key*), i1 false, i8* blockaddress(@arch_static_branch, %return))
          to label %asm.fallthrough [label %return]

asm.fallthrough:                                  ; preds = %entry
  call void asm sideeffect "", "~{dirflag},~{fpsr},~{flags}"()
  br label %return

return:                                           ; preds = %asm.fallthrough, %entry
  %retval.0 = phi i1 [ false, %asm.fallthrough ], [ true, %entry ]
  ret i1 %retval.0
}

gives me this with the asm-goto patches:

$ clang -o /dev/null arch_static_branch.ll
warning: overriding the module target triple with x86_64-unknown-linux-gnu [-Woverride-module]
<inline asm>:4:15: error: expected a symbol reference in '.quad' directive
         .quad 1b, "", __tracepoint_emulate_vsyscall+8 + 0 
                     ^
error: cannot compile inline asm
1 warning and 1 error generated.

I think things don't work right unless you disable the integrated assembler. I'm not sure why though.

[void]

In D56571#1467358, @craig.topper wrote:

I think things don't work right unless you disable the integrated assembler. I'm not sure why though.

Using -no-integrated-as does allow it to compile, but it doesn't link (with ld.lld) if LTO is specified. Is there an equivalent flag / plugin-opt for lld?

[jyknight]

There shouldn't be an empty string ("") in the asm output -- that should be a reference to the "l_yes" label, not the empty string. That seems very weird...

Even odder: running clang -S on the above without -fno-integrated-as emits a ".quad .Ltmp00" (note the extra "0"!), while with -fno-integrated-as, it properly refers to ".Ltmp0".

[craig.topper]

@void, @jyknight given that looks like a LLVM issue rather than a clang issue, can we file a bugzilla to track separately from this clang frontend patch?

[martong]

The changes in ASTImporter.cpp looks good to me!
And I have no competence about the rest of the change, thus I resign as a reviewer.

[compudj]

Hi,

First, thanks for working on this. I am the author of the "rseq" system call in the Linux kernel, and the user-space code required to interact with that system call requires asm goto. I therefore look forward to getting asm goto support in clang.

I tried this patch on top of current clang on the following Linux kernel rseq selftests, and it fails to build. Hopefully this feedback can help you improve the current implementation.

The kernel rseq selftests can be found at:

https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/tools/testing/selftests/rseq

from the kernel source tree (on x86-64):

make headers_install
cd tools/testing/selftests/rseq
make CC=/path/to/clang

build output:

/home/efficios/git/llvm-project/build/bin/clang -O2 -Wall -g -I./ -I../../../../usr/include/ -L./ -Wl,-rpath=./ -shared -fPIC rseq.c -lpthread -o /home/efficios/git/linux/tools/testing/selftests/rseq/librseq.so
/home/efficios/git/llvm-project/build/bin/clang -O2 -Wall -g -I./ -I../../../../usr/include/ -L./ -Wl,-rpath=./ basic_test.c -lpthread -lrseq -o /home/efficios/git/linux/tools/testing/selftests/rseq/basic_test
/home/efficios/git/llvm-project/build/bin/clang -O2 -Wall -g -I./ -I../../../../usr/include/ -L./ -Wl,-rpath=./ basic_percpu_ops_test.c -lpthread -lrseq -o /home/efficios/git/linux/tools/testing/selftests/rseq/basic_percpu_ops_test
In file included from basic_percpu_ops_test.c:12:
In file included from ./rseq.h:71:
./rseq-x86.h:90:26: error: expected a symbol reference
                "cmpq %[v], %[expect]\n\t"
                                       ^
<inline asm>:13:8: note: instantiated into assembly here
        jnz ""
              ^
In file included from basic_percpu_ops_test.c:12:
In file included from ./rseq.h:71:
./rseq-x86.h:102:3: error: expected a symbol reference
                RSEQ_ASM_DEFINE_ABORT(4, "", abort)
                ^
./rseq-x86.h:67:25: note: expanded from macro 'RSEQ_ASM_DEFINE_ABORT'
                __rseq_str(label) ":\n\t"                               \
                                      ^
<inline asm>:20:8: note: instantiated into assembly here
        jmp ""
              ^
In file included from basic_percpu_ops_test.c:12:
In file included from ./rseq.h:71:
./rseq-x86.h:148:30: error: expected a symbol reference
                "cmpq %%rbx, %[expectnot]\n\t"
                                           ^
<inline asm>:14:7: note: instantiated into assembly here
        je ""
             ^
In file included from basic_percpu_ops_test.c:12:
In file included from ./rseq.h:71:
./rseq-x86.h:164:3: error: expected a symbol reference
                RSEQ_ASM_DEFINE_ABORT(4, "", abort)
                ^
./rseq-x86.h:67:25: note: expanded from macro 'RSEQ_ASM_DEFINE_ABORT'
                __rseq_str(label) ":\n\t"                               \
                                      ^
<inline asm>:24:8: note: instantiated into assembly here
        jmp ""
              ^
4 errors generated.
Makefile:22: recipe for target '/home/efficios/git/linux/tools/testing/selftests/rseq/basic_percpu_ops_test' failed
make: *** [/home/efficios/git/linux/tools/testing/selftests/rseq/basic_percpu_ops_test] Error 1

[nickdesaulniers]

@compudj email me the preprocessed output of basic_percpu_ops_test.c and I'll take a look. (Should be able to find my email via git log).

[jyu2]

In D56571#1476266, @nickdesaulniers wrote:

@compudj email me the preprocessed output of basic_percpu_ops_test.c and I'll take a look. (Should be able to find my email via git log).

@nickdesaulniers, thanks for looking into this. It look like error come from: llvm/lib/MC/MCParser/AsmParser.cpp:1118.

Please let me know if that is clang problem.

Thanks.
Jennifer

[nickdesaulniers]

In D56571#1477992, @jyu2 wrote:

Please let me know if that is clang problem.

It's an orthogonal issue with Clang's integrated assembler. @compudj confirmed that setting -no-integrated-as solves the issue (which is what we do throughout the kernel, except in a few places mostly by accident). I'm following up with @compudj off thread.

If we can get help w/ code review of:

• https://reviews.llvm.org/D58260
• https://reviews.llvm.org/D60887
• https://reviews.llvm.org/D60224

Then I think we'll have everything we need to land this patch, for the Linux kernel's consumption.

[nickdesaulniers]

Also: https://reviews.llvm.org/D61560

[nickdesaulniers]

Ok, from the Linux kernel's perspective, I believe we have worked out all underlying issues in LLVM wrt callbr that would prevent us from using asm goto successfully. This patch now has my blessing; thanks for all the hard work that went into this large feature. Please wait for a final LGTM from @rsmith .

[rsmith]

Looks good with a few largely-mechanical changes.

include/clang/Basic/DiagnosticParseKinds.td

30

Nit: can_not -> cannot

lib/Parse/ParseStmtAsm.cpp

806

Nit: the Tok.isNot(tok::r_paren) check here is redundant, since isTokenStringLiteral() covers that check.

821

I think this should be:

if (!isGotoAsm && (Tok.isNot(tok::r_paren) || AteExtraColon)) {

otherwise we'll accept a spurious extra colon split from a :: at the end of a non-goto asm. Eg, I think in C++:

void f() { asm("" : : :: ); }

... would be incorrectly accepted, because we'll parse the final :: as introducing the clobbers list, consume the :: token, pass this check because the next token is now ), and never notice we didn't use the second half of the :: token.

lib/Sema/SemaStmtAsm.cpp

668–680

This is really neat, thanks!

672

Nit: explicitly spell this as std::stable_sort instead of relying on ADL to find it from the std:: in the type of NamedOperand.

[kees]

test/Analysis/asm-goto.cpp

1

Based on Nathan's comments in another thread, it seems like this needs to be:

// REQUIRES: x86-registered-target
// RUN: %clang_analyze_cc1 -triple x86_64 -analyzer-checker=debug.DumpCFG %s 2>&1 | FileCheck %s

test/CodeGen/asm-goto.c

1

Based on Nathan's comments in another thread, it seems like this needs to be:

// REQUIRES: x86-registered-target
// RUN: %clang_cc1 -O0 -triple x86_64 -emit-llvm  %s -o - | FileCheck %s

test/Sema/asm-goto.cpp

1

Based on Nathan's comments in another thread, it seems like this needs to be:

// REQUIRES: x86-registered-target
// RUN: %clang_cc1 -triple x86_64 -fsyntax-only -verify -fblocks -std=gnu99 %s -Wno-unreachable-code

[kees]

Nick points out that "REQUIRES: x86-registered-target" is likely not needed.

[nickdesaulniers]

Was this committed accidentally?

Today in master I see:

• r362106: Revert "clang support gnu asm goto." Erich Keane <[e-mail]>
• r362059: Mark CodeGen/asm-goto.c as x86 specific after r362045 Fangrui Song <[e-mail]>
• r362045: clang support gnu asm goto. Jennifer Yu <[e-mail]>

and yet this Phabricator review is still open.

It may be easier to rebase this into a monorepo checkout, then commit with git llvm push.
https://llvm.org/docs/GettingStarted.html#for-developers-to-commit-changes-from-git

As @kees noted, for new test files that contain x86 assembly, they need a -triple that specifies an x86 target, otherwise the implicit target is based on the host, which may not be x86. We still want to verify that non-x86 host can cross compile to x86 correctly. Sorry we did not catch this earlier in code review.

[jyu2]

jyu2 committed rG954ec09aed4f: clang support gnu asm goto

In D56571#1523895, @nickdesaulniers wrote:

Was this committed accidentally?

Today in master I see:

• r362106: Revert "clang support gnu asm goto." Erich Keane <[e-mail]>
• r362059: Mark CodeGen/asm-goto.c as x86 specific after r362045 Fangrui Song <[e-mail]>
• r362045: clang support gnu asm goto. Jennifer Yu <[e-mail]>

and yet this Phabricator review is still open.

It may be easier to rebase this into a monorepo checkout, then commit with git llvm push.
https://llvm.org/docs/GettingStarted.html#for-developers-to-commit-changes-from-git

As @kees noted, for new test files that contain x86 assembly, they need a -triple that specifies an x86 target, otherwise the implicit target is based on the host, which may not be x86. We still want to verify that non-x86 host can cross compile to x86 correctly. Sorry we did not catch this earlier in code review.

Thanks Kees and Nick! I am currently work on those tests to see if I can make them more generic. All my test using x86 instruction. So that is not working for arm or arm64 target. Will update you once I am done for this.

[jyu2]

jyu2 committed rGb8fee677bf8e: Re-check in clang support gun asm goto after fixing tests. (authored by jyu2).

[xbolva00]

There is a bug.. I took GCC’s example for asm goto and trunk emits:
https://godbolt.org/z/9EcTR9

Wrong jb instruction target..

[erichkeane]

In D56571#1523895, @nickdesaulniers wrote:

Was this committed accidentally?

Today in master I see:

• r362106: Revert "clang support gnu asm goto." Erich Keane <[e-mail]>
• r362059: Mark CodeGen/asm-goto.c as x86 specific after r362045 Fangrui Song <[e-mail]>
• r362045: clang support gnu asm goto. Jennifer Yu <[e-mail]>

and yet this Phabricator review is still open.

It may be easier to rebase this into a monorepo checkout, then commit with git llvm push.
https://llvm.org/docs/GettingStarted.html#for-developers-to-commit-changes-from-git

As @kees noted, for new test files that contain x86 assembly, they need a -triple that specifies an x86 target, otherwise the implicit target is based on the host, which may not be x86. We still want to verify that non-x86 host can cross compile to x86 correctly. Sorry we did not catch this earlier in code review.

I think Jennifer just forgot the Differential Revision line, so this was never closed. The test failures resulted in her wanting the patch reverted until she could fix it (hence my revert)

In D56571#1529349, @xbolva00 wrote:

There is a bug.. I took GCC’s example for asm goto and trunk emits:
https://godbolt.org/z/9EcTR9

Wrong jb instruction target..

Hmm... I don't see the jb instruction target name reflected in the IR, so I suspect @craig.topper should be made aware of the descrepancy (author of https://reviews.llvm.org/D53765).

[craig.topper]

There's still something weird in the backend, but things seem to generally work if you pass -fno-integrated-as to clang which the linux kernel does.

[nickdesaulniers]

For future travelers, we're tracking 2 related bugs:

• -no-integrated-as providing different results: https://github.com/ClangBuiltLinux/linux/issues/500
• IfConverter asserting on INLINEASM_BR MachineInstrs: https://github.com/ClangBuiltLinux/linux/issues/494

include/clang/AST/Stmt.h

 
 namespace clang {
 
 class ASTContext;
 class Attr;
 class CapturedDecl;
 class Decl;
 class Expr;
+class AddrLabelExpr;
 class LabelDecl;
 class ODRHash;
 class PrinterHelper;
 struct PrintingPolicy;
 class RecordDecl;
 class SourceManager;
 class StringLiteral;
 class Token;

 protected:
   /// Iterator for iterating over Stmt * arrays that contain only T *.
   ///
   /// This is needed because AST nodes use Stmt* arrays to store
   /// references to children (to be compatible with StmtIterator).
   template<typename T, typename TPtr = T *, typename StmtPtr = Stmt *>
   struct CastIterator
       : llvm::iterator_adaptor_base<CastIterator<T, TPtr, StmtPtr>, StmtPtr *,
                                     std::random_access_iterator_tag, TPtr> {
     using Base = typename CastIterator::iterator_adaptor_base;
 
     CastIterator() : Base(nullptr) {}
     CastIterator(StmtPtr *I) : Base(I) {}
 
     typename Base::value_type operator*() const {
       return cast<T>(*this->I);
     }
class GCCAsmStmt : public AsmStmt {
 
   SourceLocation RParenLoc;
   StringLiteral *AsmStr;
 
   // FIXME: If we wanted to, we could allocate all of these in one big array.
   StringLiteral **Constraints = nullptr;
   StringLiteral **Clobbers = nullptr;
   IdentifierInfo **Names = nullptr;
+  unsigned NumLabels = 0;
 
 public:
   GCCAsmStmt(const ASTContext &C, SourceLocation asmloc, bool issimple,
              bool isvolatile, unsigned numoutputs, unsigned numinputs,
              IdentifierInfo **names, StringLiteral **constraints, Expr **exprs,
              StringLiteral *asmstr, unsigned numclobbers,
-             StringLiteral **clobbers, SourceLocation rparenloc);
+             StringLiteral **clobbers, unsigned numlabels,
+             SourceLocation rparenloc);
 
   /// Build an empty inline-assembly statement.
   explicit GCCAsmStmt(EmptyShell Empty) : AsmStmt(GCCAsmStmtClass, Empty) {}
 
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   //===--- Asm String Analysis ---===//
public:
 
   Expr *getInputExpr(unsigned i);
   void setInputExpr(unsigned i, Expr *E);
 
   const Expr *getInputExpr(unsigned i) const {
     return const_cast<GCCAsmStmt*>(this)->getInputExpr(i);
   }
 
+  //===--- Labels ---===//
+
+  bool isAsmGoto() const {
+    return NumLabels > 0;
+  }
+
+  unsigned getNumLabels() const {
+    return NumLabels;
+  }
+
+  IdentifierInfo *getLabelIdentifier(unsigned i) const {
+    return Names[i + NumInputs];
+  }
+
+  AddrLabelExpr *getLabelExpr(unsigned i) const;
+  StringRef getLabelName(unsigned i) const;
+  using labels_iterator = CastIterator<AddrLabelExpr>;
+  using const_labels_iterator = ConstCastIterator<AddrLabelExpr>;
+  using labels_range = llvm::iterator_range<labels_iterator>;
+  using labels_const_range = llvm::iterator_range<const_labels_iterator>;
+
+  labels_iterator begin_labels() {
+    return &Exprs[0] + NumInputs;
+  }
+
+  labels_iterator end_labels() {
+    return &Exprs[0] + NumInputs + NumLabels;
+  }
+
+  labels_range labels() {
+    return labels_range(begin_labels(), end_labels());
+  }
+
+  const_labels_iterator begin_labels() const {
+    return &Exprs[0] + NumInputs;
+  }
+
+  const_labels_iterator end_labels() const {
+    return &Exprs[0] + NumInputs + NumLabels;
+  }
+
+  labels_const_range labels() const {
+    return labels_const_range(begin_labels(), end_labels());
+  }
+
 private:
   void setOutputsAndInputsAndClobbers(const ASTContext &C,
                                       IdentifierInfo **Names,
                                       StringLiteral **Constraints,
                                       Stmt **Exprs,
                                       unsigned NumOutputs,
                                       unsigned NumInputs,
+                                      unsigned NumLabels,
                                       StringLiteral **Clobbers,
                                       unsigned NumClobbers);
 
 public:
   //===--- Other ---===//
 
   /// getNamedOperand - Given a symbolic operand reference like %[foo],
   /// translate this into a numeric value needed to reference the same operand.

include/clang/Basic/DiagnosticParseKinds.td

 def err_asm_empty : Error<"__asm used with no assembly instructions">;
 def err_inline_ms_asm_parsing : Error<"%0">;
 def err_msasm_unsupported_arch : Error<
   "Unsupported architecture '%0' for MS-style inline assembly">;
 def err_msasm_unable_to_create_target : Error<
   "MS-style inline assembly is not available: %0">;
 def err_gnu_inline_asm_disabled : Error<
   "GNU-style inline assembly is disabled">;
-def err_asm_goto_not_supported_yet : Error<
-  "'asm goto' constructs are not supported yet">;
+def err_asm_goto_can_not_have_output : Error<
+  "'asm goto' cannot have output constraints">;
 }
 
 let CategoryName = "Parse Issue" in {
 
 def ext_empty_translation_unit : Extension<
   "ISO C requires a translation unit to contain at least one declaration">,
   InGroup<DiagGroup<"empty-translation-unit">>;
 def warn_cxx98_compat_top_level_semi : Warning<

include/clang/Basic/DiagnosticSemaKinds.td

 def err_switch_into_protected_scope : Error<
   "cannot jump from switch statement to this case label">;
 def warn_cxx98_compat_switch_into_protected_scope : Warning<
   "jump from switch statement to this case label is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_indirect_goto_without_addrlabel : Error<
   "indirect goto in function with no address-of-label expressions">;
 def err_indirect_goto_in_protected_scope : Error<
-  "cannot jump from this indirect goto statement to one of its possible targets">;
+  "cannot jump from this %select{indirect|asm}0 goto statement to one of its possible targets">;
 def warn_cxx98_compat_indirect_goto_in_protected_scope : Warning<
-  "jump from this indirect goto statement to one of its possible targets "
+  "jump from this %select{indirect|asm}0 goto statement to one of its possible targets "
   "is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore;
 def note_indirect_goto_target : Note<
-  "possible target of indirect goto statement">;
+  "possible target of %select{indirect|asm}0 goto statement">;
 def note_protected_by_variable_init : Note<
   "jump bypasses variable initialization">;
 def note_protected_by_variable_nontriv_destructor : Note<
   "jump bypasses variable with a non-trivial destructor">;
 def note_protected_by_variable_non_pod : Note<
   "jump bypasses initialization of non-POD variable">;
 def note_protected_by_cleanup : Note<
   "jump bypasses initialization of variable with __attribute__((cleanup))">;
def warn_asm_mismatched_size_modifier : Warning<
     "value size does not match register size specified by the constraint "
     "and modifier">,
     InGroup<ASMOperandWidths>;
 
   def note_asm_missing_constraint_modifier : Note<
     "use constraint modifier \"%0\"">;
   def note_asm_input_duplicate_first : Note<
     "constraint '%0' is already present here">;
+ def error_duplicate_asm_operand_name : Error<
+    "duplicate use of asm operand name \"%0\"">;
+ def note_duplicate_asm_operand_name : Note<
+    "asm operand name \"%0\" first referenced here">;
 }
 
   def error_inoutput_conflict_with_clobber : Error<
     "asm-specifier for input or output variable conflicts with asm"
     " clobber list">;
 
 let CategoryName = "Semantic Issue" in {
 

include/clang/Sema/Sema.h

public:
   StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
   StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
 
   StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                              bool IsVolatile, unsigned NumOutputs,
                              unsigned NumInputs, IdentifierInfo **Names,
                              MultiExprArg Constraints, MultiExprArg Exprs,
                              Expr *AsmString, MultiExprArg Clobbers,
+                             unsigned NumLabels,
                              SourceLocation RParenLoc);
 
   void FillInlineAsmIdentifierInfo(Expr *Res,
                                    llvm::InlineAsmIdentifierInfo &Info);
   ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,
                                        SourceLocation TemplateKWLoc,
                                        UnqualifiedId &Id,
                                        bool IsUnevaluatedContext);

lib/AST/ASTImporter.cpp

ExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
 
   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
     if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
       Constraints.push_back(*InputOrErr);
     else
       return InputOrErr.takeError();
   }
 
-  SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
+  SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
+                               S->getNumLabels());
   if (Error Err = ImportContainerChecked(S->outputs(), Exprs))
     return std::move(Err);
 
+  if (Error Err =
+          ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
+    return std::move(Err);
+
   if (Error Err = ImportArrayChecked(
-      S->inputs(), Exprs.begin() + S->getNumOutputs()))
+          S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
     return std::move(Err);
 
   ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
   if (!AsmLocOrErr)
     return AsmLocOrErr.takeError();
   auto AsmStrOrErr = import(S->getAsmString());
   if (!AsmStrOrErr)
     return AsmStrOrErr.takeError();
return new (Importer.getToContext()) GCCAsmStmt(
       S->getNumOutputs(),
       S->getNumInputs(),
       Names.data(),
       Constraints.data(),
       Exprs.data(),
       *AsmStrOrErr,
       S->getNumClobbers(),
       Clobbers.data(),
+      S->getNumLabels(),
       *RParenLocOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
   auto Imp = importSeq(S->getDeclGroup(), S->getBeginLoc(), S->getEndLoc());
   if (!Imp)
     return Imp.takeError();
 

lib/AST/Stmt.cpp

 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
   return cast<Expr>(Exprs[i + NumOutputs]);
 }
 
 void GCCAsmStmt::setInputExpr(unsigned i, Expr *E) {
   Exprs[i + NumOutputs] = E;
 }
 
+AddrLabelExpr *GCCAsmStmt::getLabelExpr(unsigned i) const {
+  return cast<AddrLabelExpr>(Exprs[i + NumInputs]);
+}
+
+StringRef GCCAsmStmt::getLabelName(unsigned i) const {
+  return getLabelExpr(i)->getLabel()->getName();
+}
+
 /// getInputConstraint - Return the specified input constraint.  Unlike output
 /// constraints, these can be empty.
 StringRef GCCAsmStmt::getInputConstraint(unsigned i) const {
   return getInputConstraintLiteral(i)->getString();
 }
 
 void GCCAsmStmt::setOutputsAndInputsAndClobbers(const ASTContext &C,
                                                 IdentifierInfo **Names,
                                                 StringLiteral **Constraints,
                                                 Stmt **Exprs,
                                                 unsigned NumOutputs,
                                                 unsigned NumInputs,
+                                                unsigned NumLabels,
                                                 StringLiteral **Clobbers,
                                                 unsigned NumClobbers) {
   this->NumOutputs = NumOutputs;
   this->NumInputs = NumInputs;
   this->NumClobbers = NumClobbers;
+  this->NumLabels = NumLabels;
+  assert(!(NumOutputs && NumLabels) && "asm goto cannot have outputs");
 
-  unsigned NumExprs = NumOutputs + NumInputs;
+  unsigned NumExprs = NumOutputs + NumInputs + NumLabels;
 
   C.Deallocate(this->Names);
   this->Names = new (C) IdentifierInfo*[NumExprs];
   std::copy(Names, Names + NumExprs, this->Names);
 
   C.Deallocate(this->Exprs);
   this->Exprs = new (C) Stmt*[NumExprs];
   std::copy(Exprs, Exprs + NumExprs, this->Exprs);
for (unsigned i = 0, e = getNumOutputs(); i != e; ++i) {
     if (getOutputName(i) == SymbolicName)
       return i;
   }
 
   for (unsigned i = 0, e = getNumInputs(); i != e; ++i)
     if (getInputName(i) == SymbolicName)
       return getNumOutputs() + NumPlusOperands + i;
 
+  for (unsigned i = 0, e = getNumLabels(); i != e; ++i)
+    if (getLabelName(i) == SymbolicName)
+      return i + getNumInputs();
+
   // Not found.
   return -1;
 }
 
 /// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing
 /// it into pieces.  If the asm string is erroneous, emit errors and return
 /// true, otherwise return false.
 unsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece>&Pieces,
while (true) {
     if (isDigit(EscapedChar)) {
       // %n - Assembler operand n
       unsigned N = 0;
 
       --CurPtr;
       while (CurPtr != StrEnd && isDigit(*CurPtr))
         N = N*10 + ((*CurPtr++)-'0');
 
-      unsigned NumOperands =
-        getNumOutputs() + getNumPlusOperands() + getNumInputs();
+      unsigned NumOperands = getNumOutputs() + getNumPlusOperands() +
+                             getNumInputs() + getNumLabels();
       if (N >= NumOperands) {
         DiagOffs = CurPtr-StrStart-1;
         return diag::err_asm_invalid_operand_number;
       }
 
       // Str contains "x4" (Operand without the leading %).
       std::string Str(Begin, CurPtr - Begin);
 
       // (BeginLoc, EndLoc) represents the range of the operand we are currently
       // processing. Unlike Str, the range includes the leading '%'.
       SourceLocation BeginLoc = getAsmString()->getLocationOfByte(
           Percent - StrStart, SM, LO, TI, &LastAsmStringToken,
           &LastAsmStringOffset);
       SourceLocation EndLoc = getAsmString()->getLocationOfByte(
           CurPtr - StrStart, SM, LO, TI, &LastAsmStringToken,
           &LastAsmStringOffset);

 // Constructors
 //===----------------------------------------------------------------------===//
 
 GCCAsmStmt::GCCAsmStmt(const ASTContext &C, SourceLocation asmloc,
                        bool issimple, bool isvolatile, unsigned numoutputs,
                        unsigned numinputs, IdentifierInfo **names,
                        StringLiteral **constraints, Expr **exprs,
                        StringLiteral *asmstr, unsigned numclobbers,
-                       StringLiteral **clobbers, SourceLocation rparenloc)
+                       StringLiteral **clobbers, unsigned numlabels,
+                       SourceLocation rparenloc)
     : AsmStmt(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
-              numinputs, numclobbers), RParenLoc(rparenloc), AsmStr(asmstr) {
-  unsigned NumExprs = NumOutputs + NumInputs;
+              numinputs, numclobbers),
+              RParenLoc(rparenloc), AsmStr(asmstr), NumLabels(numlabels) {
+  unsigned NumExprs = NumOutputs + NumInputs + NumLabels;
 
   Names = new (C) IdentifierInfo*[NumExprs];
   std::copy(names, names + NumExprs, Names);
 
   Exprs = new (C) Stmt*[NumExprs];
   std::copy(exprs, exprs + NumExprs, Exprs);
 
   Constraints = new (C) StringLiteral*[NumExprs];

lib/AST/StmtPrinter.cpp

 }
 
 void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
   Indent() << "asm ";
 
   if (Node->isVolatile())
     OS << "volatile ";
 
+  if (Node->isAsmGoto())
+    OS << "goto ";
+
   OS << "(";
   VisitStringLiteral(Node->getAsmString());
 
   // Outputs
   if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
-      Node->getNumClobbers() != 0)
+      Node->getNumClobbers() != 0 || Node->getNumLabels() != 0)
     OS << " : ";
 
   for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
     if (i != 0)
       OS << ", ";
 
     if (!Node->getOutputName(i).empty()) {
       OS << '[';
       OS << Node->getOutputName(i);
       OS << "] ";
     }
 
     VisitStringLiteral(Node->getOutputConstraintLiteral(i));
     OS << " (";
     Visit(Node->getOutputExpr(i));
     OS << ")";
   }
 
   // Inputs
-  if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0)
+  if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0 ||
+      Node->getNumLabels() != 0)
     OS << " : ";
 
   for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
     if (i != 0)
       OS << ", ";
 
     if (!Node->getInputName(i).empty()) {
       OS << '[';
       OS << Node->getInputName(i);
       OS << "] ";
     }
 
     VisitStringLiteral(Node->getInputConstraintLiteral(i));
     OS << " (";
     Visit(Node->getInputExpr(i));
     OS << ")";
   }
 
   // Clobbers
-  if (Node->getNumClobbers() != 0)
+  if (Node->getNumClobbers() != 0 || Node->getNumLabels())
     OS << " : ";
 
   for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
     if (i != 0)
       OS << ", ";
 
     VisitStringLiteral(Node->getClobberStringLiteral(i));
   }
 
+  // Labels
+  if (Node->getNumLabels() != 0)
+    OS << " : ";
+
+  for (unsigned i = 0, e = Node->getNumLabels(); i != e; ++i) {
+    if (i != 0)
+      OS << ", ";
+    OS << Node->getLabelName(i);
+  }
+
   OS << ");";
   if (Policy.IncludeNewlines) OS << NL;
 }
 
 void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
   // FIXME: Implement MS style inline asm statement printer.
   Indent() << "__asm ";
   if (Node->hasBraces())

lib/AST/StmtProfile.cpp

void StmtProfiler::VisitGCCAsmStmt(const GCCAsmStmt *S) {
   ID.AddInteger(S->getNumInputs());
   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
     ID.AddString(S->getInputName(I));
     VisitStringLiteral(S->getInputConstraintLiteral(I));
   }
   ID.AddInteger(S->getNumClobbers());
   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
     VisitStringLiteral(S->getClobberStringLiteral(I));
+  ID.AddInteger(S->getNumLabels());
+  for (auto *L : S->labels())
+    VisitDecl(L->getLabel());
 }
 
 void StmtProfiler::VisitMSAsmStmt(const MSAsmStmt *S) {
   // FIXME: Implement MS style inline asm statement profiler.
   VisitStmt(S);
 }
 
 void StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) {

lib/Analysis/CFG.cpp

private:
   CFGBlock *VisitCXXTryStmt(CXXTryStmt *S);
   CFGBlock *VisitDeclStmt(DeclStmt *DS);
   CFGBlock *VisitDeclSubExpr(DeclStmt *DS);
   CFGBlock *VisitDefaultStmt(DefaultStmt *D);
   CFGBlock *VisitDoStmt(DoStmt *D);
   CFGBlock *VisitExprWithCleanups(ExprWithCleanups *E, AddStmtChoice asc);
   CFGBlock *VisitForStmt(ForStmt *F);
   CFGBlock *VisitGotoStmt(GotoStmt *G);
+  CFGBlock *VisitGCCAsmStmt(GCCAsmStmt *G, AddStmtChoice asc);
   CFGBlock *VisitIfStmt(IfStmt *I);
   CFGBlock *VisitImplicitCastExpr(ImplicitCastExpr *E, AddStmtChoice asc);
   CFGBlock *VisitConstantExpr(ConstantExpr *E, AddStmtChoice asc);
   CFGBlock *VisitIndirectGotoStmt(IndirectGotoStmt *I);
   CFGBlock *VisitLabelStmt(LabelStmt *L);
   CFGBlock *VisitBlockExpr(BlockExpr *E, AddStmtChoice asc);
   CFGBlock *VisitLambdaExpr(LambdaExpr *E, AddStmtChoice asc);
   CFGBlock *VisitLogicalOperator(BinaryOperator *B);
if (B)
     Succ = B;
 
   // Backpatch the gotos whose label -> block mappings we didn't know when we
   // encountered them.
   for (BackpatchBlocksTy::iterator I = BackpatchBlocks.begin(),
                                    E = BackpatchBlocks.end(); I != E; ++I ) {
 
     CFGBlock *B = I->block;
-    const GotoStmt *G = cast<GotoStmt>(B->getTerminator());
+    if (auto *G = dyn_cast<GotoStmt>(B->getTerminator())) {
       LabelMapTy::iterator LI = LabelMap.find(G->getLabel());
-
       // If there is no target for the goto, then we are looking at an
       // incomplete AST.  Handle this by not registering a successor.
-    if (LI == LabelMap.end()) continue;
-
+      if (LI == LabelMap.end())
+        continue;
       JumpTarget JT = LI->second;
       prependAutomaticObjLifetimeWithTerminator(B, I->scopePosition,
                                                 JT.scopePosition);
       prependAutomaticObjDtorsWithTerminator(B, I->scopePosition,
                                              JT.scopePosition);
       const VarDecl *VD = prependAutomaticObjScopeEndWithTerminator(
           B, I->scopePosition, JT.scopePosition);
       appendScopeBegin(JT.block, VD, G);
       addSuccessor(B, JT.block);
+    };
+    if (auto *G = dyn_cast<GCCAsmStmt>(B->getTerminator())) {
+      CFGBlock *Successor  = (I+1)->block;
+      for (auto *L : G->labels()) {
+        LabelMapTy::iterator LI = LabelMap.find(L->getLabel());
+        // If there is no target for the goto, then we are looking at an
+        // incomplete AST.  Handle this by not registering a successor.
+        if (LI == LabelMap.end())
+          continue;
+        JumpTarget JT = LI->second;
+        // Successor has been added, so skip it.
+        if (JT.block == Successor)
+          continue;
+        addSuccessor(B, JT.block);
+      }
+      I++;
+    }
   }
 
   // Add successors to the Indirect Goto Dispatch block (if we have one).
   if (CFGBlock *B = cfg->getIndirectGotoBlock())
     for (LabelSetTy::iterator I = AddressTakenLabels.begin(),
                               E = AddressTakenLabels.end(); I != E; ++I ) {
       // Lookup the target block.
       LabelMapTy::iterator LI = LabelMap.find(*I);
case Stmt::DoStmtClass:
       return VisitDoStmt(cast<DoStmt>(S));
 
     case Stmt::ForStmtClass:
       return VisitForStmt(cast<ForStmt>(S));
 
     case Stmt::GotoStmtClass:
       return VisitGotoStmt(cast<GotoStmt>(S));
 
+    case Stmt::GCCAsmStmtClass:
+      return VisitGCCAsmStmt(cast<GCCAsmStmt>(S), asc);
+
     case Stmt::IfStmtClass:
       return VisitIfStmt(cast<IfStmt>(S));
 
     case Stmt::ImplicitCastExprClass:
       return VisitImplicitCastExpr(cast<ImplicitCastExpr>(S), asc);
 
     case Stmt::ConstantExprClass:
       return VisitConstantExpr(cast<ConstantExpr>(S), asc);
else {
     JumpTarget JT = I->second;
     addAutomaticObjHandling(ScopePos, JT.scopePosition, G);
     addSuccessor(Block, JT.block);
   }
 
   return Block;
 }
 
+CFGBlock *CFGBuilder::VisitGCCAsmStmt(GCCAsmStmt *G, AddStmtChoice asc) {
+  // Goto is a control-flow statement.  Thus we stop processing the current
+  // block and create a new one.
+
+  if (!G->isAsmGoto())
+    return VisitStmt(G, asc);
+
+  if (Block) {
+    Succ = Block;
+    if (badCFG)
+      return nullptr;
+  }
+  Block = createBlock();
+  Block->setTerminator(G);
+  // We will backpatch this block later for all the labels.
+  BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
+  // Save "Succ" in BackpatchBlocks. In the backpatch processing, "Succ" is
+  // used to avoid adding "Succ" again.
+  BackpatchBlocks.push_back(JumpSource(Succ, ScopePos));
+  return Block;
+}
+
 CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) {
   CFGBlock *LoopSuccessor = nullptr;
 
   // Save local scope position because in case of condition variable ScopePos
   // won't be restored when traversing AST.
   SaveAndRestore<LocalScope::const_iterator> save_scope_pos(ScopePos);
 
   // Create local scope for init statement and possible condition variable.

lib/CodeGen/CGStmt.cpp

for (unsigned i = 0, e = StrVal.size() - 1; i != e; ++i) {
       Locs.push_back(llvm::ConstantAsMetadata::get(
           llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding())));
     }
   }
 
   return llvm::MDNode::get(CGF.getLLVMContext(), Locs);
 }
 
+static void UpdateAsmCallInst(llvm::CallBase &Result, bool HasSideEffect,
+                              bool ReadOnly, bool ReadNone, const AsmStmt &S,
+                              const std::vector<llvm::Type *> &ResultRegTypes,
+                              CodeGenFunction &CGF,
+                              std::vector<llvm::Value *> &RegResults) {
+  Result.addAttribute(llvm::AttributeList::FunctionIndex,
+                      llvm::Attribute::NoUnwind);
+  // Attach readnone and readonly attributes.
+  if (!HasSideEffect) {
+    if (ReadNone)
+      Result.addAttribute(llvm::AttributeList::FunctionIndex,
+                          llvm::Attribute::ReadNone);
+    else if (ReadOnly)
+      Result.addAttribute(llvm::AttributeList::FunctionIndex,
+                          llvm::Attribute::ReadOnly);
+  }
+
+  // Slap the source location of the inline asm into a !srcloc metadata on the
+  // call.
+  if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S))
+    Result.setMetadata("srcloc",
+                       getAsmSrcLocInfo(gccAsmStmt->getAsmString(), CGF));
+  else {
+    // At least put the line number on MS inline asm blobs.
+    llvm::Constant *Loc = llvm::ConstantInt::get(CGF.Int32Ty,
+                                        S.getAsmLoc().getRawEncoding());
+    Result.setMetadata("srcloc",
+                       llvm::MDNode::get(CGF.getLLVMContext(),
+                                         llvm::ConstantAsMetadata::get(Loc)));
+  }
+
+  if (CGF.getLangOpts().assumeFunctionsAreConvergent())
+    // Conservatively, mark all inline asm blocks in CUDA or OpenCL as
+    // convergent (meaning, they may call an intrinsically convergent op, such
+    // as bar.sync, and so can't have certain optimizations applied around
+    // them).
+    Result.addAttribute(llvm::AttributeList::FunctionIndex,
+                        llvm::Attribute::Convergent);
+  // Extract all of the register value results from the asm.
+  if (ResultRegTypes.size() == 1) {
+    RegResults.push_back(&Result);
+  } else {
+    for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
+      llvm::Value *Tmp = CGF.Builder.CreateExtractValue(&Result, i, "asmresult");
+      RegResults.push_back(Tmp);
+    }
+  }
+}
+
 void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
   // Assemble the final asm string.
   std::string AsmString = S.generateAsmString(getContext());
 
   // Get all the output and input constraints together.
   SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
   SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
 
void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
 
   // Append the "input" part of inout constraints last.
   for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
     ArgTypes.push_back(InOutArgTypes[i]);
     Args.push_back(InOutArgs[i]);
   }
   Constraints += InOutConstraints;
 
+  // Labels
+  SmallVector<llvm::BasicBlock *, 16> Transfer;
+  llvm::BasicBlock *Fallthrough = nullptr;
+  bool IsGCCAsmGoto = false;
+  if (const auto *GS =  dyn_cast<GCCAsmStmt>(&S)) {
+    IsGCCAsmGoto = GS->isAsmGoto();
+    if (IsGCCAsmGoto) {
+      for (auto *E : GS->labels()) {
+        JumpDest Dest = getJumpDestForLabel(E->getLabel());
+        Transfer.push_back(Dest.getBlock());
+        llvm::BlockAddress *BA =
+            llvm::BlockAddress::get(CurFn, Dest.getBlock());
+        Args.push_back(BA);
+        ArgTypes.push_back(BA->getType());
+        if (!Constraints.empty())
+          Constraints += ',';
+        Constraints += 'X';
+      }
+      StringRef Name = "asm.fallthrough";
+      Fallthrough = createBasicBlock(Name);
+    }
+  }
+
   // Clobbers
   for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) {
     StringRef Clobber = S.getClobber(i);
 
     if (Clobber == "memory")
       ReadOnly = ReadNone = false;
     else if (Clobber != "cc")
       Clobber = getTarget().getNormalizedGCCRegisterName(Clobber);
llvm::FunctionType *FTy =
     llvm::FunctionType::get(ResultType, ArgTypes, false);
 
   bool HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0;
   llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&S) ?
     llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT;
   llvm::InlineAsm *IA =
     llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect,
                          /* IsAlignStack */ false, AsmDialect);
-  llvm::CallInst *Result =
-      Builder.CreateCall(IA, Args, getBundlesForFunclet(IA));
-  Result->addAttribute(llvm::AttributeList::FunctionIndex,
-                       llvm::Attribute::NoUnwind);
-
-  // Attach readnone and readonly attributes.
-  if (!HasSideEffect) {
-    if (ReadNone)
-      Result->addAttribute(llvm::AttributeList::FunctionIndex,
-                           llvm::Attribute::ReadNone);
-    else if (ReadOnly)
-      Result->addAttribute(llvm::AttributeList::FunctionIndex,
-                           llvm::Attribute::ReadOnly);
-  }
-
-  // Slap the source location of the inline asm into a !srcloc metadata on the
-  // call.
-  if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S)) {
-    Result->setMetadata("srcloc", getAsmSrcLocInfo(gccAsmStmt->getAsmString(),
-                                                   *this));
-  } else {
-    // At least put the line number on MS inline asm blobs.
-    auto Loc = llvm::ConstantInt::get(Int32Ty, S.getAsmLoc().getRawEncoding());
-    Result->setMetadata("srcloc",
-                        llvm::MDNode::get(getLLVMContext(),
-                                          llvm::ConstantAsMetadata::get(Loc)));
-  }
-
-  if (getLangOpts().assumeFunctionsAreConvergent()) {
-    // Conservatively, mark all inline asm blocks in CUDA or OpenCL as
-    // convergent (meaning, they may call an intrinsically convergent op, such
-    // as bar.sync, and so can't have certain optimizations applied around
-    // them).
-    Result->addAttribute(llvm::AttributeList::FunctionIndex,
-                         llvm::Attribute::Convergent);
-  }
-
-  // Extract all of the register value results from the asm.
   std::vector<llvm::Value*> RegResults;
-  if (ResultRegTypes.size() == 1) {
-    RegResults.push_back(Result);
+  if (IsGCCAsmGoto) {
+    llvm::CallBrInst *Result =
+        Builder.CreateCallBr(IA, Fallthrough, Transfer, Args);
+    UpdateAsmCallInst(cast<llvm::CallBase>(*Result), HasSideEffect, ReadOnly,
+                      ReadNone, S, ResultRegTypes, *this, RegResults);
+    EmitBlock(Fallthrough);
   } else {
-    for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
-      llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult");
-      RegResults.push_back(Tmp);
-    }
+    llvm::CallInst *Result =
+        Builder.CreateCall(IA, Args, getBundlesForFunclet(IA));
+    UpdateAsmCallInst(cast<llvm::CallBase>(*Result), HasSideEffect, ReadOnly,
+                      ReadNone, S, ResultRegTypes, *this, RegResults);
   }
 
   assert(RegResults.size() == ResultRegTypes.size());
   assert(RegResults.size() == ResultTruncRegTypes.size());
   assert(RegResults.size() == ResultRegDests.size());
   for (unsigned i = 0, e = RegResults.size(); i != e; ++i) {
     llvm::Value *Tmp = RegResults[i];
 

lib/Parse/ParseStmtAsm.cpp

StmtResult Parser::ParseAsmStatement(bool &msAsm) {
   if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
     Diag(Loc, diag::warn_asm_qualifier_ignored) << "restrict";
   // FIXME: Once GCC supports _Atomic, check whether it permits it here.
   if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
     Diag(Loc, diag::warn_asm_qualifier_ignored) << "_Atomic";
 
   // Remember if this was a volatile asm.
   bool isVolatile = DS.getTypeQualifiers() & DeclSpec::TQ_volatile;
+  // Remember if this was a goto asm.
+  bool isGotoAsm = false;
 
-  // TODO: support "asm goto" constructs (PR#9295).
   if (Tok.is(tok::kw_goto)) {
-    Diag(Tok, diag::err_asm_goto_not_supported_yet);
-    SkipUntil(tok::r_paren, StopAtSemi);
-    return StmtError();
+    isGotoAsm = true;
+    ConsumeToken();
   }
 
   if (Tok.isNot(tok::l_paren)) {
     Diag(Tok, diag::err_expected_lparen_after) << "asm";
     SkipUntil(tok::r_paren, StopAtSemi);
     return StmtError();
   }
   BalancedDelimiterTracker T(*this, tok::l_paren);
StmtResult Parser::ParseAsmStatement(bool &msAsm) {
   ExprVector Clobbers;
 
   if (Tok.is(tok::r_paren)) {
     // We have a simple asm expression like 'asm("foo")'.
     T.consumeClose();
     return Actions.ActOnGCCAsmStmt(AsmLoc, /*isSimple*/ true, isVolatile,
                                    /*NumOutputs*/ 0, /*NumInputs*/ 0, nullptr,
                                    Constraints, Exprs, AsmString.get(),
-                                   Clobbers, T.getCloseLocation());
+                                   Clobbers, /*NumLabels*/ 0,
+                                   T.getCloseLocation());
   }
 
   // Parse Outputs, if present.
   bool AteExtraColon = false;
   if (Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
     // In C++ mode, parse "::" like ": :".
     AteExtraColon = Tok.is(tok::coloncolon);
     ConsumeToken();
 
+    if (!AteExtraColon && isGotoAsm && Tok.isNot(tok::colon)) {
+      Diag(Tok, diag::err_asm_goto_can_not_have_output);
+      SkipUntil(tok::r_paren, StopAtSemi);
+      return StmtError();
+    }
+
     if (!AteExtraColon && ParseAsmOperandsOpt(Names, Constraints, Exprs))
       return StmtError();
   }
 
   unsigned NumOutputs = Names.size();
 
   // Parse Inputs, if present.
   if (AteExtraColon || Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
StmtResult Parser::ParseAsmStatement(bool &msAsm) {
   }
 
   assert(Names.size() == Constraints.size() &&
          Constraints.size() == Exprs.size() && "Input operand size mismatch!");
 
   unsigned NumInputs = Names.size() - NumOutputs;
 
   // Parse the clobbers, if present.
-  if (AteExtraColon || Tok.is(tok::colon)) {
-    if (!AteExtraColon)
+  if (AteExtraColon || Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
+    if (AteExtraColon)
+      AteExtraColon = false;
+    else {
+      AteExtraColon = Tok.is(tok::coloncolon);
       ConsumeToken();
-
+    }
     // Parse the asm-string list for clobbers if present.
-    if (Tok.isNot(tok::r_paren)) {
+    if (!AteExtraColon && Tok.isNot(tok::r_paren) &&
+        isTokenStringLiteral()) {
       while (1) {
         ExprResult Clobber(ParseAsmStringLiteral());
 
         if (Clobber.isInvalid())
           break;
 
         Clobbers.push_back(Clobber.get());
 
         if (!TryConsumeToken(tok::comma))
           break;
       }
     }
   }
+  if (!isGotoAsm && Tok.isNot(tok::r_paren)) {
+    Diag(Tok, diag::err_expected) << tok::r_paren;
+    SkipUntil(tok::r_paren, StopAtSemi);
+    return StmtError();
+  }
+
+  // Parse the goto label, if present.
+  unsigned NumLabels = 0;
+  if (AteExtraColon || Tok.is(tok::colon)) {
+    if (!AteExtraColon)
+      ConsumeToken();
 
+    while (true) {
+      if (Tok.isNot(tok::identifier)) {
+        Diag(Tok, diag::err_expected) << tok::identifier;
+        SkipUntil(tok::r_paren, StopAtSemi);
+        return StmtError();
+      }
+      LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
+                                                  Tok.getLocation());
+      Names.push_back(Tok.getIdentifierInfo());
+      if (!LD) {
+        SkipUntil(tok::r_paren, StopAtSemi);
+        return StmtError();
+      }
+      ExprResult Res =
+          Actions.ActOnAddrLabel(Tok.getLocation(), Tok.getLocation(), LD);
+      Exprs.push_back(Res.get());
+      NumLabels++;
+      ConsumeToken();
+      if (!TryConsumeToken(tok::comma))
+        break;
+    }
+  } else if (isGotoAsm) {
+    Diag(Tok, diag::err_expected) << tok::colon;
+    SkipUntil(tok::r_paren, StopAtSemi);
+    return StmtError();
+  }
   T.consumeClose();
   return Actions.ActOnGCCAsmStmt(
       AsmLoc, false, isVolatile, NumOutputs, NumInputs, Names.data(),
-      Constraints, Exprs, AsmString.get(), Clobbers, T.getCloseLocation());
+      Constraints, Exprs, AsmString.get(), Clobbers, NumLabels,
+      T.getCloseLocation());
 }
 
 /// ParseAsmOperands - Parse the asm-operands production as used by
 /// asm-statement, assuming the leading ':' token was eaten.
 ///
 /// [GNU] asm-operands:
 ///         asm-operand
 ///         asm-operands ',' asm-operand

lib/Sema/JumpDiagnostics.cpp

GotoScope(unsigned parentScope, unsigned InDiag, unsigned OutDiag,
               SourceLocation L)
       : ParentScope(parentScope), InDiag(InDiag), OutDiag(OutDiag), Loc(L) {}
   };
 
   SmallVector<GotoScope, 48> Scopes;
   llvm::DenseMap<Stmt*, unsigned> LabelAndGotoScopes;
   SmallVector<Stmt*, 16> Jumps;
 
-  SmallVector<IndirectGotoStmt*, 4> IndirectJumps;
+  SmallVector<Stmt*, 4> IndirectJumps;
+  SmallVector<Stmt*, 4> AsmJumps;
   SmallVector<LabelDecl*, 4> IndirectJumpTargets;
+  SmallVector<LabelDecl*, 4> AsmJumpTargets;
 public:
   JumpScopeChecker(Stmt *Body, Sema &S);
 private:
   void BuildScopeInformation(Decl *D, unsigned &ParentScope);
   void BuildScopeInformation(VarDecl *D, const BlockDecl *BDecl,
                              unsigned &ParentScope);
   void BuildScopeInformation(Stmt *S, unsigned &origParentScope);
 
   void VerifyJumps();
-  void VerifyIndirectJumps();
+  void VerifyIndirectOrAsmJumps(bool IsAsmGoto);
   void NoteJumpIntoScopes(ArrayRef<unsigned> ToScopes);
-  void DiagnoseIndirectJump(IndirectGotoStmt *IG, unsigned IGScope,
-                            LabelDecl *Target, unsigned TargetScope);
+  void DiagnoseIndirectOrAsmJump(Stmt *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);
 
   unsigned GetDeepestCommonScope(unsigned A, unsigned B);
 };
 } // end anonymous namespace
 
 #define CHECK_PERMISSIVE(x) (assert(Permissive || !(x)), (Permissive && (x)))
 
 JumpScopeChecker::JumpScopeChecker(Stmt *Body, Sema &s)
     : S(s), Permissive(s.hasAnyUnrecoverableErrorsInThisFunction()) {
   // Add a scope entry for function scope.
   Scopes.push_back(GotoScope(~0U, ~0U, ~0U, SourceLocation()));
 
   // Build information for the top level compound statement, so that we have a
   // defined scope record for every "goto" and label.
   unsigned BodyParentScope = 0;
   BuildScopeInformation(Body, BodyParentScope);
 
   // Check that all jumps we saw are kosher.
   VerifyJumps();
-  VerifyIndirectJumps();
+  VerifyIndirectOrAsmJumps(false);
+  VerifyIndirectOrAsmJumps(true);
 }
 
 /// GetDeepestCommonScope - Finds the innermost scope enclosing the
 /// two scopes.
 unsigned JumpScopeChecker::GetDeepestCommonScope(unsigned A, unsigned B) {
   while (A != B) {
     // Inner scopes are created after outer scopes and therefore have
     // higher indices.
case Stmt::IndirectGotoStmtClass:
     // we detect as constant targets.
     if (cast<IndirectGotoStmt>(S)->getConstantTarget()) {
       LabelAndGotoScopes[S] = ParentScope;
       Jumps.push_back(S);
       return;
     }
 
     LabelAndGotoScopes[S] = ParentScope;
-    IndirectJumps.push_back(cast<IndirectGotoStmt>(S));
+    IndirectJumps.push_back(S);
     break;
 
   case Stmt::SwitchStmtClass:
     // Evaluate the C++17 init stmt and condition variable
     // before entering the scope of the switch statement.
     if (Stmt *Init = cast<SwitchStmt>(S)->getInit()) {
       BuildScopeInformation(Init, ParentScope);
       ++StmtsToSkip;
     }
     if (VarDecl *Var = cast<SwitchStmt>(S)->getConditionVariable()) {
       BuildScopeInformation(Var, ParentScope);
       ++StmtsToSkip;
     }
     LLVM_FALLTHROUGH;
 
   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::GCCAsmStmtClass:
+    if (auto *GS = dyn_cast<GCCAsmStmt>(S))
+      if (GS->isAsmGoto()) {
+        // 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;
+        AsmJumps.push_back(GS);
+        for (auto *E : GS->labels())
+          AsmJumpTargets.push_back(E->getLabel());
+      }
+    break;
+
   case Stmt::IfStmtClass: {
     IfStmt *IS = cast<IfStmt>(S);
     if (!(IS->isConstexpr() || IS->isObjCAvailabilityCheck()))
       break;
 
     unsigned Diag = IS->isConstexpr() ? diag::note_protected_by_constexpr_if
                                       : diag::note_protected_by_if_available;
 
for (SwitchCase *SC = SS->getSwitchCaseList(); SC;
       else
         Loc = SC->getBeginLoc();
       CheckJump(SS, SC, Loc, diag::err_switch_into_protected_scope, 0,
                 diag::warn_cxx98_compat_switch_into_protected_scope);
     }
   }
 }
 
-/// VerifyIndirectJumps - Verify whether any possible indirect jump
-/// might cross a protection boundary.  Unlike direct jumps, indirect
-/// jumps count cleanups as protection boundaries:  since there's no
-/// way to know where the jump is going, we can't implicitly run the
-/// right cleanups the way we can with direct jumps.
-///
-/// Thus, an indirect jump is "trivial" if it bypasses no
-/// initializations and no teardowns.  More formally, an indirect jump
+/// VerifyIndirectOrAsmJumps - Verify whether any possible indirect goto or
+/// asm goto jump might cross a protection boundary.  Unlike direct jumps,
+/// indirect or asm goto jumps count cleanups as protection boundaries:
+/// since there's no way to know where the jump is going, we can't implicitly
+/// run the right cleanups the way we can with direct jumps.
+/// Thus, an indirect/asm jump is "trivial" if it bypasses no
+/// initializations and no teardowns.  More formally, an indirect/asm jump
 /// from A to B is trivial if the path out from A to DCA(A,B) is
 /// trivial and the path in from DCA(A,B) to B is trivial, where
 /// DCA(A,B) is the deepest common ancestor of A and B.
 /// Jump-triviality is transitive but asymmetric.
 ///
 /// A path in is trivial if none of the entered scopes have an InDiag.
 /// A path out is trivial is none of the exited scopes have an OutDiag.
 ///
 /// Under these definitions, this function checks that the indirect
 /// jump between A and B is trivial for every indirect goto statement A
 /// and every label B whose address was taken in the function.
-void JumpScopeChecker::VerifyIndirectJumps() {
-  if (IndirectJumps.empty()) return;
-
+void JumpScopeChecker::VerifyIndirectOrAsmJumps(bool IsAsmGoto) {
+  SmallVector<Stmt*, 4> GotoJumps = IsAsmGoto ? AsmJumps : IndirectJumps;
+  if (GotoJumps.empty())
+    return;
+  SmallVector<LabelDecl *, 4> JumpTargets =
+      IsAsmGoto ? AsmJumpTargets : IndirectJumpTargets;
   // If there aren't any address-of-label expressions in this function,
   // complain about the first indirect goto.
-  if (IndirectJumpTargets.empty()) {
-    S.Diag(IndirectJumps[0]->getGotoLoc(),
+  if (JumpTargets.empty()) {
+    assert(!IsAsmGoto &&"only indirect goto can get here");
+    S.Diag(GotoJumps[0]->getBeginLoc(),
            diag::err_indirect_goto_without_addrlabel);
     return;
   }
-
   // Collect a single representative of every scope containing an
-  // indirect goto.  For most code bases, this substantially cuts
+  // indirect or asm goto.  For most code bases, this substantially cuts
   // down on the number of jump sites we'll have to consider later.
-  typedef std::pair<unsigned, IndirectGotoStmt*> JumpScope;
+  typedef std::pair<unsigned, Stmt*> JumpScope;
   SmallVector<JumpScope, 32> JumpScopes;
   {
-    llvm::DenseMap<unsigned, IndirectGotoStmt*> JumpScopesMap;
-    for (SmallVectorImpl<IndirectGotoStmt*>::iterator
-           I = IndirectJumps.begin(), E = IndirectJumps.end(); I != E; ++I) {
-      IndirectGotoStmt *IG = *I;
+    llvm::DenseMap<unsigned, Stmt*> JumpScopesMap;
+    for (SmallVectorImpl<Stmt *>::iterator I = GotoJumps.begin(),
+                                           E = GotoJumps.end();
+         I != E; ++I) {
+      Stmt *IG = *I;
       if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(IG)))
         continue;
       unsigned IGScope = LabelAndGotoScopes[IG];
-      IndirectGotoStmt *&Entry = JumpScopesMap[IGScope];
+      Stmt *&Entry = JumpScopesMap[IGScope];
       if (!Entry) Entry = IG;
     }
     JumpScopes.reserve(JumpScopesMap.size());
-    for (llvm::DenseMap<unsigned, IndirectGotoStmt*>::iterator
-           I = JumpScopesMap.begin(), E = JumpScopesMap.end(); I != E; ++I)
+    for (llvm::DenseMap<unsigned, Stmt *>::iterator I = JumpScopesMap.begin(),
+                                                    E = JumpScopesMap.end();
+         I != E; ++I)
       JumpScopes.push_back(*I);
   }
 
   // Collect a single representative of every scope containing a
   // label whose address was taken somewhere in the function.
   // For most code bases, there will be only one such scope.
   llvm::DenseMap<unsigned, LabelDecl*> TargetScopes;
-  for (SmallVectorImpl<LabelDecl*>::iterator
-         I = IndirectJumpTargets.begin(), E = IndirectJumpTargets.end();
+  for (SmallVectorImpl<LabelDecl *>::iterator I = JumpTargets.begin(),
+                                              E = JumpTargets.end();
        I != E; ++I) {
     LabelDecl *TheLabel = *I;
     if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(TheLabel->getStmt())))
       continue;
     unsigned LabelScope = LabelAndGotoScopes[TheLabel->getStmt()];
     LabelDecl *&Target = TargetScopes[LabelScope];
     if (!Target) Target = TheLabel;
   }
for (SmallVectorImpl<JumpScope>::iterator
         if (Scopes[Scope].OutDiag) break;
 
         Scope = Scopes[Scope].ParentScope;
       }
 
       // Only diagnose if we didn't find something.
       if (IsReachable) continue;
 
-      DiagnoseIndirectJump(I->second, I->first, TargetLabel, TargetScope);
+      DiagnoseIndirectOrAsmJump(I->second, I->first, TargetLabel, TargetScope);
     }
   }
 }
 
 /// Return true if a particular error+note combination must be downgraded to a
 /// warning in Microsoft mode.
 static bool IsMicrosoftJumpWarning(unsigned JumpDiag, unsigned InDiagNote) {
   return (JumpDiag == diag::err_goto_into_protected_scope &&
          (InDiagNote == diag::note_protected_by_variable_init ||
           InDiagNote == diag::note_protected_by_variable_nontriv_destructor));
 }
 
 /// Return true if a particular note should be downgraded to a compatibility
 /// warning in C++11 mode.
 static bool IsCXX98CompatWarning(Sema &S, unsigned InDiagNote) {
   return S.getLangOpts().CPlusPlus11 &&
          InDiagNote == diag::note_protected_by_variable_non_pod;
 }
 
 /// Produce primary diagnostic for an indirect jump statement.
-static void DiagnoseIndirectJumpStmt(Sema &S, IndirectGotoStmt *Jump,
+static void DiagnoseIndirectOrAsmJumpStmt(Sema &S, Stmt *Jump,
                                           LabelDecl *Target, bool &Diagnosed) {
   if (Diagnosed)
     return;
-  S.Diag(Jump->getGotoLoc(), diag::err_indirect_goto_in_protected_scope);
-  S.Diag(Target->getStmt()->getIdentLoc(), diag::note_indirect_goto_target);
+  bool IsAsmGoto = isa<GCCAsmStmt>(Jump);
+  S.Diag(Jump->getBeginLoc(), diag::err_indirect_goto_in_protected_scope)
+      << IsAsmGoto;
+  S.Diag(Target->getStmt()->getIdentLoc(), diag::note_indirect_goto_target)
+      << IsAsmGoto;
   Diagnosed = true;
 }
 
 /// Produce note diagnostics for a jump into a protected scope.
 void JumpScopeChecker::NoteJumpIntoScopes(ArrayRef<unsigned> ToScopes) {
   if (CHECK_PERMISSIVE(ToScopes.empty()))
     return;
   for (unsigned I = 0, E = ToScopes.size(); I != E; ++I)
     if (Scopes[ToScopes[I]].InDiag)
       S.Diag(Scopes[ToScopes[I]].Loc, Scopes[ToScopes[I]].InDiag);
 }
 
 /// Diagnose an indirect jump which is known to cross scopes.
-void JumpScopeChecker::DiagnoseIndirectJump(IndirectGotoStmt *Jump,
-                                            unsigned JumpScope,
+void JumpScopeChecker::DiagnoseIndirectOrAsmJump(Stmt *Jump, unsigned JumpScope,
                                                  LabelDecl *Target,
                                                  unsigned TargetScope) {
   if (CHECK_PERMISSIVE(JumpScope == TargetScope))
     return;
 
   unsigned Common = GetDeepestCommonScope(JumpScope, TargetScope);
   bool Diagnosed = false;
 
   // Walk out the scope chain until we reach the common ancestor.
   for (unsigned I = JumpScope; I != Common; I = Scopes[I].ParentScope)
     if (Scopes[I].OutDiag) {
-      DiagnoseIndirectJumpStmt(S, Jump, Target, Diagnosed);
+      DiagnoseIndirectOrAsmJumpStmt(S, Jump, Target, Diagnosed);
       S.Diag(Scopes[I].Loc, Scopes[I].OutDiag);
     }
 
   SmallVector<unsigned, 10> ToScopesCXX98Compat;
 
   // Now walk into the scopes containing the label whose address was taken.
   for (unsigned I = TargetScope; I != Common; I = Scopes[I].ParentScope)
     if (IsCXX98CompatWarning(S, Scopes[I].InDiag))
       ToScopesCXX98Compat.push_back(I);
     else if (Scopes[I].InDiag) {
-      DiagnoseIndirectJumpStmt(S, Jump, Target, Diagnosed);
+      DiagnoseIndirectOrAsmJumpStmt(S, Jump, Target, Diagnosed);
       S.Diag(Scopes[I].Loc, Scopes[I].InDiag);
     }
 
   // Diagnose this jump if it would be ill-formed in C++98.
   if (!Diagnosed && !ToScopesCXX98Compat.empty()) {
-    S.Diag(Jump->getGotoLoc(),
-           diag::warn_cxx98_compat_indirect_goto_in_protected_scope);
-    S.Diag(Target->getStmt()->getIdentLoc(), diag::note_indirect_goto_target);
+    bool IsAsmGoto = isa<GCCAsmStmt>(Jump);
+    S.Diag(Jump->getBeginLoc(),
+           diag::warn_cxx98_compat_indirect_goto_in_protected_scope)
+        << IsAsmGoto;
+    S.Diag(Target->getStmt()->getIdentLoc(), diag::note_indirect_goto_target)
+        << IsAsmGoto;
     NoteJumpIntoScopes(ToScopesCXX98Compat);
   }
 }
 
 /// CheckJump - Validate that the specified jump statement is valid: that it is
 /// jumping within or out of its current scope, not into a deeper one.
 void JumpScopeChecker::CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
                                unsigned JumpDiagError, unsigned JumpDiagWarning,

lib/Sema/SemaStmtAsm.cpp

 }
 
 // Checks if there is a conflict between the input and output lists with the
 // clobbers list. If there's a conflict, returns the location of the
 // conflicted clobber, else returns nullptr
 static SourceLocation
 getClobberConflictLocation(MultiExprArg Exprs, StringLiteral **Constraints,
                            StringLiteral **Clobbers, int NumClobbers,
+                           unsigned NumLabels,
                            const TargetInfo &Target, ASTContext &Cont) {
   llvm::StringSet<> InOutVars;
   // Collect all the input and output registers from the extended asm
   // statement in order to check for conflicts with the clobber list
-  for (unsigned int i = 0; i < Exprs.size(); ++i) {
+  for (unsigned int i = 0; i < Exprs.size() - NumLabels; ++i) {
     StringRef Constraint = Constraints[i]->getString();
     StringRef InOutReg = Target.getConstraintRegister(
         Constraint, extractRegisterName(Exprs[i], Target));
     if (InOutReg != "")
       InOutVars.insert(InOutReg);
   }
   // Check for each item in the clobber list if it conflicts with the input
   // or output
getClobberConflictLocation(MultiExprArg Exprs, StringLiteral **Constraints,
   return SourceLocation();
 }
 
 StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                                  bool IsVolatile, unsigned NumOutputs,
                                  unsigned NumInputs, IdentifierInfo **Names,
                                  MultiExprArg constraints, MultiExprArg Exprs,
                                  Expr *asmString, MultiExprArg clobbers,
+                                 unsigned NumLabels,
                                  SourceLocation RParenLoc) {
   unsigned NumClobbers = clobbers.size();
   StringLiteral **Constraints =
     reinterpret_cast<StringLiteral**>(constraints.data());
   StringLiteral *AsmString = cast<StringLiteral>(asmString);
   StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.data());
 
   SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
for (unsigned i = 0; i != NumOutputs; i++) {
     TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
     if (!Context.getTargetInfo().validateOutputConstraint(Info)) {
       targetDiag(Literal->getBeginLoc(),
                  diag::err_asm_invalid_output_constraint)
           << Info.getConstraintStr();
       return new (Context)
           GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
                      NumInputs, Names, Constraints, Exprs.data(), AsmString,
-                     NumClobbers, Clobbers, RParenLoc);
+                     NumClobbers, Clobbers, NumLabels, RParenLoc);
     }
 
     ExprResult ER = CheckPlaceholderExpr(Exprs[i]);
     if (ER.isInvalid())
       return StmtError();
     Exprs[i] = ER.get();
 
     // Check that the output exprs are valid lvalues.
for (unsigned i = 0; i != NumOutputs; i++) {
     unsigned Size = Context.getTypeSize(OutputExpr->getType());
     if (!Context.getTargetInfo().validateOutputSize(Literal->getString(),
                                                     Size)) {
       targetDiag(OutputExpr->getBeginLoc(), diag::err_asm_invalid_output_size)
           << Info.getConstraintStr();
       return new (Context)
           GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
                      NumInputs, Names, Constraints, Exprs.data(), AsmString,
-                     NumClobbers, Clobbers, RParenLoc);
+                     NumClobbers, Clobbers, NumLabels, RParenLoc);
     }
   }
 
   SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
 
   for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
     StringLiteral *Literal = Constraints[i];
     assert(Literal->isAscii());
 
     StringRef InputName;
     if (Names[i])
       InputName = Names[i]->getName();
 
     TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
     if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos,
                                                          Info)) {
       targetDiag(Literal->getBeginLoc(), diag::err_asm_invalid_input_constraint)
           << Info.getConstraintStr();
       return new (Context)
           GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
                      NumInputs, Names, Constraints, Exprs.data(), AsmString,
-                     NumClobbers, Clobbers, RParenLoc);
+                     NumClobbers, Clobbers, NumLabels, RParenLoc);
     }
 
     ExprResult ER = CheckPlaceholderExpr(Exprs[i]);
     if (ER.isInvalid())
       return StmtError();
     Exprs[i] = ER.get();
 
     Expr *InputExpr = Exprs[i];
for (unsigned i = 0; i != NumClobbers; i++) {
     StringRef Clobber = Literal->getString();
 
     if (!Context.getTargetInfo().isValidClobber(Clobber)) {
       targetDiag(Literal->getBeginLoc(), diag::err_asm_unknown_register_name)
           << Clobber;
       return new (Context)
           GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
                      NumInputs, Names, Constraints, Exprs.data(), AsmString,
-                     NumClobbers, Clobbers, RParenLoc);
+                     NumClobbers, Clobbers, NumLabels, RParenLoc);
     }
   }
 
   GCCAsmStmt *NS =
     new (Context) GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
                              NumInputs, Names, Constraints, Exprs.data(),
-                             AsmString, NumClobbers, Clobbers, RParenLoc);
+                             AsmString, NumClobbers, Clobbers, NumLabels,
+                             RParenLoc);
   // Validate the asm string, ensuring it makes sense given the operands we
   // have.
   SmallVector<GCCAsmStmt::AsmStringPiece, 8> Pieces;
   unsigned DiagOffs;
   if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
     targetDiag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
         << AsmString->getSourceRange();
     return NS;
   }
 
   // Validate constraints and modifiers.
   for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {
     GCCAsmStmt::AsmStringPiece &Piece = Pieces[i];
     if (!Piece.isOperand()) continue;
 
     // Look for the correct constraint index.
     unsigned ConstraintIdx = Piece.getOperandNo();
+    // Labels are the last in the Exprs list.
+    if (NS->isAsmGoto() && ConstraintIdx >= NS->getNumInputs())
+      continue;
     unsigned NumOperands = NS->getNumOutputs() + NS->getNumInputs();
-
     // Look for the (ConstraintIdx - NumOperands + 1)th constraint with
     // modifier '+'.
     if (ConstraintIdx >= NumOperands) {
       unsigned I = 0, E = NS->getNumOutputs();
 
       for (unsigned Cnt = ConstraintIdx - NumOperands; I != E; ++I)
         if (OutputConstraintInfos[I].isReadWrite() && Cnt-- == 0) {
           ConstraintIdx = I;
targetDiag(InputExpr->getBeginLoc(), diag::err_asm_tying_incompatible_types)
         << InTy << OutTy << OutputExpr->getSourceRange()
         << InputExpr->getSourceRange();
     return NS;
   }
 
   // Check for conflicts between clobber list and input or output lists
   SourceLocation ConstraintLoc =
       getClobberConflictLocation(Exprs, Constraints, Clobbers, NumClobbers,
+                                 NumLabels,
                                  Context.getTargetInfo(), Context);
   if (ConstraintLoc.isValid())
     targetDiag(ConstraintLoc, diag::error_inoutput_conflict_with_clobber);
 
+  // Check for duplicate asm operand name between input, output and label lists.
+  typedef std::pair<StringRef , Expr *> NamedOperand;
+  SmallVector<NamedOperand, 4> NamedOperandList;
+  for (unsigned i = 0, e = NumOutputs + NumInputs + NumLabels; i != e; ++i)
+    if (Names[i])
+      NamedOperandList.emplace_back(
+          std::make_pair(Names[i]->getName(), Exprs[i]));
+  // Sort NamedOperandList.
+  stable_sort(NamedOperandList.begin(), NamedOperandList.end(),
+              [](const NamedOperand &LHS, const NamedOperand &RHS) {
+                return LHS.first < RHS.first;
+              });
+  // Find adjacent duplicate operand.
+  SmallVector<NamedOperand, 4>::iterator Found =
+      std::adjacent_find(begin(NamedOperandList), end(NamedOperandList),
+                         [](const NamedOperand &LHS, const NamedOperand &RHS) {
+                           return LHS.first == RHS.first;
+                         });
+  if (Found != NamedOperandList.end()) {
+    Diag((Found + 1)->second->getBeginLoc(),
+         diag::error_duplicate_asm_operand_name)
+        << (Found + 1)->first;
+    Diag(Found->second->getBeginLoc(), diag::note_duplicate_asm_operand_name)
+        << Found->first;
+    return StmtError();
+  }
+  if (NS->isAsmGoto())
+    setFunctionHasBranchIntoScope();
   return NS;
 }
 
 void Sema::FillInlineAsmIdentifierInfo(Expr *Res,
                                        llvm::InlineAsmIdentifierInfo &Info) {
   QualType T = Res->getType();
   Expr::EvalResult Eval;
   if (T->isFunctionType() || T->isDependentType())

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 RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                                bool IsVolatile, unsigned NumOutputs,
                                unsigned NumInputs, IdentifierInfo **Names,
                                MultiExprArg Constraints, MultiExprArg Exprs,
                                Expr *AsmString, MultiExprArg Clobbers,
+                               unsigned NumLabels,
                                SourceLocation RParenLoc) {
     return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
                                      NumInputs, Names, Constraints, Exprs,
-                                     AsmString, Clobbers, RParenLoc);
+                                     AsmString, Clobbers, NumLabels, RParenLoc);
   }
 
   /// Build a new MS style inline asm statement.
   ///
   /// 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,
for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
     if (Result.isInvalid())
       return StmtError();
 
     ExprsChanged |= Result.get() != InputExpr;
 
     Exprs.push_back(Result.get());
   }
 
+  // Go through the Labels.
+  for (unsigned I = 0, E = S->getNumLabels(); I != E; ++I) {
+    Names.push_back(S->getLabelIdentifier(I));
+
+    ExprResult Result = getDerived().TransformExpr(S->getLabelExpr(I));
+    if (Result.isInvalid())
+      return StmtError();
+    ExprsChanged |= Result.get() != S->getLabelExpr(I);
+    Exprs.push_back(Result.get());
+  }
   if (!getDerived().AlwaysRebuild() && !ExprsChanged)
     return S;
 
   // Go through the clobbers.
   for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
     Clobbers.push_back(S->getClobberStringLiteral(I));
 
   // No need to transform the asm string literal.
   AsmString = S->getAsmString();
   return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
                                         S->isVolatile(), S->getNumOutputs(),
                                         S->getNumInputs(), Names.data(),
                                         Constraints, Exprs, AsmString.get(),
-                                        Clobbers, S->getRParenLoc());
+                                        Clobbers, S->getNumLabels(),
+                                        S->getRParenLoc());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
   ArrayRef<Token> AsmToks =
     llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
 

lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
   S->NumClobbers = Record.readInt();
   S->setAsmLoc(ReadSourceLocation());
   S->setVolatile(Record.readInt());
   S->setSimple(Record.readInt());
 }
 
 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
   VisitAsmStmt(S);
+  S->NumLabels = Record.readInt();
   S->setRParenLoc(ReadSourceLocation());
   S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));
 
   unsigned NumOutputs = S->getNumOutputs();
   unsigned NumInputs = S->getNumInputs();
   unsigned NumClobbers = S->getNumClobbers();
+  unsigned NumLabels = S->getNumLabels();
 
   // Outputs and inputs
   SmallVector<IdentifierInfo *, 16> Names;
   SmallVector<StringLiteral*, 16> Constraints;
   SmallVector<Stmt*, 16> Exprs;
   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
     Names.push_back(Record.getIdentifierInfo());
     Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
     Exprs.push_back(Record.readSubStmt());
   }
 
   // Constraints
   SmallVector<StringLiteral*, 16> Clobbers;
   for (unsigned I = 0; I != NumClobbers; ++I)
     Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
 
+  // Labels
+  for (unsigned I = 0, N = NumLabels; I != N; ++I)
+    Exprs.push_back(Record.readSubStmt());
+
   S->setOutputsAndInputsAndClobbers(Record.getContext(),
                                     Names.data(), Constraints.data(),
                                     Exprs.data(), NumOutputs, NumInputs,
+                                    NumLabels,
                                     Clobbers.data(), NumClobbers);
 }
 
 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
   VisitAsmStmt(S);
   S->LBraceLoc = ReadSourceLocation();
   S->EndLoc = ReadSourceLocation();
   S->NumAsmToks = Record.readInt();

lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
   Record.push_back(S->getNumClobbers());
   Record.AddSourceLocation(S->getAsmLoc());
   Record.push_back(S->isVolatile());
   Record.push_back(S->isSimple());
 }
 
 void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {
   VisitAsmStmt(S);
+  Record.push_back(S->getNumLabels());
   Record.AddSourceLocation(S->getRParenLoc());
   Record.AddStmt(S->getAsmString());
 
   // Outputs
   for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
     Record.AddIdentifierRef(S->getOutputIdentifier(I));
     Record.AddStmt(S->getOutputConstraintLiteral(I));
     Record.AddStmt(S->getOutputExpr(I));
   }
 
   // Inputs
   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
     Record.AddIdentifierRef(S->getInputIdentifier(I));
     Record.AddStmt(S->getInputConstraintLiteral(I));
     Record.AddStmt(S->getInputExpr(I));
   }
 
   // Clobbers
   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
     Record.AddStmt(S->getClobberStringLiteral(I));
 
+  // Labels
+  for (auto *E : S->labels()) Record.AddStmt(E);
+
   Code = serialization::STMT_GCCASM;
 }
 
 void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
   VisitAsmStmt(S);
   Record.AddSourceLocation(S->getLBraceLoc());
   Record.AddSourceLocation(S->getEndLoc());
   Record.push_back(S->getNumAsmToks());

test/Analysis/asm-goto.cpp

+// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 | FileCheck %s
+
+int foo(int cond)
+{
+label_true:
+  asm goto("testl %0, %0; jne %l1;" :: "r"(cond)::label_true, loop);
+  return 0;
+loop:
+  return 0;
+}
+
+// CHECK-LABEL: loop
+// CHECK-NEXT: 0
+// CHECK-NEXT: return
+// CHECK-NEXT: Preds (1): B3
+// CHECK-NEXT: Succs (1): B0
+
+// CHECK-LABEL: label_true
+// CHECK-NEXT: asm goto
+// CHECK-NEXT: Preds (2): B3 B4
+// CHECK-NEXT: Succs (3): B2 B3 B1
+
+
+int bar(int cond)
+{
+  asm goto("testl %0, %0; jne %l1;" :: "r"(cond)::L1, L2);
+  return 0;
+L1:
+L2:
+  return 0;
+}
+
+// CHECK: [B4]
+// CHECK-NEXT: asm goto
+// CHECK-NEXT: Preds (1): B5
+// CHECK-NEXT: Succs (3): B3 B2 B1
+
+int zoo(int n)
+{
+A5:
+A1:
+  asm goto("testl %0, %0; jne %l1;" :: "r"(n)::A1, A2, A3, A4, A5);
+A2:
+A3:
+A4:
+  return 0;
+}
+
+// CHECK-LABEL: A1
+// CHECK-NEXT: asm goto
+// CHECK-NEXT: Preds (2): B5 B4
+// CHECK-NEXT: Succs (5): B3 B4 B2 B1 B5

test/CodeGen/asm-goto.c

+// RUN: %clang_cc1 -O0 -emit-llvm  %s -o - | FileCheck %s
+
+int foo(int cond)
+{
+  // CHECK: callbr void asm sideeffect
+  // CHECK: to label %asm.fallthrough [label %label_true, label %loop], !srcloc !2
+  // CHECK: asm.fallthrough:
+  asm volatile goto("testl %0, %0; jne %l1;" :: "r"(cond)::label_true, loop);
+  asm volatile goto("testl %0, %0; jne %l1;" :: "r"(cond)::label_true, loop);
+  // CHECK: callbr void asm sideeffect
+  // CHECK: to label %asm.fallthrough1 [label %label_true, label %loop], !srcloc !3
+  // CHECK: asm.fallthrough1:
+  return 0;
+loop:
+  return 0;
+label_true:
+  return 1;
+}

test/CodeGen/asm.c

 }
 
 void t31(int len) {
   __asm__ volatile(""
                    : "+%%rm"(len), "+rm"(len));
   // CHECK: @t31
   // CHECK: call void asm sideeffect "", "=*%rm,=*rm,0,1,~{dirflag},~{fpsr},~{flags}"
 }
+
+// CHECK: @t32
+int t32(int cond)
+{
+  asm goto("testl %0, %0; jne %l1;" :: "r"(cond)::label_true, loop);
+  // CHECK: callbr void asm sideeffect "testl $0, $0; jne ${1:l};", "r,X,X,~{dirflag},~{fpsr},~{flags}"(i32 %0, i8* blockaddress(@t32, %label_true), i8* blockaddress(@t32, %loop)) #1
+  return 0;
+loop:
+  return 0;
+label_true:
+  return 1;
+}

test/CodeGen/inline-asm-mixed-style.c

-// RUN: %clang_cc1 -triple i386-unknown-unknown -fasm-blocks -fsyntax-only -verify %s -DCHECK_ASM_GOTO
 // RUN: %clang_cc1 -triple i386-unknown-unknown -fasm-blocks -O0 -emit-llvm -S %s -o - | FileCheck %s
 // REQUIRES: x86-registered-target
 
 void f() {
   __asm mov eax, ebx
   __asm mov ebx, ecx
   __asm__("movl %ecx, %edx");
   // CHECK: movl    %ebx, %eax
   // CHECK: movl    %ecx, %ebx
   // CHECK: movl    %ecx, %edx
 
   __asm mov eax, ebx
   __asm volatile ("movl %ecx, %edx");
   // CHECK: movl    %ebx, %eax
   // CHECK: movl    %ecx, %edx
 
   __asm mov eax, ebx
   __asm const ("movl %ecx, %edx"); // expected-warning {{ignored const qualifier on asm}} 
   // CHECK: movl    %ebx, %eax
   // CHECK: movl    %ecx, %edx
 
-#ifdef CHECK_ASM_GOTO
-  __asm volatile goto ("movl %ecx, %edx"); // expected-error {{'asm goto' constructs are not supported yet}}
+  __asm volatile goto ("movl %ecx, %edx");
+  // CHECK: movl    %ecx, %edx
 
   __asm mov eax, ebx
-  __asm goto ("movl %ecx, %edx"); // expected-error {{'asm goto' constructs are not supported yet}}
-#endif
+  __asm goto ("movl %ecx, %edx");
+  // CHECK: movl    %ebx, %eax
+  // CHECK: movl    %ecx, %edx
 }

test/Coverage/c-language-features.inc

theif:
   case 0:
   case 1 ... 2:
     break;
   default:
     break;
   }
 
   asm ("nop");
-
+  int cond;
+  asm goto("testl %0, %0; jne %l1;" :: "r"(cond)::label_true);
+label_true:
   return;
 }
 
 // Expressions.
 
 #include <stdarg.h>
 
 typedef struct ipair {

test/PCH/asm.h

 // Header for the PCH test asm.c
 
 void f() {
-  int i;
+  int i,cond;
 
   asm ("foo\n" : : "a" (i + 2));
   asm ("foo\n" : [symbolic_name] "=a" (i) : "[symbolic_name]" (i));
+  asm volatile goto("testl %0, %0; jne %l1;" :: "r"(cond)::label_true, loop);
+label_true:
+loop:
+  return;
 }
 
 void clobbers() {
   asm ("nop" : : : "ax", "#ax", "%ax");
   asm ("nop" : : : "eax", "rax", "ah", "al");
   asm ("nop" : : : "0", "%0", "#0");
 }

test/Parser/asm.c

void f2() {
   asm const (""); // expected-warning {{ignored const qualifier on asm}}
   asm volatile ("");
   asm restrict (""); // expected-warning {{ignored restrict qualifier on asm}}
   // FIXME: Once GCC supports _Atomic, check whether it allows this.
   asm _Atomic (""); // expected-warning {{ignored _Atomic qualifier on asm}}
 }
 
 
+int a, b, c, d, e, f, g, h, i, j, k, l;
+
+void
+fgoto1 (void)
+{
+  __asm__ volatile goto (""
+            :: [a] "r" (a), [b] "r" (b), [c] "r" (c), [d] "r" (d),
+               [e] "r" (e), [f] "r" (f), [g] "r" (g), [h] "r" (h),
+               [i] "r" (i), [j] "r" (j), [k] "r" (k), [l] "r" (l)
+            ::lab1,lab2);
+lab1: return;
+lab2: return;
+}
+
+void
+fgoto2 (void)
+{
+  __asm__ volatile goto (""
+            :: [a] "r,m" (a), [b] "r,m" (b), [c] "r,m" (c), [d] "r,m" (d),
+               [e] "r,m" (e), [f] "r,m" (f), [g] "r,m" (g), [h] "r,m" (h),
+               [i] "r,m" (i), [j] "r,m" (j), [k] "r,m" (k), [l] "r,m" (l)
+            :: lab);
+  lab: return;
+}
+
+int zoo ()
+{
+  int x,cond,*e;
+  // expected-error@+1 {{expected ')'}}
+  asm ("mov %[e], %[e]" : : [e] "rm" (*e)::a)
+  // expected-error@+1 {{'asm goto' cannot have output constraints}}
+  asm goto ("decl %0; jnz %l[a]" :"=r"(x): "m"(x) : "memory" : a);
+  // expected-error@+1 {{expected identifie}}
+  asm goto ("decl %0;" :: "m"(x) : "memory" : );
+  // expected-error@+1 {{expected ':'}}
+  asm goto ("decl %0;" :: "m"(x) : "memory" );
+  // expected-error@+1 {{use of undeclared label 'x'}}
+  asm goto ("decl %0;" :: "m"(x) : "memory" :x);
+  // expected-error@+1 {{use of undeclared label 'b'}}
+  asm goto ("decl %0;" :: "m"(x) : "memory" :b);
+  // expected-error@+1 {{invalid operand number in inline asm string}}
+  asm goto ("testl %0, %0; jne %l3;" :: "r"(cond)::label_true, loop);
+  // expected-error@+1 {{unknown symbolic operand name in inline assembly string}}
+  asm goto ("decl %0; jnz %l[b]" :: "m"(x) : "memory" : a);
+a:
+label_true:
+loop:
+  return 0;
+}
+
 // rdar://5952468
 __asm ; // expected-error {{expected '(' after 'asm'}}
 
 // <rdar://problem/10465079> - Don't crash on wide string literals in 'asm'.
 int foo asm (L"bar"); // expected-error {{cannot use wide string literal in 'asm'}}
 
 asm() // expected-error {{expected string literal in 'asm'}}
 // expected-error@-1 {{expected ';' after top-level asm block}}

test/Parser/asm.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 int foo1 asm ("bar1");
 int foo2 asm (L"bar2"); // expected-error {{cannot use wide string literal in 'asm'}}
 int foo3 asm (u8"bar3"); // expected-error {{cannot use unicode string literal in 'asm'}}
 int foo4 asm (u"bar4"); // expected-error {{cannot use unicode string literal in 'asm'}}
 int foo5 asm (U"bar5"); // expected-error {{cannot use unicode string literal in 'asm'}}
 int foo6 asm ("bar6"_x); // expected-error {{string literal with user-defined suffix cannot be used here}}
 int foo6 asm ("" L"bar7"); // expected-error {{cannot use wide string literal in 'asm'}}
+
+int zoo ()
+{
+  int x,cond,*e;
+  // expected-error@+1 {{expected ')'}}
+  asm ("mov %[e], %[e]" : : [e] "rm" (*e)::a)
+  // expected-error@+1  {{'asm goto' cannot have output constraints}}
+  asm goto ("decl %0; jnz %l[a]" :"=r"(x): "m"(x) : "memory" : a);
+  // expected-error@+1 {{expected identifie}}
+  asm goto ("decl %0;" :: "m"(x) : "memory" : );
+  // expected-error@+1  {{expected ':'}}
+  asm goto ("decl %0;" :: "m"(x) : "memory" );
+  // expected-error@+1 {{use of undeclared label 'x'}}
+  asm goto ("decl %0;" :: "m"(x) : "memory" :x);
+  // expected-error@+1 {{use of undeclared label 'b'}}
+  asm goto ("decl %0;" :: "m"(x) : "memory" :b);
+  // expected-error@+1 {{invalid operand number in inline asm string}}
+  asm goto ("testl %0, %0; jne %l3;" :: "r"(cond)::label_true, loop);
+  // expected-error@+1 {{unknown symbolic operand name in inline assembly string}}
+  asm goto ("decl %0; jnz %l[b]" :: "m"(x) : "memory" : a);
+label_true:
+loop:
+a:
+  return 0;
+}
+
+
+int a, b, c, d, e, f, g, h, i, j, k, l;
+
+void
+fgoto1 (void)
+{
+  __asm__ volatile goto (""
+            :: [a] "r" (a), [b] "r" (b), [c] "r" (c), [d] "r" (d),
+               [e] "r" (e), [f] "r" (f), [g] "r" (g), [h] "r" (h),
+               [i] "r" (i), [j] "r" (j), [k] "r" (k), [l] "r" (l)
+            ::lab1,lab2);
+lab1: return;
+lab2: return;
+}
+
+void
+fgoto2 (void)
+{
+  __asm__ volatile goto (""
+            :: [a] "r,m" (a), [b] "r,m" (b), [c] "r,m" (c), [d] "r,m" (d),
+               [e] "r,m" (e), [f] "r,m" (f), [g] "r,m" (g), [h] "r,m" (h),
+               [i] "r,m" (i), [j] "r,m" (j), [k] "r,m" (k), [l] "r,m" (l)
+            :: lab);
+  lab: return;
+}

test/Sema/asm-goto.cpp

+// RUN: %clang_cc1 %s -triple i386-pc-linux-gnu -verify -fsyntax-only
+
+struct NonTrivial {
+  ~NonTrivial();
+  int f(int);
+private:
+  int k;
+};
+void JumpDiagnostics(int n) {
+// expected-error@+1 {{cannot jump from this goto statement to its label}}
+  goto DirectJump;
+// expected-note@+1 {{jump bypasses variable with a non-trivial destructor}}
+  NonTrivial tnp1;
+
+DirectJump:
+// expected-error@+1 {{cannot jump from this asm goto statement to one of its possible targets}}
+  asm goto("jmp %l0;" ::::Later);
+// expected-note@+1 {{jump bypasses variable with a non-trivial destructor}}
+  NonTrivial tnp2;
+// expected-note@+1 {{possible target of asm goto statement}}
+Later:
+  return;
+}
+
+struct S { ~S(); };
+void foo(int a) {
+  if (a) {
+FOO:
+// expected-note@+2 {{jump exits scope of variable with non-trivial destructor}}
+// expected-note@+1 {{jump exits scope of variable with non-trivial destructor}}
+    S s;
+    void *p = &&BAR;
+// expected-error@+1 {{cannot jump from this asm goto statement to one of its possible targets}}
+  asm goto("jmp %l0;" ::::BAR);
+// expected-error@+1 {{cannot jump from this indirect goto statement to one of its possible targets}}
+    goto *p;
+    p = &&FOO;
+    goto *p;
+    return;
+  }
+// expected-note@+2 {{possible target of asm goto statement}}
+// expected-note@+1 {{possible target of indirect goto statement}}
+BAR:
+  return;
+}

test/Sema/asm.c

__asm ("addl %2, %2\n\t"
          "movl $123, %0"
          : "=a" (r0),
            "=&r" (r1)
          : "1" (t0),   // expected-note {{constraint '1' is already present here}}
            "1" (t0));  // expected-error {{more than one input constraint matches the same output '1'}}
   return r0 + r1;
 }
 
+void test18()
+{
+  // expected-error@+2 {{duplicate use of asm operand name "lab"}}
+  // expected-note@+1 {{asm operand name "lab" first referenced here}}
+  asm goto ("" : : : : lab, lab, lab2, lab);
+  // expected-error@+2 {{duplicate use of asm operand name "lab"}}
+  // expected-note@+1 {{asm operand name "lab" first referenced here}}
+  asm goto ("xorw %[lab], %[lab]; je %l[lab]" : : [lab] "i" (0) : : lab);
+lab:;
+lab2:;
+  int x,x1;
+  // expected-error@+2 {{duplicate use of asm operand name "lab"}}
+  // expected-note@+1 {{asm operand name "lab" first referenced here}}
+  asm ("" : [lab] "=r" (x),[lab] "+r" (x) : [lab1] "r" (x));
+  // expected-error@+2 {{duplicate use of asm operand name "lab"}}
+  // expected-note@+1 {{asm operand name "lab" first referenced here}}
+  asm ("" : [lab] "=r" (x1) : [lab] "r" (x));
+  // expected-error@+1 {{invalid operand number in inline asm string}}
+  asm ("jne %l0":::);
+  asm goto ("jne %l0"::::lab);
+}

test/Sema/inline-asm-validate-tmpl.cpp

 }
 
 // these should compile without error
 template <int N> void  testc(int value)
 {
   asm("rol %1, %0" :"=r"(value): "I"(N + 1));
 }
 int  foo() { testc<2>(10); }
+
+// these should compile without error
+template <int N> bool testd()
+{
+  __asm goto ("" : : : : lab);
+  return true;
+lab:
+  return false;
+}
+bool foox() { return testd<0> (); }

test/Sema/scope-check.c

L1:
     char vla[n]; // expected-note {{jump bypasses initialization}}
    L2: // expected-note {{possible target}}
     vla[0] = 'a';
   }
 }
 
 // rdar://9024687
 int test16(int [sizeof &&z]); // expected-error {{use of address-of-label extension outside of a function body}}
+
+//Asm goto:
+int test16(int n)
+{
+  // expected-error@+2 {{cannot jump from this asm goto statement to one of its possible targets}}
+  // expected-error@+1 {{cannot jump from this asm goto statement to one of its possible targets}}
+  asm volatile goto("testl %0, %0; jne %l1;" :: "r"(n)::label_true, loop);
+  // expected-note@+2 {{jump bypasses initialization of variable length array}}
+  // expected-note@+1 {{possible target of asm goto statement}}
+  return ({int a[n];label_true: 2;});
+  // expected-note@+1 {{jump bypasses initialization of variable length array}}
+  int b[n];
+// expected-note@+1 {{possible target of asm goto statement}}
+loop:
+  return 0;
+}