llvm-mirror/test/MC/AsmParser/X86/x86_operands.s

// FIXME: Actually test that we get the expected results.
        
// RUN: llvm-mc -triple i386-unknown-unknown %s | FileCheck %s

# Immediates
# CHECK: addl $1, %eax
        addl $1, %eax
# CHECK: addl $3, %eax
        addl $(1+2), %eax
# CHECK: addl $a, %eax
        addl $a, %eax
# CHECK: addl $3, %eax
        addl $1 + 2, %eax
        
# Disambiguation

# CHECK: addl $1, 8
        addl $1, 4+4
# CHECK: addl $1, 8
        addl $1, (4+4)
# CHECK: addl $1, 8(%eax)
        addl $1, 4+4(%eax)
# CHECK: addl $1, 8(%eax)
        addl $1, (4+4)(%eax)
# CHECK: addl $1, 8(%eax)
        addl $1, 8(%eax)
# CHECK: addl $1, (%eax)
        addl $1, (%eax)
# CHECK: addl $1, 8(,%eax)
        addl $1, (4+4)(,%eax)
        
# Indirect Memory Operands
# CHECK: addl $1, 1(%eax)
        addl $1, 1(%eax)
# CHECK: addl $1, 1(%eax,%ebx)
        addl $1, 1(%eax,%ebx)
# CHECK: addl $1, 1(%eax,%ebx)
        addl $1, 1(%eax,%ebx,)
# CHECK: addl $1, 1(%eax,%ebx,4)
        addl $1, 1(%eax,%ebx,4)
# CHECK: addl $1, 1(,%ebx)
        addl $1, 1(,%ebx)
# CHECK: addl $1, 1(,%ebx)
        addl $1, 1(,%ebx,)
# CHECK: addl $1, 1(,%ebx,4)
        addl $1, 1(,%ebx,4)
# CHECK: addl $1, 1(,%ebx,4)
        addl $1, 1(,%ebx,(2+2))

# '*'
# CHECK: call a
        call a
# CHECK: call *%eax
        call *%eax
# CHECK: call *4(%eax)
        call *4(%eax)

# CHECK: movl	%gs:8, %eax
movl %gs:8, %eax
Revert r103137, fix for $ in labels. It looks like we can't actually handle this at the token level. Consider the following horrible test case: a = 1 .globl $a movl ($a), %eax movl $a, %eax movl $$a, %eax llvm-svn: 103178 2010-05-06 16:46:38 +02:00			`// FIXME: Actually test that we get the expected results.`

Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`// RUN: llvm-mc -triple i386-unknown-unknown %s \| FileCheck %s`
llvm-mc/x86: Test case for x86 operand parsing. llvm-svn: 74688 2009-07-02 04:28:23 +02:00
			`# Immediates`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`# CHECK: addl $1, %eax`
			`addl $1, %eax`
MC/AsmParser: Attempt to constant fold expressions up-front. This ensures we avoid fixups for obvious cases like '-(16)'. llvm-svn: 96064 2010-02-13 02:28:07 +01:00			`# CHECK: addl $3, %eax`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`addl $(1+2), %eax`
Revert r103137, fix for $ in labels. It looks like we can't actually handle this at the token level. Consider the following horrible test case: a = 1 .globl $a movl ($a), %eax movl $a, %eax movl $$a, %eax llvm-svn: 103178 2010-05-06 16:46:38 +02:00			`# CHECK: addl $a, %eax`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`addl $a, %eax`
MC/AsmParser: Attempt to constant fold expressions up-front. This ensures we avoid fixups for obvious cases like '-(16)'. llvm-svn: 96064 2010-02-13 02:28:07 +01:00			`# CHECK: addl $3, %eax`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`addl $1 + 2, %eax`
llvm-mc/x86: Test case for x86 operand parsing. llvm-svn: 74688 2009-07-02 04:28:23 +02:00
			`# Disambiguation`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00
MC/AsmParser: Attempt to constant fold expressions up-front. This ensures we avoid fixups for obvious cases like '-(16)'. llvm-svn: 96064 2010-02-13 02:28:07 +01:00			`# CHECK: addl $1, 8`
			`addl $1, 4+4`
			`# CHECK: addl $1, 8`
			`addl $1, (4+4)`
			`# CHECK: addl $1, 8(%eax)`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`addl $1, 4+4(%eax)`
MC/AsmParser: Attempt to constant fold expressions up-front. This ensures we avoid fixups for obvious cases like '-(16)'. llvm-svn: 96064 2010-02-13 02:28:07 +01:00			`# CHECK: addl $1, 8(%eax)`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`addl $1, (4+4)(%eax)`
			`# CHECK: addl $1, 8(%eax)`
			`addl $1, 8(%eax)`
MC/X86: Push immediate operands as immediates not expressions when possible. llvm-svn: 96055 2010-02-13 01:17:21 +01:00			`# CHECK: addl $1, (%eax)`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`addl $1, (%eax)`
MC/AsmParser: Attempt to constant fold expressions up-front. This ensures we avoid fixups for obvious cases like '-(16)'. llvm-svn: 96064 2010-02-13 02:28:07 +01:00			`# CHECK: addl $1, 8(,%eax)`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`addl $1, (4+4)(,%eax)`
llvm-mc/x86: Test case for x86 operand parsing. llvm-svn: 74688 2009-07-02 04:28:23 +02:00
			`# Indirect Memory Operands`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`# CHECK: addl $1, 1(%eax)`
			`addl $1, 1(%eax)`
			`# CHECK: addl $1, 1(%eax,%ebx)`
			`addl $1, 1(%eax,%ebx)`
			`# CHECK: addl $1, 1(%eax,%ebx)`
			`addl $1, 1(%eax,%ebx,)`
			`# CHECK: addl $1, 1(%eax,%ebx,4)`
			`addl $1, 1(%eax,%ebx,4)`
			`# CHECK: addl $1, 1(,%ebx)`
			`addl $1, 1(,%ebx)`
			`# CHECK: addl $1, 1(,%ebx)`
			`addl $1, 1(,%ebx,)`
			`# CHECK: addl $1, 1(,%ebx,4)`
			`addl $1, 1(,%ebx,4)`
			`# CHECK: addl $1, 1(,%ebx,4)`
			`addl $1, 1(,%ebx,(2+2))`
llvm-mc/x86: Test case for x86 operand parsing. llvm-svn: 74688 2009-07-02 04:28:23 +02:00
			`# '*'`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`# CHECK: call a`
llvm-mc/x86: Test case for x86 operand parsing. llvm-svn: 74688 2009-07-02 04:28:23 +02:00			`call a`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`# CHECK: call *%eax`
llvm-mc/x86: Test case for x86 operand parsing. llvm-svn: 74688 2009-07-02 04:28:23 +02:00			`call *%eax`
Update llvm-mc / MCAsmStreamer to print the instruction using the actual target specific printer (this only works on x86, for now). - This makes it possible to do some correctness checking of the parsing and matching, since we can compare the results of 'as' on the original input, to those of 'as' on the output from llvm-mc. - In theory, we could now have an easy ATT -> Intel syntax converter. :) llvm-svn: 78986 2009-08-14 05:48:55 +02:00			`# CHECK: call *4(%eax)`
llvm-mc/x86: Test case for x86 operand parsing. llvm-svn: 74688 2009-07-02 04:28:23 +02:00			`call *4(%eax)`

teach the x86 asm parser how to handle segment prefixes in memory operands. rdar://7874844 llvm-svn: 101661 2010-04-17 20:56:34 +02:00			`# CHECK: movl %gs:8, %eax`
			`movl %gs:8, %eax`