maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGen/ms-inline-asm.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

789 lines
25 KiB
C
Raw Normal View History

clang/test: REQUIRES: s/x86-64-registered-target/x86-registered-target/ llvm-svn: 196350
2013-12-04 11:41:33 +08:00
// REQUIRES: x86-registered-target
[OpaquePtrs][Clang] Add -no-opaque-pointers to tests (NFC) This adds -no-opaque-pointers to clang tests whose output will change when opaque pointers are enabled by default. This is intended to be part of the migration approach described in https://discourse.llvm.org/t/enabling-opaque-pointers-by-default/61322/9. The patch has been produced by replacing %clang_cc1 with %clang_cc1 -no-opaque-pointers for tests that fail with opaque pointers enabled. Worth noting that this doesn't cover all tests, there's a remaining ~40 tests not using %clang_cc1 that will need a followup change. Differential Revision: https://reviews.llvm.org/D123115
2022-04-07 18:03:55 +08:00
// RUN: %clang_cc1 -no-opaque-pointers %s -triple i386-apple-darwin10 -fasm-blocks -emit-llvm -o - | FileCheck %s
[ms-inline asm] Revert accidental commit. Sorry for the churn. llvm-svn: 166312
2012-10-20 04:38:09 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t1(void) {
[ms-inline asm] Add a very simple test case. Basically, we're only testing for crashers at the moment (and coincidentally this case was causing a crash). llvm-svn: 161520
2012-08-09 04:37:31 +08:00
// CHECK: @t1
Remove unnecessary attributes from test case. llvm-svn: 178188
2013-03-28 05:54:09 +08:00
// CHECK: call void asm sideeffect inteldialect "", "~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add a very simple test case. Basically, we're only testing for crashers at the moment (and coincidentally this case was causing a crash). llvm-svn: 161520
2012-08-09 04:37:31 +08:00
// CHECK: ret void
__asm {}
}
[ms-inline asm] Have patchMSAsmStrings() return a vector or AsmStrings. The AsmParser expects a single asm instruction, but valid ms-style inline asm statements may contain multiple instructions. This happens with asm blocks __asm { mov ebx, eax mov ecx, ebx } or when multiple asm statements are adjacent to one another __asm mov ebx, eax __asm mov ecx, ebx and __asm mov ebx, eax __asm mov ecx, ebx Currently, asm blocks are not properly handled. llvm-svn: 161780
2012-08-14 04:32:07 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t2(void) {
[ms-inline asm] Have patchMSAsmStrings() return a vector or AsmStrings. The AsmParser expects a single asm instruction, but valid ms-style inline asm statements may contain multiple instructions. This happens with asm blocks __asm { mov ebx, eax mov ecx, ebx } or when multiple asm statements are adjacent to one another __asm mov ebx, eax __asm mov ecx, ebx and __asm mov ebx, eax __asm mov ecx, ebx Currently, asm blocks are not properly handled. llvm-svn: 161780
2012-08-14 04:32:07 +08:00
// CHECK: @t2
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: call void asm sideeffect inteldialect "nop\0A\09nop\0A\09nop", "~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Have patchMSAsmStrings() return a vector or AsmStrings. The AsmParser expects a single asm instruction, but valid ms-style inline asm statements may contain multiple instructions. This happens with asm blocks __asm { mov ebx, eax mov ecx, ebx } or when multiple asm statements are adjacent to one another __asm mov ebx, eax __asm mov ecx, ebx and __asm mov ebx, eax __asm mov ecx, ebx Currently, asm blocks are not properly handled. llvm-svn: 161780
2012-08-14 04:32:07 +08:00
// CHECK: ret void
__asm nop
__asm nop
__asm nop
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t3(void) {
[ms-inline asm] Have patchMSAsmStrings() return a vector or AsmStrings. The AsmParser expects a single asm instruction, but valid ms-style inline asm statements may contain multiple instructions. This happens with asm blocks __asm { mov ebx, eax mov ecx, ebx } or when multiple asm statements are adjacent to one another __asm mov ebx, eax __asm mov ecx, ebx and __asm mov ebx, eax __asm mov ecx, ebx Currently, asm blocks are not properly handled. llvm-svn: 161780
2012-08-14 04:32:07 +08:00
// CHECK: @t3
Remove unnecessary attributes from test case. llvm-svn: 178188
2013-03-28 05:54:09 +08:00
// CHECK: call void asm sideeffect inteldialect "nop\0A\09nop\0A\09nop", "~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Have patchMSAsmStrings() return a vector or AsmStrings. The AsmParser expects a single asm instruction, but valid ms-style inline asm statements may contain multiple instructions. This happens with asm blocks __asm { mov ebx, eax mov ecx, ebx } or when multiple asm statements are adjacent to one another __asm mov ebx, eax __asm mov ecx, ebx and __asm mov ebx, eax __asm mov ecx, ebx Currently, asm blocks are not properly handled. llvm-svn: 161780
2012-08-14 04:32:07 +08:00
// CHECK: ret void
__asm nop __asm nop __asm nop
}
void t4(void) {
// CHECK: @t4
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: call void asm sideeffect inteldialect "mov ebx, eax\0A\09mov ecx, ebx", "~{ebx},~{ecx},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Have patchMSAsmStrings() return a vector or AsmStrings. The AsmParser expects a single asm instruction, but valid ms-style inline asm statements may contain multiple instructions. This happens with asm blocks __asm { mov ebx, eax mov ecx, ebx } or when multiple asm statements are adjacent to one another __asm mov ebx, eax __asm mov ecx, ebx and __asm mov ebx, eax __asm mov ecx, ebx Currently, asm blocks are not properly handled. llvm-svn: 161780
2012-08-14 04:32:07 +08:00
// CHECK: ret void
__asm mov ebx, eax
__asm mov ecx, ebx
}
void t5(void) {
// CHECK: @t5
Remove unnecessary attributes from test case. llvm-svn: 178188
2013-03-28 05:54:09 +08:00
// CHECK: call void asm sideeffect inteldialect "mov ebx, eax\0A\09mov ecx, ebx", "~{ebx},~{ecx},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Have patchMSAsmStrings() return a vector or AsmStrings. The AsmParser expects a single asm instruction, but valid ms-style inline asm statements may contain multiple instructions. This happens with asm blocks __asm { mov ebx, eax mov ecx, ebx } or when multiple asm statements are adjacent to one another __asm mov ebx, eax __asm mov ecx, ebx and __asm mov ebx, eax __asm mov ecx, ebx Currently, asm blocks are not properly handled. llvm-svn: 161780
2012-08-14 04:32:07 +08:00
// CHECK: ret void
__asm mov ebx, eax __asm mov ecx, ebx
}
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
void t6(void) {
__asm int 0x2c
// CHECK: t6
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: call void asm sideeffect inteldialect "int $$44", "~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t7(void) {
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
__asm {
(clang part) Implement MASM-flavor intel syntax behavior for inline MS asm block. Clang tests for verifying the following syntaxes: 1. 0xNN and NNh are accepted as valid hexadecimal numbers, but 0xNNh is not. 0xNN and NNh may come with optional U or L suffix. 2. NNb is accepted as a valid binary (base-2) number, but 0bNN is not. NNb may come with optional U or L suffix. Differential Revision: https://reviews.llvm.org/D22112 llvm-svn: 280556
2016-09-03 07:16:06 +08:00
int 0x2cU ; } asm comments are fun! }{
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
}
Add support for nested blocks in Microsoft inline assembly This fixes http://llvm.org/PR20204. llvm-svn: 212389
2014-07-06 13:26:54 +08:00
__asm {
{
int 0x2c ; } asm comments are fun! }{
}
}
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
__asm {}
[X86][MS]Adjacent comments within multi-line inline assembly statement Allowing adjacent comments within MS inline assembly multi-line statement Differential Revision: https://reviews.llvm.org/D28989 llvm-svn: 294120
2017-02-05 18:23:06 +08:00
__asm {
;
; label
mov eax, ebx
}
[ms-inline asm] Remove this test case and the associated special case code. llvm-svn: 162288
2012-08-22 01:01:26 +08:00
// CHECK: t7
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: call void asm sideeffect inteldialect "int $$44", "~{dirflag},~{fpsr},~{flags}"()
Remove unnecessary attributes from test case. llvm-svn: 178188
2013-03-28 05:54:09 +08:00
// CHECK: call void asm sideeffect inteldialect "", "~{dirflag},~{fpsr},~{flags}"()
[X86][MS]Adjacent comments within multi-line inline assembly statement Allowing adjacent comments within MS inline assembly multi-line statement Differential Revision: https://reviews.llvm.org/D28989 llvm-svn: 294120
2017-02-05 18:23:06 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, ebx", "~{eax},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
}
[ms-inline asm] Fixup test case to be valid ms-style asm. Fix whitespace. llvm-svn: 165045
2012-10-03 04:55:30 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
int t8(void) {
[ms-inline asm] Rework the front-end to use the API introduced in r165946. -The front-end now builds a single assembly string and feeds it to the AsmParser. The front-end iterates on a per statement basis by calling the ParseStatement() function. Please note, the calling of ParseStatement() and and any notion of MCAsmParsedOperands will be sunk into the MC layer in the near future. I plan to expose more basic APIs such as getClobbers, etc. -The enumeration of the AsmString expressions have been reworked to use SMLocs rather than assembly Pieces, which were being parsed in the front-end. -The test case, t8(), was modified due to r129223. I'll have to find a way to work around things such as these. Sorry for the large commit, but breaking this in multiple smaller commits proved too irritating. llvm-svn: 165957
2012-10-16 03:56:10 +08:00
__asm int 4 ; } comments for single-line asm
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
__asm {}
[ms-inline-asm] Fixing bug in single asm statement support Fixing a crash caused by trying to merge a single-line asm statement with an asm block that follows it, e.g: asm int 4 asm { int 5 } Now, only adjacent single-line asm statements that are not surrounded by braces will be merged into one asm call. Differential Revision: http://reviews.llvm.org/D17496 llvm-svn: 261618
2016-02-23 16:53:45 +08:00
__asm { int 5}
__asm int 6
__asm int 7
__asm {
int 8
}
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
return 10;
[ms-inline asm] Remove this test case and the associated special case code. llvm-svn: 162288
2012-08-22 01:01:26 +08:00
// CHECK: t8
[ms-inline-asm] Fixing bug in single asm statement support Fixing a crash caused by trying to merge a single-line asm statement with an asm block that follows it, e.g: asm int 4 asm { int 5 } Now, only adjacent single-line asm statements that are not surrounded by braces will be merged into one asm call. Differential Revision: http://reviews.llvm.org/D17496 llvm-svn: 261618
2016-02-23 16:53:45 +08:00
// CHECK: call i32 asm sideeffect inteldialect "int $$4", "={eax},~{dirflag},~{fpsr},~{flags}"()
// CHECK: call i32 asm sideeffect inteldialect "", "={eax},~{dirflag},~{fpsr},~{flags}"()
// CHECK: call i32 asm sideeffect inteldialect "int $$5", "={eax},~{dirflag},~{fpsr},~{flags}"()
// CHECK: call i32 asm sideeffect inteldialect "int $$6\0A\09int $$7", "={eax},~{dirflag},~{fpsr},~{flags}"()
// CHECK: call i32 asm sideeffect inteldialect "int $$8", "={eax},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
// CHECK: ret i32 10
}
[ms-inline asm] Fixup test case to be valid ms-style asm. Fix whitespace. llvm-svn: 165045
2012-10-03 04:55:30 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t9(void) {
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
__asm {
push ebx
Add support for nested blocks in Microsoft inline assembly This fixes http://llvm.org/PR20204. llvm-svn: 212389
2014-07-06 13:26:54 +08:00
{ mov ebx, 0x07 }
__asm { pop ebx }
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
}
[ms-inline asm] Remove this test case and the associated special case code. llvm-svn: 162288
2012-08-22 01:01:26 +08:00
// CHECK: t9
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call void asm sideeffect inteldialect
// CHECK-SAME: push ebx
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK-SAME: mov ebx, $$7
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK-SAME: pop ebx
// CHECK-SAME: "~{ebx},~{esp},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] More test cases to make sure buildMSAsmString() doesn't regress. llvm-svn: 161908
2012-08-15 07:48:41 +08:00
}
[ms-inline asm] Start tracking which tokens are registers and which are variables, function or label references. The former is a potential clobber. The latter is either an input or an output. Unfortunately, it's difficult to test this patch at the moment, but the added test case will eventually do so. llvm-svn: 162026
2012-08-17 01:10:59 +08:00
[ms-inline asm] Remove this test case and the associated special case code. llvm-svn: 162288
2012-08-22 01:01:26 +08:00
unsigned t10(void) {
[ms-inline asm] Start tracking which tokens are registers and which are variables, function or label references. The former is a potential clobber. The latter is either an input or an output. Unfortunately, it's difficult to test this patch at the moment, but the added test case will eventually do so. llvm-svn: 162026
2012-08-17 01:10:59 +08:00
unsigned i = 1, j;
__asm {
mov eax, i
mov j, eax
}
return j;
[ms-inline asm] Remove this test case and the associated special case code. llvm-svn: 162288
2012-08-22 01:01:26 +08:00
// CHECK: t10
MS inline asm: Allow __asm blocks to set a return value If control falls off the end of a function after an __asm block, MSVC assumes that the inline assembly filled the EAX and possibly EDX registers with an appropriate return value. This functionality is used in inline functions returning 64-bit integers in system headers, so we need some amount of compatibility. This is implemented in Clang by adding extra output constraints to every inline asm block, and storing the resulting output registers into the return value slot. If we see an asm block somewhere in the function body, we emit a normal epilogue instead of marking the end of the function with a return type unreachable. Normal returns in functions not using this functionality will overwrite the return value slot, and in most cases LLVM should be able to eliminate the dead stores. Fixes PR17201. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D5177 llvm-svn: 217187
2014-09-05 04:04:38 +08:00
// CHECK: [[r:%[a-zA-Z0-9]+]] = alloca i32, align 4
[ms-inline asm] Start tracking which tokens are registers and which are variables, function or label references. The former is a potential clobber. The latter is either an input or an output. Unfortunately, it's difficult to test this patch at the moment, but the added test case will eventually do so. llvm-svn: 162026
2012-08-17 01:10:59 +08:00
// CHECK: [[I:%[a-zA-Z0-9]+]] = alloca i32, align 4
// CHECK: [[J:%[a-zA-Z0-9]+]] = alloca i32, align 4
// CHECK: store i32 1, i32* [[I]], align 4
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call i32 asm sideeffect inteldialect
// CHECK-SAME: mov eax, $2
// CHECK-SAME: mov $0, eax
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK-SAME: "=*m,=&{eax},*m,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}})
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[RET:%[a-zA-Z0-9]+]] = load i32, i32* [[J]], align 4
[ms-inline asm] Start tracking which tokens are registers and which are variables, function or label references. The former is a potential clobber. The latter is either an input or an output. Unfortunately, it's difficult to test this patch at the moment, but the added test case will eventually do so. llvm-svn: 162026
2012-08-17 01:10:59 +08:00
// CHECK: ret i32 [[RET]]
}
[ms-inline asm] Add a helper function, isMSAsmKeyword(). These require special handling, which we don't currently handle. This is being put in place to ensure we don't do invalid symbol table lookups or try to parse invalid assembly. The test cases just makes sure the latter isn't happening. llvm-svn: 162050
2012-08-17 06:25:38 +08:00
[ms-inline asm] Remove this test case and the associated special case code. llvm-svn: 162288
2012-08-22 01:01:26 +08:00
void t11(void) {
[ms-inline asm] Add $$ before numeric constants in the IR. llvm-svn: 163581
2012-09-11 08:51:28 +08:00
__asm mov eax, 1
[ms-inline asm] Remove a bunch of parsing code from the front-end, which will be reimplemented in the AsmParser where it belongs. llvm-svn: 165825
2012-10-13 05:37:00 +08:00
// CHECK: t11
Remove unnecessary attributes from test case. llvm-svn: 178188
2013-03-28 05:54:09 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add $$ before numeric constants in the IR. llvm-svn: 163581
2012-09-11 08:51:28 +08:00
}
[ms-inline asm] If we have a single asm operand that maps to multiple MCOperands then iterate over all of then when computing clobbers, inputs and outputs. On x86 the 1-to-many mapping is a memory operand that includes a BaseReg(reg), MemScale(imm), MemIndexReg(reg), an Expr(MCExpr or imm) and a MemSegReg(reg). Invalid register (Op.getReg() == 0) are not considered when computing clobber. llvm-svn: 163728
2012-09-13 02:14:25 +08:00
[ms-inline asm] Remove a bunch of parsing code from the front-end, which will be reimplemented in the AsmParser where it belongs. llvm-svn: 165825
2012-10-13 05:37:00 +08:00
unsigned t12(void) {
[ms-inline asm] Handle the enumeration of input and output expressions in a more robust way to address a few FIXMEs. The initial implementation, r163342, built the IR asm string and then tried to patch things on the fly without enough context. Specifically, it didn't skip mnemonics nor did it track with assembly instruction an expression was related to. The new implementation patches the operands and then builds the final IR string. llvm-svn: 163756
2012-09-13 08:06:55 +08:00
unsigned i = 1, j, l = 1, m;
__asm {
mov eax, i
mov j, eax
mov eax, l
mov m, eax
}
return j + m;
[ms-inline asm] Remove a bunch of parsing code from the front-end, which will be reimplemented in the AsmParser where it belongs. llvm-svn: 165825
2012-10-13 05:37:00 +08:00
// CHECK: t12
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call i32 asm sideeffect inteldialect
// CHECK-SAME: mov eax, $3
// CHECK-SAME: mov $0, eax
// CHECK-SAME: mov eax, $4
// CHECK-SAME: mov $1, eax
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK-SAME: "=*m,=*m,=&{eax},*m,*m,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}})
[ms-inline asm] Update testcase for r166316. llvm-svn: 166317
2012-10-20 04:57:37 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t13(void) {
[ms-inline asm] Update testcase for r166316. llvm-svn: 166317
2012-10-20 04:57:37 +08:00
char i = 1;
short j = 2;
__asm movzx eax, i
__asm movzx eax, j
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t13()
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call void asm sideeffect inteldialect
// CHECK-SAME: movzx eax, byte ptr $0
// CHECK-SAME: movzx eax, word ptr $1
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK-SAME: "*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i8* elementtype(i8) %{{.*}}i, i16* elementtype(i16) %{{.*}}j)
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t13_brac(void) {
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
char i = 1;
short j = 2;
__asm movzx eax, [i]
__asm movzx eax, [j]
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t13_brac()
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call void asm sideeffect inteldialect
// CHECK-SAME: movzx eax, byte ptr $0
// CHECK-SAME: movzx eax, word ptr $1
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK-SAME: "*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i8* elementtype(i8) %{{.*}}i, i16* elementtype(i16) %{{.*}}j)
[ms-inline asm] Handle the enumeration of input and output expressions in a more robust way to address a few FIXMEs. The initial implementation, r163342, built the IR asm string and then tried to patch things on the fly without enough context. Specifically, it didn't skip mnemonics nor did it track with assembly instruction an expression was related to. The new implementation patches the operands and then builds the final IR string. llvm-svn: 163756
2012-09-13 08:06:55 +08:00
}
[ms-inline asm] Test case for r166349 and r166352. llvm-svn: 166353
2012-10-20 07:16:17 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t14(void) {
[ms-inline asm] Test case for r166349 and r166352. llvm-svn: 166353
2012-10-20 07:16:17 +08:00
unsigned i = 1, j = 2;
__asm {
.if 1
Add support for nested blocks in Microsoft inline assembly This fixes http://llvm.org/PR20204. llvm-svn: 212389
2014-07-06 13:26:54 +08:00
{ mov eax, i }
[ms-inline asm] Test case for r166349 and r166352. llvm-svn: 166353
2012-10-20 07:16:17 +08:00
.else
mov ebx, j
.endif
}
// CHECK: t14
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect ".if 1\0A\09mov eax, $0\0A\09.else\0A\09mov ebx, j\0A\09.endif", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[ms-inline asm] Test case for r166349 and r166352. llvm-svn: 166353
2012-10-20 07:16:17 +08:00
}
[ms-inline asm] Test case for r166433. llvm-svn: 166434
2012-10-23 03:43:17 +08:00
[ms-inline asm] Add a test case for the offset operator where the operand is a global variable. llvm-svn: 171919
2013-01-09 07:51:48 +08:00
int gvar = 10;
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t15(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t15
[ms-inline asm] Add a test case for the offset operator where the operand is a global variable. llvm-svn: 171919
2013-01-09 07:51:48 +08:00
int lvar = 10;
__asm mov eax, lvar ; eax = 10
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: mov eax, $0
[ms-inline asm] Add a test case for the offset operator where the operand is a global variable. llvm-svn: 171919
2013-01-09 07:51:48 +08:00
__asm mov eax, offset lvar ; eax = address of lvar
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $1
[ms-inline asm] Add a test case for the offset operator where the operand is a global variable. llvm-svn: 171919
2013-01-09 07:51:48 +08:00
__asm mov eax, offset gvar ; eax = address of gvar
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $2
[X86][AsmParser] re-introduce 'offset' operator Summary: Amend MS offset operator implementation, to more closely fit with its MS counterpart: 1. InlineAsm: evaluate non-local source entities to their (address) location 2. Provide a mean with which one may acquire the address of an assembly label via MS syntax, rather than yielding a memory reference (i.e. "offset asm_label" and "$asm_label" should be synonymous 3. address PR32530 Based on http://llvm.org/D37461 Fix broken test where the break appears unrelated. - Set up appropriate memory-input rewrites for variable references. - Intel-dialect assembly printing now correctly handles addresses by adding "offset". - Pass offsets as immediate operands (using "r" constraint for offsets of locals). Reviewed By: rnk Differential Revision: https://reviews.llvm.org/D71436
2019-12-31 03:33:56 +08:00
__asm mov eax, offset gvar+1 ; eax = 1 + address of gvar
// CHECK: mov eax, $3 + $$1
__asm mov eax, 1+offset gvar ; eax = 1 + address of gvar
// CHECK: mov eax, $4 + $$1
__asm mov eax, 1+offset gvar+1 ; eax = 2 + address of gvar
// CHECK: mov eax, $5 + $$2
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: "*m,r,i,i,i,i,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}}, i32* %{{.*}}, i32* @{{.*}}, i32* @{{.*}}, i32* @{{.*}}, i32* @{{.*}})
[ms-inline asm] Test case for r166433. llvm-svn: 166434
2012-10-23 03:43:17 +08:00
}
[ms-inline asm] Add test cases for r166592. The test cases only works if the source operand is a register. llvm-svn: 166594
2012-10-25 01:23:06 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t16(void) {
[ms-inline asm] Add test cases for r166592. The test cases only works if the source operand is a register. llvm-svn: 166594
2012-10-25 01:23:06 +08:00
int var = 10;
[X86][AsmParser] re-introduce 'offset' operator Summary: Amend MS offset operator implementation, to more closely fit with its MS counterpart: 1. InlineAsm: evaluate non-local source entities to their (address) location 2. Provide a mean with which one may acquire the address of an assembly label via MS syntax, rather than yielding a memory reference (i.e. "offset asm_label" and "$asm_label" should be synonymous 3. address PR32530 Based on http://llvm.org/D37461 Fix broken test where the break appears unrelated. - Set up appropriate memory-input rewrites for variable references. - Intel-dialect assembly printing now correctly handles addresses by adding "offset". - Pass offsets as immediate operands (using "r" constraint for offsets of locals). Reviewed By: rnk Differential Revision: https://reviews.llvm.org/D71436
2019-12-31 03:33:56 +08:00
__asm mov dword ptr [eax], offset var
[ms-inline asm] Add test cases for r166592. The test cases only works if the source operand is a register. llvm-svn: 166594
2012-10-25 01:23:06 +08:00
// CHECK: t16
[X86][AsmParser] re-introduce 'offset' operator Summary: Amend MS offset operator implementation, to more closely fit with its MS counterpart: 1. InlineAsm: evaluate non-local source entities to their (address) location 2. Provide a mean with which one may acquire the address of an assembly label via MS syntax, rather than yielding a memory reference (i.e. "offset asm_label" and "$asm_label" should be synonymous 3. address PR32530 Based on http://llvm.org/D37461 Fix broken test where the break appears unrelated. - Set up appropriate memory-input rewrites for variable references. - Intel-dialect assembly printing now correctly handles addresses by adding "offset". - Pass offsets as immediate operands (using "r" constraint for offsets of locals). Reviewed By: rnk Differential Revision: https://reviews.llvm.org/D71436
2019-12-31 03:33:56 +08:00
// CHECK: call void asm sideeffect inteldialect "mov dword ptr [eax], $0", "r,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
[ms-inline asm] Add test cases for r166592. The test cases only works if the source operand is a register. llvm-svn: 166594
2012-10-25 01:23:06 +08:00
}
[ms-inline asm] Add test cases for r166451. llvm-svn: 166600
2012-10-25 01:48:01 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t17(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t17
[ms-inline asm] Add test cases for r166451. llvm-svn: 166600
2012-10-25 01:48:01 +08:00
__asm _emit 0x4A
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .byte 0x4A
(clang part) Implement MASM-flavor intel syntax behavior for inline MS asm block. Clang tests for verifying the following syntaxes: 1. 0xNN and NNh are accepted as valid hexadecimal numbers, but 0xNNh is not. 0xNN and NNh may come with optional U or L suffix. 2. NNb is accepted as a valid binary (base-2) number, but 0bNN is not. NNb may come with optional U or L suffix. Differential Revision: https://reviews.llvm.org/D22112 llvm-svn: 280556
2016-09-03 07:16:06 +08:00
__asm _emit 0x43L
// CHECK: .byte 0x43L
[ms-inline asm] Add test cases for r166451. llvm-svn: 166600
2012-10-25 01:48:01 +08:00
__asm _emit 0x4B
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .byte 0x4B
[ms-inline-asm] Add test cases for the align/emit directives. Part of rdar://13200215 llvm-svn: 175009
2013-02-13 05:34:14 +08:00
__asm _EMIT 0x4B
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .byte 0x4B
// CHECK: "~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add test cases for r166451. llvm-svn: 166600
2012-10-25 01:48:01 +08:00
}
[ms-inline asm] Test case for r166632. llvm-svn: 166633
2012-10-25 06:22:12 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t20(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t20
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
char bar;
[ms-inline asm] Test case for r166790. llvm-svn: 166791
2012-10-27 02:04:45 +08:00
int foo;
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
char _bar[2];
int _foo[4];
__asm mov eax, LENGTH foo
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$1
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, LENGTH bar
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$1
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, LENGTH _foo
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$4
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, LENGTH _bar
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$2
[X86][MS-compatability][clang] allow MS TYPE/SIZE/LENGTH operators as a part of a compound expression This patch introduces X86AsmParser with the ability to handle the aforementioned ops within compound "MS" arithmetical expressions. Currently - only supported as a stand alone Operand, e.g.: "TYPE X" now allowed : "4 + TYPE X * 128" LLVM side: https://reviews.llvm.org/D31173 Differential Revision: https://reviews.llvm.org/D31174 llvm-svn: 298426
2017-03-22 03:33:32 +08:00
__asm mov eax, [eax + LENGTH foo * 4]
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$4]
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, TYPE foo
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$4
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, TYPE bar
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$1
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, TYPE _foo
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$4
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, TYPE _bar
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$1
[X86][MS-compatability][clang] allow MS TYPE/SIZE/LENGTH operators as a part of a compound expression This patch introduces X86AsmParser with the ability to handle the aforementioned ops within compound "MS" arithmetical expressions. Currently - only supported as a stand alone Operand, e.g.: "TYPE X" now allowed : "4 + TYPE X * 128" LLVM side: https://reviews.llvm.org/D31173 Differential Revision: https://reviews.llvm.org/D31174 llvm-svn: 298426
2017-03-22 03:33:32 +08:00
__asm mov eax, [eax + TYPE foo * 4]
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$16]
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, SIZE foo
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$4
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, SIZE bar
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$1
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, SIZE _foo
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$16
[X86][MS-compatability][clang] allow MS TYPE/SIZE/LENGTH operators as a part of a compound expression This patch introduces X86AsmParser with the ability to handle the aforementioned ops within compound "MS" arithmetical expressions. Currently - only supported as a stand alone Operand, e.g.: "TYPE X" now allowed : "4 + TYPE X * 128" LLVM side: https://reviews.llvm.org/D31173 Differential Revision: https://reviews.llvm.org/D31174 llvm-svn: 298426
2017-03-22 03:33:32 +08:00
__asm mov eax, [eax + SIZE _foo * 4]
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$64]
[ms-inline asm] Updates and test case for r172743. Part of rdar://12576868 llvm-svn: 172744
2013-01-18 03:22:48 +08:00
__asm mov eax, SIZE _bar
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$2
// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
[X86][MS-compatability][clang] allow MS TYPE/SIZE/LENGTH operators as a part of a compound expression This patch introduces X86AsmParser with the ability to handle the aforementioned ops within compound "MS" arithmetical expressions. Currently - only supported as a stand alone Operand, e.g.: "TYPE X" now allowed : "4 + TYPE X * 128" LLVM side: https://reviews.llvm.org/D31173 Differential Revision: https://reviews.llvm.org/D31174 llvm-svn: 298426
2017-03-22 03:33:32 +08:00
[ms-inline asm] Test case for r166790. llvm-svn: 166791
2012-10-27 02:04:45 +08:00
}
[ms-inline asm] Add more tests. llvm-svn: 169411
2012-12-06 03:52:05 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t21(void) {
[ms-inline asm] Add more tests. llvm-svn: 169411
2012-12-06 03:52:05 +08:00
__asm {
__asm push ebx
(clang part) Implement MASM-flavor intel syntax behavior for inline MS asm block. Clang tests for verifying the following syntaxes: 1. 0xNN and NNh are accepted as valid hexadecimal numbers, but 0xNNh is not. 0xNN and NNh may come with optional U or L suffix. 2. NNb is accepted as a valid binary (base-2) number, but 0bNN is not. NNb may come with optional U or L suffix. Differential Revision: https://reviews.llvm.org/D22112 llvm-svn: 280556
2016-09-03 07:16:06 +08:00
__asm mov ebx, 07H
[ms-inline asm] Add more tests. llvm-svn: 169411
2012-12-06 03:52:05 +08:00
__asm pop ebx
}
// CHECK: t21
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call void asm sideeffect inteldialect
// CHECK-SAME: push ebx
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK-SAME: mov ebx, $$7
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK-SAME: pop ebx
// CHECK-SAME: "~{ebx},~{esp},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add more tests. llvm-svn: 169411
2012-12-06 03:52:05 +08:00
}
extern void t22_helper(int x);
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t22(void) {
[ms-inline asm] Add more tests. llvm-svn: 169411
2012-12-06 03:52:05 +08:00
int x = 0;
__asm {
__asm push ebx
__asm mov ebx, esp
}
t22_helper(x);
__asm {
__asm mov esp, ebx
__asm pop ebx
}
// CHECK: t22
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call void asm sideeffect inteldialect
// CHECK-SAME: push ebx
// CHECK-SAME: mov ebx, esp
// CHECK-SAME: "~{ebx},~{esp},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add more tests. llvm-svn: 169411
2012-12-06 03:52:05 +08:00
// CHECK: call void @t22_helper
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call void asm sideeffect inteldialect
// CHECK-SAME: mov esp, ebx
// CHECK-SAME: pop ebx
// CHECK-SAME: "~{ebx},~{esp},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add more tests. llvm-svn: 169411
2012-12-06 03:52:05 +08:00
}
Test case for r171784. llvm-svn: 171785
2013-01-08 04:34:40 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t23(void) {
Test case for r171784. llvm-svn: 171785
2013-01-08 04:34:40 +08:00
__asm {
the_label:
}
// CHECK: t23
Use ${:uid} to generate unique MS asm labels, not {:uid} llvm-svn: 288093
2016-11-29 08:39:37 +08:00
// CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.${:uid}__the_label:", "~{dirflag},~{fpsr},~{flags}"()
Test case for r171784. llvm-svn: 171785
2013-01-08 04:34:40 +08:00
}
[ms-inline asm] Add test case for r172121. Part of rdar://12991541 llvm-svn: 172122
2013-01-11 06:11:28 +08:00
void t24_helper(void) {}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t24(void) {
[ms-inline asm] Add test case for r172121. Part of rdar://12991541 llvm-svn: 172122
2013-01-11 06:11:28 +08:00
__asm call t24_helper
// CHECK: t24
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "call dword ptr ${0:P}", "*m,~{dirflag},~{fpsr},~{flags}"(void ()* elementtype(void ()) @t24_helper)
[ms-inline asm] Add test case for r172121. Part of rdar://12991541 llvm-svn: 172122
2013-01-11 06:11:28 +08:00
}
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t25(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t25
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
__asm mov eax, 0ffffffffh
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, $$4294967295
(clang part) Implement MASM-flavor intel syntax behavior for inline MS asm block. Clang tests for verifying the following syntaxes: 1. 0xNN and NNh are accepted as valid hexadecimal numbers, but 0xNNh is not. 0xNN and NNh may come with optional U or L suffix. 2. NNb is accepted as a valid binary (base-2) number, but 0bNN is not. NNb may come with optional U or L suffix. Differential Revision: https://reviews.llvm.org/D22112 llvm-svn: 280556
2016-09-03 07:16:06 +08:00
__asm mov eax, 0fhU
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$15
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
__asm mov eax, 0a2h
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, $$162
(clang part) Implement MASM-flavor intel syntax behavior for inline MS asm block. Clang tests for verifying the following syntaxes: 1. 0xNN and NNh are accepted as valid hexadecimal numbers, but 0xNNh is not. 0xNN and NNh may come with optional U or L suffix. 2. NNb is accepted as a valid binary (base-2) number, but 0bNN is not. NNb may come with optional U or L suffix. Differential Revision: https://reviews.llvm.org/D22112 llvm-svn: 280556
2016-09-03 07:16:06 +08:00
__asm mov eax, 10100010b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, $$162
(clang part) Implement MASM-flavor intel syntax behavior for inline MS asm block. Clang tests for verifying the following syntaxes: 1. 0xNN and NNh are accepted as valid hexadecimal numbers, but 0xNNh is not. 0xNN and NNh may come with optional U or L suffix. 2. NNb is accepted as a valid binary (base-2) number, but 0bNN is not. NNb may come with optional U or L suffix. Differential Revision: https://reviews.llvm.org/D22112 llvm-svn: 280556
2016-09-03 07:16:06 +08:00
__asm mov eax, 10100010BU
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$162
// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t26(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t26
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
__asm pushad
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: pushad
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
__asm mov eax, 0
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$0
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
__asm __emit 0fh
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .byte 0fh
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
__asm __emit 0a2h
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .byte 0a2h
[ms-inline-asm] Add test cases for the align/emit directives. Part of rdar://13200215 llvm-svn: 175009
2013-02-13 05:34:14 +08:00
__asm __EMIT 0a2h
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .byte 0a2h
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
__asm popad
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: popad
// CHECK: "~{eax},~{ebp},~{ebx},~{ecx},~{edi},~{edx},~{esi},~{esp},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t27(void) {
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
__asm mov eax, fs:[0h]
// CHECK: t27
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, fs:[$$0]", "~{eax},~{dirflag},~{fpsr},~{flags}"()
[ms-inline asm] Add a few test cases for the parsing of hexidecimal integers. llvm-svn: 174989
2013-02-13 02:45:21 +08:00
}
[ms-inline-asm] Add test cases for the align/emit directives. Part of rdar://13200215 llvm-svn: 175009
2013-02-13 05:34:14 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t28(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t28
[ms-inline-asm] Add test cases for the align/emit directives. Part of rdar://13200215 llvm-svn: 175009
2013-02-13 05:34:14 +08:00
__asm align 8
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .align 3
[ms-inline-asm] Add test cases for the align/emit directives. Part of rdar://13200215 llvm-svn: 175009
2013-02-13 05:34:14 +08:00
__asm align 16;
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .align 4
[ms-inline-asm] Add test cases for the align/emit directives. Part of rdar://13200215 llvm-svn: 175009
2013-02-13 05:34:14 +08:00
__asm align 128;
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .align 7
[ms-inline-asm] Add test cases for the align/emit directives. Part of rdar://13200215 llvm-svn: 175009
2013-02-13 05:34:14 +08:00
__asm ALIGN 256;
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: .align 8
// CHECK: "~{dirflag},~{fpsr},~{flags}"()
[ms-inline-asm] Add test cases for the align/emit directives. Part of rdar://13200215 llvm-svn: 175009
2013-02-13 05:34:14 +08:00
}
[ms-inline-asm] Test cases to ensure the AsmRewrite list is sorted (r175021). Part of rdar://13202662 llvm-svn: 175022
2013-02-13 09:06:08 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t29(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t29
[ms-inline-asm] Test cases to ensure the AsmRewrite list is sorted (r175021). Part of rdar://13202662 llvm-svn: 175022
2013-02-13 09:06:08 +08:00
int arr[2] = {0, 0};
int olen = 0, osize = 0, otype = 0;
__asm mov olen, LENGTH arr
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov dword ptr $0, $$2
[ms-inline-asm] Test cases to ensure the AsmRewrite list is sorted (r175021). Part of rdar://13202662 llvm-svn: 175022
2013-02-13 09:06:08 +08:00
__asm mov osize, SIZE arr
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov dword ptr $1, $$8
[ms-inline-asm] Test cases to ensure the AsmRewrite list is sorted (r175021). Part of rdar://13202662 llvm-svn: 175022
2013-02-13 09:06:08 +08:00
__asm mov otype, TYPE arr
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov dword ptr $2, $$4
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: "=*m,=*m,=*m,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}})
[ms-inline-asm] Test cases to ensure the AsmRewrite list is sorted (r175021). Part of rdar://13202662 llvm-svn: 175022
2013-02-13 09:06:08 +08:00
}
[ms-inline asm] Add test case for r175083. llvm-svn: 175084
2013-02-14 05:34:54 +08:00
int results[2] = {13, 37};
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
int *t30(void)
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t30
[ms-inline asm] Add test case for r175083. llvm-svn: 175084
2013-02-14 05:34:54 +08:00
{
int *res;
__asm lea edi, results
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: lea edi, $2
[ms-inline asm] Add test case for r175083. llvm-svn: 175084
2013-02-14 05:34:54 +08:00
__asm mov res, edi
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: mov $0, edi
[ms-inline asm] Add test case for r175083. llvm-svn: 175084
2013-02-14 05:34:54 +08:00
return res;
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: "=*m,={eax},*m,~{edi},~{dirflag},~{fpsr},~{flags}"(i32** elementtype(i32*) %{{.*}}, [2 x i32]* elementtype([2 x i32]) @{{.*}})
[ms-inline asm] Add test case for r175083. llvm-svn: 175084
2013-02-14 05:34:54 +08:00
}
Update to use references to attribute groups instead of listing the attributes on the call/invoke instructions. llvm-svn: 175878
2013-02-22 17:10:20 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t31(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t31
Add a front-end test case for r176036. llvm-svn: 176038
2013-02-26 03:13:23 +08:00
__asm pushad
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: pushad
Add a front-end test case for r176036. llvm-svn: 176038
2013-02-26 03:13:23 +08:00
__asm popad
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: popad
// CHECK: "~{eax},~{ebp},~{ebx},~{ecx},~{edi},~{edx},~{esi},~{esp},~{dirflag},~{fpsr},~{flags}"()
Add a front-end test case for r176036. llvm-svn: 176038
2013-02-26 03:13:23 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t32(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t32
Test case for r177347. llvm-svn: 177349
2013-03-19 07:32:33 +08:00
int i;
__asm mov eax, i
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: mov eax, $0
Test case for r177347. llvm-svn: 177349
2013-03-19 07:32:33 +08:00
__asm mov eax, dword ptr i
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, dword ptr $1
Test case for r177347. llvm-svn: 177349
2013-03-19 07:32:33 +08:00
__asm mov ax, word ptr i
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov ax, word ptr $2
Test case for r177347. llvm-svn: 177349
2013-03-19 07:32:33 +08:00
__asm mov al, byte ptr i
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov al, byte ptr $3
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: "*m,*m,*m,*m,~{al},~{ax},~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}})
Test case for r177347. llvm-svn: 177349
2013-03-19 07:32:33 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t33(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t33
Test case for r177439 and r177440. llvm-svn: 177441
2013-03-20 05:12:57 +08:00
int i;
__asm mov eax, [i]
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: mov eax, $0
Test case for r177439 and r177440. llvm-svn: 177441
2013-03-20 05:12:57 +08:00
__asm mov eax, dword ptr [i]
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, dword ptr $1
Test case for r177439 and r177440. llvm-svn: 177441
2013-03-20 05:12:57 +08:00
__asm mov ax, word ptr [i]
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov ax, word ptr $2
Test case for r177439 and r177440. llvm-svn: 177441
2013-03-20 05:12:57 +08:00
__asm mov al, byte ptr [i]
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov al, byte ptr $3
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: "*m,*m,*m,*m,~{al},~{ax},~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}}, i32* elementtype(i32) %{{.*}})
Test case for r177439 and r177440. llvm-svn: 177441
2013-03-20 05:12:57 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t34(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t34
Add a front-end test case for r178186. llvm-svn: 178187
2013-03-28 05:50:39 +08:00
__asm prefetchnta 64[eax]
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: prefetchnta [eax + $$64]
Add a front-end test case for r178186. llvm-svn: 178187
2013-03-28 05:50:39 +08:00
__asm mov eax, dword ptr 4[eax]
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, dword ptr [eax + $$4]
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
Add a front-end test case for r178186. llvm-svn: 178187
2013-03-28 05:50:39 +08:00
}
Add test case for r178881. llvm-svn: 178882
2013-04-06 00:29:17 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t35(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t35
Add test case for r178881. llvm-svn: 178882
2013-04-06 00:29:17 +08:00
__asm prefetchnta [eax + (200*64)]
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: prefetchnta [eax + $$12800]
Add test case for r178881. llvm-svn: 178882
2013-04-06 00:29:17 +08:00
__asm mov eax, dword ptr [eax + (200*64)]
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, dword ptr [eax + $$12800]
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
Add test case for r178881. llvm-svn: 178882
2013-04-06 00:29:17 +08:00
}
Test case for r179030. llvm-svn: 179031
2013-04-09 01:44:05 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t36(void) {
Test case for r179030. llvm-svn: 179031
2013-04-09 01:44:05 +08:00
// CHECK: t36
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
int arr[4];
// Work around PR20368: These should be single line blocks
__asm { mov eax, 4[arr] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$4]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 4[arr + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$8]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 8[arr + 4 + 32*2 - 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$72]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 12[4 + arr] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$16]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 4[4 + arr + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$12]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 4[64 + arr + (2*32)] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$132]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 4[64 + arr - 2*32] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$4]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, [arr + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$4]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, [arr + 4 + 32*2 - 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$64]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, [4 + arr] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$4]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, [4 + arr + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$8]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, [64 + arr + (2*32)] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$128]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, [64 + arr - 2*32] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
Test case for r179030. llvm-svn: 179031
2013-04-09 01:44:05 +08:00
}
Test cases for r179655. llvm-svn: 179656
2013-04-17 08:12:09 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t37(void) {
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: t37
Test cases for r179655. llvm-svn: 179656
2013-04-17 08:12:09 +08:00
__asm mov eax, 4 + 8
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$12
Test cases for r179655. llvm-svn: 179656
2013-04-17 08:12:09 +08:00
__asm mov eax, 4 + 8 * 16
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$132
Test cases for r179655. llvm-svn: 179656
2013-04-17 08:12:09 +08:00
__asm mov eax, -4 + 8 * 16
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$124
Test cases for r179655. llvm-svn: 179656
2013-04-17 08:12:09 +08:00
__asm mov eax, (4 + 4) * 16
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$128
Test cases for r179719. llvm-svn: 179720
2013-04-18 05:02:39 +08:00
__asm mov eax, 4 + 8 * -16
[X86][Asm] Allow negative immediate to appear before bracketed expression Currently, only non-negative immediate is allowed prior to a brac expression (memory reference). MASM / GAS does not have any problem cope with the left side of the real line, so we should be able to as well. llvm: D36229 Differential Revision: https://reviews.llvm.org/D36230 llvm-svn: 310529
2017-08-10 05:50:22 +08:00
// CHECK: mov eax, $$-124
Test cases for r179719. llvm-svn: 179720
2013-04-18 05:02:39 +08:00
__asm mov eax, 4 + 16 / -8
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: mov eax, $$2
Test cases for r179719. llvm-svn: 179720
2013-04-18 05:02:39 +08:00
__asm mov eax, (16 + 16) / -8
[X86][Asm] Allow negative immediate to appear before bracketed expression Currently, only non-negative immediate is allowed prior to a brac expression (memory reference). MASM / GAS does not have any problem cope with the left side of the real line, so we should be able to as well. llvm: D36229 Differential Revision: https://reviews.llvm.org/D36230 llvm-svn: 310529
2017-08-10 05:50:22 +08:00
// CHECK: mov eax, $$-4
Add a test case for the tilde operator in Microsoft inline assembly llvm-svn: 212373
2014-07-05 23:04:06 +08:00
__asm mov eax, ~15
[X86][Asm] Allow negative immediate to appear before bracketed expression Currently, only non-negative immediate is allowed prior to a brac expression (memory reference). MASM / GAS does not have any problem cope with the left side of the real line, so we should be able to as well. llvm: D36229 Differential Revision: https://reviews.llvm.org/D36230 llvm-svn: 310529
2017-08-10 05:50:22 +08:00
// CHECK: mov eax, $$-16
Add test for parsing the XOR operator in Intel syntax inline assembly. LLVM side of the patch was committed as r239695. Differential Revision: http://reviews.llvm.org/D10384 Patch by marina.yatsina@intel.com llvm-svn: 239696
2015-06-14 21:03:27 +08:00
__asm mov eax, 6 ^ 3
// CHECK: mov eax, $$5
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
Test cases for r179655. llvm-svn: 179656
2013-04-17 08:12:09 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t38(void) {
Fix typo. llvm-svn: 179811
2013-04-19 07:12:05 +08:00
// CHECK: t38
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
int arr[4];
// Work around PR20368: These should be single line blocks
__asm { mov eax, 4+4[arr] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$8]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, (4+4)[arr + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$12]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 8*2[arr + 4 + 32*2 - 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$80]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 12+20[4 + arr] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$36]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 4*16+4[4 + arr + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$76]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 4*4[64 + arr + (2*32)] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$144]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 4*(4-2)[64 + arr - 2*32] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$8]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
__asm { mov eax, 32*(4-2)[arr - 2*32] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* elementtype([4 x i32]) %{{.*}})
Test cases for r179655. llvm-svn: 179656
2013-04-17 08:12:09 +08:00
}
Test case for clobbers on cpuid in ms inline asm Tests r200279 in LLVM. llvm-svn: 200280
2014-01-28 10:09:28 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void cpuid(void) {
Test case for clobbers on cpuid in ms inline asm Tests r200279 in LLVM. llvm-svn: 200280
2014-01-28 10:09:28 +08:00
__asm cpuid
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @cpuid
Test case for clobbers on cpuid in ms inline asm Tests r200279 in LLVM. llvm-svn: 200280
2014-01-28 10:09:28 +08:00
// CHECK: call void asm sideeffect inteldialect "cpuid", "~{eax},~{ebx},~{ecx},~{edx},~{dirflag},~{fpsr},~{flags}"()
}
Add tests for MS inline asm change r203146 llvm-svn: 203147
2014-03-07 03:19:36 +08:00
typedef struct {
int a;
int b;
[X86][Ms-InlineAsm] Extend MS Dot operator to accept "this" + struct/class pointers aliases MS InlineAsm Dot operator accepts "Bases" such as "this" (cpp) and class/struct pointer typedef. This patch enhance its implementation with this behavior. Differential Revision: https://reviews.llvm.org/D36450 llvm-svn: 310472
2017-08-09 21:31:41 +08:00
} A, *pA;
Add tests for MS inline asm change r203146 llvm-svn: 203147
2014-03-07 03:19:36 +08:00
[ms-inline-asm] Add support for composite structs in MS inline asm Add MS inline asm support for structs that contain fields that are also structs. Differential Revision: http://reviews.llvm.org/D15578 llvm-svn: 255890
2015-12-17 20:51:51 +08:00
typedef struct {
int b1;
A b2;
} B;
typedef struct {
int c1;
A c2;
int c3;
B c4;
[X86][Ms-InlineAsm] Extend MS Dot operator to accept "this" + struct/class pointers aliases MS InlineAsm Dot operator accepts "Bases" such as "this" (cpp) and class/struct pointer typedef. This patch enhance its implementation with this behavior. Differential Revision: https://reviews.llvm.org/D36450 llvm-svn: 310472
2017-08-09 21:31:41 +08:00
} C, *pC;
[ms-inline-asm] Add support for composite structs in MS inline asm Add MS inline asm support for structs that contain fields that are also structs. Differential Revision: http://reviews.llvm.org/D15578 llvm-svn: 255890
2015-12-17 20:51:51 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t39(void) {
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t39
Add tests for MS inline asm change r203146 llvm-svn: 203147
2014-03-07 03:19:36 +08:00
__asm mov eax, [eax].A.b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$4]
Add tests for MS inline asm change r203146 llvm-svn: 203147
2014-03-07 03:19:36 +08:00
__asm mov eax, [eax] A.b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$4]
[X86][Ms-InlineAsm] Extend MS Dot operator to accept "this" + struct/class pointers aliases MS InlineAsm Dot operator accepts "Bases" such as "this" (cpp) and class/struct pointer typedef. This patch enhance its implementation with this behavior. Differential Revision: https://reviews.llvm.org/D36450 llvm-svn: 310472
2017-08-09 21:31:41 +08:00
__asm mov eax, [eax] pA.b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$4]
Add tests for MS inline asm change r203146 llvm-svn: 203147
2014-03-07 03:19:36 +08:00
__asm mov eax, fs:[0] A.b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, fs:[$$4]
[ms-inline-asm] Add support for composite structs in MS inline asm Add MS inline asm support for structs that contain fields that are also structs. Differential Revision: http://reviews.llvm.org/D15578 llvm-svn: 255890
2015-12-17 20:51:51 +08:00
__asm mov eax, [eax].B.b2.a
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$4]
[ms-inline-asm] Add support for composite structs in MS inline asm Add MS inline asm support for structs that contain fields that are also structs. Differential Revision: http://reviews.llvm.org/D15578 llvm-svn: 255890
2015-12-17 20:51:51 +08:00
__asm mov eax, [eax] B.b2.b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$8]
[ms-inline-asm] Add support for composite structs in MS inline asm Add MS inline asm support for structs that contain fields that are also structs. Differential Revision: http://reviews.llvm.org/D15578 llvm-svn: 255890
2015-12-17 20:51:51 +08:00
__asm mov eax, fs:[0] C.c2.b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, fs:[$$8]
[ms-inline-asm] Add support for composite structs in MS inline asm Add MS inline asm support for structs that contain fields that are also structs. Differential Revision: http://reviews.llvm.org/D15578 llvm-svn: 255890
2015-12-17 20:51:51 +08:00
__asm mov eax, [eax]C.c4.b2.b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$24]
[X86][Ms-InlineAsm] Extend MS Dot operator to accept "this" + struct/class pointers aliases MS InlineAsm Dot operator accepts "Bases" such as "this" (cpp) and class/struct pointer typedef. This patch enhance its implementation with this behavior. Differential Revision: https://reviews.llvm.org/D36450 llvm-svn: 310472
2017-08-09 21:31:41 +08:00
__asm mov eax, [eax]pC.c4.b2.b
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: mov eax, [eax + $$24]
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
Add tests for MS inline asm change r203146 llvm-svn: 203147
2014-03-07 03:19:36 +08:00
}
MS asm: Filter out fpsw clobbers When parsing MS inline assembly, we note that fpsw is an implicit def of most x87 FP operations, and add it to the clobber list. However, we don't recognize fpsw as a gcc register name, and we assert. Clang always adds an fpsr clobber, which means the same thing to LLVM, so we can just use that. This test case was broken by my LLVM change r196939. Reviewers: echristo Differential Revision: http://llvm-reviews.chandlerc.com/D2993 llvm-svn: 204878
2014-03-27 08:00:03 +08:00
void t40(float a) {
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t40
MS asm: Filter out fpsw clobbers When parsing MS inline assembly, we note that fpsw is an implicit def of most x87 FP operations, and add it to the clobber list. However, we don't recognize fpsw as a gcc register name, and we assert. Clang always adds an fpsr clobber, which means the same thing to LLVM, so we can just use that. This test case was broken by my LLVM change r196939. Reviewers: echristo Differential Revision: http://llvm-reviews.chandlerc.com/D2993 llvm-svn: 204878
2014-03-27 08:00:03 +08:00
int i;
__asm fld a
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: fld dword ptr $1
MS asm: Filter out fpsw clobbers When parsing MS inline assembly, we note that fpsw is an implicit def of most x87 FP operations, and add it to the clobber list. However, we don't recognize fpsw as a gcc register name, and we assert. Clang always adds an fpsr clobber, which means the same thing to LLVM, so we can just use that. This test case was broken by my LLVM change r196939. Reviewers: echristo Differential Revision: http://llvm-reviews.chandlerc.com/D2993 llvm-svn: 204878
2014-03-27 08:00:03 +08:00
__asm fistp i
clang-cl: Merge adjacent single-line __asm blocks Summary: This patch extends the __asm parser to make it keep parsing input tokens as inline assembly if a single-line __asm line is followed by another line starting with __asm too. It also makes sure that we correctly keep matching braces in such situations by separating the notions of how many braces we are matching and whether we are in single-line asm block mode. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4598 llvm-svn: 213916
2014-07-25 10:27:14 +08:00
// CHECK: fistp dword ptr $0
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: "=*m,*m,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}}, float* elementtype(float) %{{.*}})
MS asm: Filter out fpsw clobbers When parsing MS inline assembly, we note that fpsw is an implicit def of most x87 FP operations, and add it to the clobber list. However, we don't recognize fpsw as a gcc register name, and we assert. Clang always adds an fpsr clobber, which means the same thing to LLVM, so we can just use that. This test case was broken by my LLVM change r196939. Reviewers: echristo Differential Revision: http://llvm-reviews.chandlerc.com/D2993 llvm-svn: 204878
2014-03-27 08:00:03 +08:00
}
Add a test for PR20343 after llvm r213303. llvm-svn: 213305
2014-07-18 04:25:36 +08:00
void t41(unsigned short a) {
[Clang/Test]: Rename enable_noundef_analysis to disable-noundef-analysis and turn it off by default Turning on `enable_noundef_analysis` flag allows better codegen by removing freeze instructions. I modified clang by renaming `enable_noundef_analysis` flag to `disable-noundef-analysis` and turning it off by default. Test updates are made as a separate patch: D108453 Reviewed By: eugenis Differential Revision: https://reviews.llvm.org/D105169
2022-01-16 17:53:11 +08:00
// CHECK-LABEL: define{{.*}} void @t41(i16 noundef zeroext %a)
Add a test for PR20343 after llvm r213303. llvm-svn: 213305
2014-07-18 04:25:36 +08:00
__asm mov cs, a;
Avoid unecessary opsize byte in segment move to memory Segment moves to memory are always 16-bit. Remove invalid 32 and 64 bit variants. Recommiting with missing clang inline assembly test change. Fixes PR34478. Reviewers: rnk, craig.topper Subscribers: llvm-commits, hiraditya Differential Revision: https://reviews.llvm.org/D39847 llvm-svn: 318797
2017-11-22 03:28:13 +08:00
// CHECK: mov cs, $0
Add a test for PR20343 after llvm r213303. llvm-svn: 213305
2014-07-18 04:25:36 +08:00
__asm mov ds, a;
Avoid unecessary opsize byte in segment move to memory Segment moves to memory are always 16-bit. Remove invalid 32 and 64 bit variants. Recommiting with missing clang inline assembly test change. Fixes PR34478. Reviewers: rnk, craig.topper Subscribers: llvm-commits, hiraditya Differential Revision: https://reviews.llvm.org/D39847 llvm-svn: 318797
2017-11-22 03:28:13 +08:00
// CHECK: mov ds, $1
Add a test for PR20343 after llvm r213303. llvm-svn: 213305
2014-07-18 04:25:36 +08:00
__asm mov es, a;
Avoid unecessary opsize byte in segment move to memory Segment moves to memory are always 16-bit. Remove invalid 32 and 64 bit variants. Recommiting with missing clang inline assembly test change. Fixes PR34478. Reviewers: rnk, craig.topper Subscribers: llvm-commits, hiraditya Differential Revision: https://reviews.llvm.org/D39847 llvm-svn: 318797
2017-11-22 03:28:13 +08:00
// CHECK: mov es, $2
Add a test for PR20343 after llvm r213303. llvm-svn: 213305
2014-07-18 04:25:36 +08:00
__asm mov fs, a;
Avoid unecessary opsize byte in segment move to memory Segment moves to memory are always 16-bit. Remove invalid 32 and 64 bit variants. Recommiting with missing clang inline assembly test change. Fixes PR34478. Reviewers: rnk, craig.topper Subscribers: llvm-commits, hiraditya Differential Revision: https://reviews.llvm.org/D39847 llvm-svn: 318797
2017-11-22 03:28:13 +08:00
// CHECK: mov fs, $3
Add a test for PR20343 after llvm r213303. llvm-svn: 213305
2014-07-18 04:25:36 +08:00
__asm mov gs, a;
Avoid unecessary opsize byte in segment move to memory Segment moves to memory are always 16-bit. Remove invalid 32 and 64 bit variants. Recommiting with missing clang inline assembly test change. Fixes PR34478. Reviewers: rnk, craig.topper Subscribers: llvm-commits, hiraditya Differential Revision: https://reviews.llvm.org/D39847 llvm-svn: 318797
2017-11-22 03:28:13 +08:00
// CHECK: mov gs, $4
Add a test for PR20343 after llvm r213303. llvm-svn: 213305
2014-07-18 04:25:36 +08:00
__asm mov ss, a;
Avoid unecessary opsize byte in segment move to memory Segment moves to memory are always 16-bit. Remove invalid 32 and 64 bit variants. Recommiting with missing clang inline assembly test change. Fixes PR34478. Reviewers: rnk, craig.topper Subscribers: llvm-commits, hiraditya Differential Revision: https://reviews.llvm.org/D39847 llvm-svn: 318797
2017-11-22 03:28:13 +08:00
// CHECK: mov ss, $5
Fix test/CodeGen/ms-inline-asm.c from r213916. llvm-svn: 213919
2014-07-25 10:39:33 +08:00
// CHECK: "*m,*m,*m,*m,*m,*m,~{dirflag},~{fpsr},~{flags}"(i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}})
Add a test for PR20343 after llvm r213303. llvm-svn: 213305
2014-07-18 04:25:36 +08:00
}
ms-inline-asm: Add a test to ensure that call doesn't clobber eax. Note that it's not clear whether this is the right behavior, please see the review for the discussion. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4577 llvm-svn: 214401
2014-07-31 21:43:17 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t42(void) {
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t42(
[X86] Recognize "flags" as an identifier, not a register in Intel-syntax inline asm This contains the test-case for r243630. Patch by: marina.yatsina@intel.com Differential Revision: http://reviews.llvm.org/D11513 llvm-svn: 243632
2015-07-30 18:10:47 +08:00
int flags;
__asm mov flags, eax
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: mov $0, eax
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: "=*m,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %flags)
[X86] Recognize "flags" as an identifier, not a register in Intel-syntax inline asm This contains the test-case for r243630. Patch by: marina.yatsina@intel.com Differential Revision: http://reviews.llvm.org/D11513 llvm-svn: 243632
2015-07-30 18:10:47 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t42b(void) {
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t42b(
[X86] Don't treat mxcsr as a register name when parsing MS inline assembly. No instruction takes mxcsr as a an operand so we should always treat it as an identifier name.
2019-11-14 07:20:34 +08:00
int mxcsr;
__asm mov mxcsr, eax
// CHECK: mov $0, eax
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: "=*m,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %mxcsr)
[X86] Don't treat mxcsr as a register name when parsing MS inline assembly. No instruction takes mxcsr as a an operand so we should always treat it as an identifier name.
2019-11-14 07:20:34 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t43(void) {
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t43
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
C strct;
// Work around PR20368: These should be single line blocks
__asm { mov eax, 4[strct.c1] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$4]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, 4[strct.c3 + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$8]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, 8[strct.c2.a + 4 + 32*2 - 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$72]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, 12[4 + strct.c2.b] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$16]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, 4[4 + strct.c4.b2.b + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$12]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, 4[64 + strct.c1 + (2*32)] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$132]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, 4[64 + strct.c2.a - 2*32] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$4]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, [strct.c4.b1 + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$4]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, [strct.c4.b2.a + 4 + 32*2 - 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$64]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, [4 + strct.c1] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$4]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, [4 + strct.c2.b + 4] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$8]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, [64 + strct.c3 + (2*32)] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0[$$128]", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
__asm { mov eax, [64 + strct.c4.b2.b - 2*32] }
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}})
[X86][ms-inline asm] Test case for adding support for memory operands that include structs Test case for commit 256381 Differential Revision: http://reviews.llvm.org/D15749 llvm-svn: 256382
2015-12-24 20:11:40 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t44(void) {
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t44
[x86][inline-asm]Allow a pack of Control Regs to be properly picked Allows the incorporation of legit (x86) Control Regs within inline asm stataements Differential Revision: https://reviews.llvm.org/D35903 llvm-svn: 309508
2017-07-30 18:19:10 +08:00
__asm {
mov cr0, eax
mov cr2, ebx
mov cr3, ecx
mov cr4, edx
}
// CHECK: call void asm sideeffect inteldialect "mov cr0, eax\0A\09mov cr2, ebx\0A\09mov cr3, ecx\0A\09mov cr4, edx", "~{cr0},~{cr2},~{cr3},~{cr4},~{dirflag},~{fpsr},~{flags}"()
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t45(void) {
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t45
[x86][inline-asm]Allow a pack of Control Debug to be properly picked Allows the incorporation of legit (x86) Debug Regs within inline asm stataements Differential Revision: https://reviews.llvm.org/D36074 llvm-svn: 309672
2017-08-01 18:51:09 +08:00
__asm {
mov dr0, eax
mov dr1, ebx
mov dr2, ebx
mov dr3, ecx
mov dr6, edx
mov dr7, ecx
}
// CHECK: call void asm sideeffect inteldialect "mov dr0, eax\0A\09mov dr1, ebx\0A\09mov dr2, ebx\0A\09mov dr3, ecx\0A\09mov dr6, edx\0A\09mov dr7, ecx", "~{dr0},~{dr1},~{dr2},~{dr3},~{dr6},~{dr7},~{dirflag},~{fpsr},~{flags}"()
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void t46(void) {
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @t46
[X86][Asm] Allow negative immediate to appear before bracketed expression Currently, only non-negative immediate is allowed prior to a brac expression (memory reference). MASM / GAS does not have any problem cope with the left side of the real line, so we should be able to as well. llvm: D36229 Differential Revision: https://reviews.llvm.org/D36230 llvm-svn: 310529
2017-08-10 05:50:22 +08:00
__asm add eax, -128[eax]
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: call void asm sideeffect inteldialect "add eax, [eax + $$-128]", "~{eax},~{flags},~{dirflag},~{fpsr},~{flags}"()
[X86][Asm] Allow negative immediate to appear before bracketed expression Currently, only non-negative immediate is allowed prior to a brac expression (memory reference). MASM / GAS does not have any problem cope with the left side of the real line, so we should be able to as well. llvm: D36229 Differential Revision: https://reviews.llvm.org/D36230 llvm-svn: 310529
2017-08-10 05:50:22 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void dot_operator(void){
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @dot_operator
[inline asm] dot operator while using imm generates wrong ir + asm - clang part Inline asm dot operator while using imm generates wrong ir and asm This is the test for the llvm changes committed in revision 306300 This also fixes bugzilla 32987: https://bugs.llvm.org//show_bug.cgi?id=32987 The llvm part of the review that contains the test can be found here: https://reviews.llvm.org/D33039 commit on behald of zizhar Differential Revision: https://reviews.llvm.org/D33040 llvm-svn: 306301
2017-06-27 00:09:55 +08:00
__asm { mov eax, 3[ebx]A.b}
Fixups to FE tests affected by D36793 Differential Revision: https://reviews.llvm.org/D36794 llvm-svn: 311640
2017-08-24 16:47:26 +08:00
// CHECK: call void asm sideeffect inteldialect "mov eax, [ebx + $$7]", "~{eax},~{dirflag},~{fpsr},~{flags}"
[inline asm] dot operator while using imm generates wrong ir + asm - clang part Inline asm dot operator while using imm generates wrong ir and asm This is the test for the llvm changes committed in revision 306300 This also fixes bugzilla 32987: https://bugs.llvm.org//show_bug.cgi?id=32987 The llvm part of the review that contains the test can be found here: https://reviews.llvm.org/D33039 commit on behald of zizhar Differential Revision: https://reviews.llvm.org/D33040 llvm-svn: 306301
2017-06-27 00:09:55 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void call_clobber(void) {
ms-inline-asm: Add a test to ensure that call doesn't clobber eax. Note that it's not clear whether this is the right behavior, please see the review for the discussion. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4577 llvm-svn: 214401
2014-07-31 21:43:17 +08:00
__asm call t41
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @call_clobber
[CodeGen] Emit elementtype attributes for indirect inline asm constraints This implements the clang side of D116531. The elementtype attribute is added for all indirect constraints (*) and tests are updated accordingly. Differential Revision: https://reviews.llvm.org/D116666
2022-01-05 22:16:24 +08:00
// CHECK: call void asm sideeffect inteldialect "call dword ptr ${0:P}", "*m,~{dirflag},~{fpsr},~{flags}"(void (i16)* elementtype(void (i16)) @t41)
ms-inline-asm: Add a test to ensure that call doesn't clobber eax. Note that it's not clear whether this is the right behavior, please see the review for the discussion. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4577 llvm-svn: 214401
2014-07-31 21:43:17 +08:00
}
MS inline asm: Add a test for xgetbv clobbers llvm-svn: 217174
2014-09-05 00:58:47 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void xgetbv(void) {
MS inline asm: Add a test for xgetbv clobbers llvm-svn: 217174
2014-09-05 00:58:47 +08:00
__asm xgetbv
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @xgetbv()
MS inline asm: Add a test for xgetbv clobbers llvm-svn: 217174
2014-09-05 00:58:47 +08:00
// CHECK: call void asm sideeffect inteldialect "xgetbv", "~{eax},~{edx},~{dirflag},~{fpsr},~{flags}"()
ms-inline-asm: Scope inline asm labels to functions Summary: This fixes PR20023. In order to implement this scoping rule, we piggy back on the existing LabelDecl machinery, by creating LabelDecl's that will carry the "internal" name of the inline assembly label, which we will rewrite the asm label to. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4589 llvm-svn: 218230
2014-09-22 10:21:54 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void label1(void) {
ms-inline-asm: Scope inline asm labels to functions Summary: This fixes PR20023. In order to implement this scoping rule, we piggy back on the existing LabelDecl machinery, by creating LabelDecl's that will carry the "internal" name of the inline assembly label, which we will rewrite the asm label to. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4589 llvm-svn: 218230
2014-09-22 10:21:54 +08:00
__asm {
label:
jmp label
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @label1()
Use ${:uid} to generate unique MS asm labels, not {:uid} llvm-svn: 288093
2016-11-29 08:39:37 +08:00
// CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.${:uid}__label:\0A\09jmp {{.*}}__MSASMLABEL_.${:uid}__label", "~{dirflag},~{fpsr},~{flags}"() [[ATTR1:#[0-9]+]]
ms-inline-asm: Scope inline asm labels to functions Summary: This fixes PR20023. In order to implement this scoping rule, we piggy back on the existing LabelDecl machinery, by creating LabelDecl's that will carry the "internal" name of the inline assembly label, which we will rewrite the asm label to. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4589 llvm-svn: 218230
2014-09-22 10:21:54 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void label2(void) {
ms-inline-asm: Scope inline asm labels to functions Summary: This fixes PR20023. In order to implement this scoping rule, we piggy back on the existing LabelDecl machinery, by creating LabelDecl's that will carry the "internal" name of the inline assembly label, which we will rewrite the asm label to. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4589 llvm-svn: 218230
2014-09-22 10:21:54 +08:00
__asm {
jmp label
label:
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @label2
Use ${:uid} to generate unique MS asm labels, not {:uid} llvm-svn: 288093
2016-11-29 08:39:37 +08:00
// CHECK: call void asm sideeffect inteldialect "jmp {{.*}}__MSASMLABEL_.${:uid}__label\0A\09{{.*}}__MSASMLABEL_.${:uid}__label:", "~{dirflag},~{fpsr},~{flags}"()
ms-inline-asm: Scope inline asm labels to functions Summary: This fixes PR20023. In order to implement this scoping rule, we piggy back on the existing LabelDecl machinery, by creating LabelDecl's that will carry the "internal" name of the inline assembly label, which we will rewrite the asm label to. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4589 llvm-svn: 218230
2014-09-22 10:21:54 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void label3(void) {
ms-inline-asm: Scope inline asm labels to functions Summary: This fixes PR20023. In order to implement this scoping rule, we piggy back on the existing LabelDecl machinery, by creating LabelDecl's that will carry the "internal" name of the inline assembly label, which we will rewrite the asm label to. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4589 llvm-svn: 218230
2014-09-22 10:21:54 +08:00
__asm {
label:
mov eax, label
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @label3
Use ${:uid} to generate unique MS asm labels, not {:uid} llvm-svn: 288093
2016-11-29 08:39:37 +08:00
// CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.${:uid}__label:\0A\09mov eax, {{.*}}__MSASMLABEL_.${:uid}__label", "~{eax},~{dirflag},~{fpsr},~{flags}"()
ms-inline-asm: Scope inline asm labels to functions Summary: This fixes PR20023. In order to implement this scoping rule, we piggy back on the existing LabelDecl machinery, by creating LabelDecl's that will carry the "internal" name of the inline assembly label, which we will rewrite the asm label to. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4589 llvm-svn: 218230
2014-09-22 10:21:54 +08:00
}
ms-inline-asm: Add a test case for the usage of labels in bracket expressions Summary: This is a test for this patch: http://reviews.llvm.org/D5445. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D5446 llvm-svn: 218271
2014-09-23 04:41:39 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void label4(void) {
ms-inline-asm: Add a test case for the usage of labels in bracket expressions Summary: This is a test for this patch: http://reviews.llvm.org/D5445. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D5446 llvm-svn: 218271
2014-09-23 04:41:39 +08:00
__asm {
label:
mov eax, [label]
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @label4
Use ${:uid} to generate unique MS asm labels, not {:uid} llvm-svn: 288093
2016-11-29 08:39:37 +08:00
// CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.${:uid}__label:\0A\09mov eax, {{.*}}__MSASMLABEL_.${:uid}__label", "~{eax},~{dirflag},~{fpsr},~{flags}"()
ms-inline-asm: Add a test case for the usage of labels in bracket expressions Summary: This is a test for this patch: http://reviews.llvm.org/D5445. Reviewers: rnk Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D5446 llvm-svn: 218271
2014-09-23 04:41:39 +08:00
}
[ms-inline-asm] Add field access to MS inline asm identifier lookup Now we can parse code like this: struct A { int field; }; int f(A o) { __asm mov eax, o.field } Fixes PR19117. llvm-svn: 246088
2015-08-27 05:57:20 +08:00
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void label5(void) {
[ms inline asm] Add support for label names with '$' chars In MS inline asm syntax a label with '$' char produces an error, while in AT&T it does not. In AT&T inline asm syntax Clang escapes the '$' char and replaces it with "$$". Adopted same approach for MS syntax. Differential Revision: http://reviews.llvm.org/D15795 llvm-svn: 256545
2015-12-29 16:49:34 +08:00
__asm {
jmp dollar_label$
dollar_label$:
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @label5
Use ${:uid} to generate unique MS asm labels, not {:uid} llvm-svn: 288093
2016-11-29 08:39:37 +08:00
// CHECK: call void asm sideeffect inteldialect "jmp {{.*}}__MSASMLABEL_.${:uid}__dollar_label$$\0A\09{{.*}}__MSASMLABEL_.${:uid}__dollar_label$$:", "~{dirflag},~{fpsr},~{flags}"()
[ms inline asm] Add support for label names with '$' chars In MS inline asm syntax a label with '$' char produces an error, while in AT&T it does not. In AT&T inline asm syntax Clang escapes the '$' char and replaces it with "$$". Adopted same approach for MS syntax. Differential Revision: http://reviews.llvm.org/D15795 llvm-svn: 256545
2015-12-29 16:49:34 +08:00
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void label6(void){
[x86][ms-inline-asm] use of "jmp short" in asm is not supported Test linked to: https://reviews.llvm.org/D24957 Committing in the name of Ziv Izhar: After check-all and LGTM . Differential Revision: https://reviews.llvm.org/D24958 llvm-svn: 284213
2016-10-14 16:13:27 +08:00
__asm {
jmp short label
[x86][inline-asm][ms-compat] legalize the use of "jc/jz short <op>" MS ignores the keyword "short" when used after a jc/jz instruction, LLVM ought to do the same. llvm: D35892 Differential Revision: https://reviews.llvm.org/D35893 llvm-svn: 309510
2017-07-30 19:13:46 +08:00
jc short label
jz short label
[x86][ms-inline-asm] use of "jmp short" in asm is not supported Test linked to: https://reviews.llvm.org/D24957 Committing in the name of Ziv Izhar: After check-all and LGTM . Differential Revision: https://reviews.llvm.org/D24958 llvm-svn: 284213
2016-10-14 16:13:27 +08:00
label:
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @label6
[x86][inline-asm][ms-compat] legalize the use of "jc/jz short <op>" MS ignores the keyword "short" when used after a jc/jz instruction, LLVM ought to do the same. llvm: D35892 Differential Revision: https://reviews.llvm.org/D35893 llvm-svn: 309510
2017-07-30 19:13:46 +08:00
// CHECK: jmp {{.*}}__MSASMLABEL_.${:uid}__label\0A\09jc {{.*}}__MSASMLABEL_.${:uid}__label\0A\09jz {{.*}}__MSASMLABEL_.${:uid}__label\0A\09{{.*}}__MSASMLABEL_.${:uid}__label:"
[x86][ms-inline-asm] use of "jmp short" in asm is not supported Test linked to: https://reviews.llvm.org/D24957 Committing in the name of Ziv Izhar: After check-all and LGTM . Differential Revision: https://reviews.llvm.org/D24958 llvm-svn: 284213
2016-10-14 16:13:27 +08:00
}
MS inline asm: Filter MXCSR out of the inferred clobber list Since r295004, LLVM has started modelling this new register, but we don't have GCC constraint inline asm spellings for it yet. llvm-svn: 295107
2017-02-15 05:38:17 +08:00
// Don't include mxcsr in the clobber list.
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void mxcsr(void) {
MS inline asm: Filter MXCSR out of the inferred clobber list Since r295004, LLVM has started modelling this new register, but we don't have GCC constraint inline asm spellings for it yet. llvm-svn: 295107
2017-02-15 05:38:17 +08:00
char buf[4096];
__asm fxrstor buf
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @mxcsr
[X86] add mayRaiseFPException flag and FPCW registers for X87 instructions Summary: This patch adds flag "mayRaiseFPException" , FPCW and FPSW for X87 instructions which could raise float exception. Reviewers: pengfei, RKSimon, andrew.w.kaylor, uweigand, kpn, spatel, cameron.mcinally, craig.topper Reviewed By: craig.topper Subscribers: thakis, hiraditya, llvm-commits Patch by LiuChen. Differential Revision: https://reviews.llvm.org/D68854
2019-11-01 14:17:07 +08:00
// CHECK: call void asm sideeffect inteldialect "fxrstor $0", "=*m,~{fpcr},~{dirflag},~{fpsr},~{flags}"
MS inline asm: Filter MXCSR out of the inferred clobber list Since r295004, LLVM has started modelling this new register, but we don't have GCC constraint inline asm spellings for it yet. llvm-svn: 295107
2017-02-15 05:38:17 +08:00
[X86] Add test case for llvm change r329734 This test ensures the popfd instruction in MS inline assembly can properly find a clobber name for the dirflag register. Previously the register was named 'DF', but it needs to be named 'dirflag' to match the name in the GCC register name list. llvm-svn: 329738
2018-04-11 02:43:44 +08:00
// Make sure we can find the register for the dirflag for popfd
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eleventh batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-16 05:06:01 +08:00
void dirflag(void) {
[X86] Add test case for llvm change r329734 This test ensures the popfd instruction in MS inline assembly can properly find a clobber name for the dirflag register. Previously the register was named 'DF', but it needs to be named 'dirflag' to match the name in the GCC register name list. llvm-svn: 329738
2018-04-11 02:43:44 +08:00
__asm popfd
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @dirflag
[X86] Add test case for llvm change r329734 This test ensures the popfd instruction in MS inline assembly can properly find a clobber name for the dirflag register. Previously the register was named 'DF', but it needs to be named 'dirflag' to match the name in the GCC register name list. llvm-svn: 329738
2018-04-11 02:43:44 +08:00
// CHECK: call void asm sideeffect inteldialect "popfd", "~{dirflag},~{flags},~{esp},~{dirflag},~{fpsr},~{flags}"
[ms-inline-asm] Add field access to MS inline asm identifier lookup Now we can parse code like this: struct A { int field; }; int f(A o) { __asm mov eax, o.field } Fixes PR19117. llvm-svn: 246088
2015-08-27 05:57:20 +08:00
typedef union _LARGE_INTEGER {
struct {
unsigned int LowPart;
unsigned int HighPart;
};
struct {
unsigned int LowPart;
unsigned int HighPart;
} u;
unsigned long long QuadPart;
} LARGE_INTEGER, *PLARGE_INTEGER;
int test_indirect_field(LARGE_INTEGER LargeInteger) {
__asm mov eax, LargeInteger.LowPart
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} i32 @test_indirect_field(
[ms-inline-asm] Use the frontend size only for ambiguous instructions This avoids problems on code like this: char buf[16]; __asm { movups xmm0, [buf] mov [buf], eax } The frontend size in this case (1) is wrong, and the register makes the instruction matching unambiguous. There are also enough bytes available that we shouldn't complain to the user that they are potentially using an incorrectly sized instruction to access the variable. Supersedes D32636 and D26586 and fixes PR28266 llvm-svn: 302179
2017-05-05 02:19:52 +08:00
// CHECK: call i32 asm sideeffect inteldialect "mov eax, $1",
Mark MS inline ASM 'nodplicate' it it has labels (PR23715) Duplicating it can lead to labels being defined twice. Differential revision: http://reviews.llvm.org/D15399 llvm-svn: 255201
2015-12-10 09:38:04 +08:00
// MS ASM containing labels must not be duplicated (PR23715).
[MS] Mangle a unique ID into all MS inline asm labels This solves PR23715 in a way that is compatible with LTO. MSVC supports jumping to source-level labels and between inline asm blocks, but we don't. Also revert the old solution, r255201, which was to mark these calls as noduplicate. llvm-svn: 288059
2016-11-29 04:52:19 +08:00
// CHECK: attributes [[ATTR1]] = {
// CHECK-NOT: noduplicate
// CHECK-SAME: }{{$}}