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

105 lines
3.1 KiB
LLVM
Raw Normal View History

[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -no-integrated-as | FileCheck %s
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
[WebAssembly] Fix a test to work even when the integrated assembler is enabled. Add -no-integrated-as to this test, since it's testing inline asm strings that aren't actually valid assembly syntax. llvm-svn: 257519
2016-01-13 05:01:30 +08:00
; Test basic inline assembly. Pass -no-integrated-as since these aren't
; actually valid assembly syntax.
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
[WebAssembly] Add -m:e to the target triple. This enables ELF-style name mangling, which primarily means using ".L" for private symbols. llvm-svn: 257020
2016-01-07 11:19:23 +08:00
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
[WebAssembly] Convert the remaining unit tests to the new wasm-object-file target. To facilitate this, add a new hidden command-line option to disable the explicit-locals pass. That causes llc to emit invalid code that doesn't have all locals converted to get_local/set_local, however it simplifies testwriting in many cases. llvm-svn: 296540
2017-03-01 07:37:04 +08:00
target triple = "wasm32-unknown-unknown-wasm"
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
; CHECK-LABEL: foo:
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: #APP{{$}}
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK-NEXT: # 0 = aaa(0){{$}}
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
; CHECK-NEXT: #NO_APP{{$}}
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK-NEXT: get_local $push0=, 0{{$}}
; CHECK-NEXT: return $pop0{{$}}
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
define i32 @foo(i32 %r) {
entry:
[WebAssembly] Make bogus inline asm strings in tests be comments. These tests aren't testing that the result is valid syntax; they're testing that the compiler emits the inline asm operands correctly. llvm-svn: 253469
2015-11-19 00:28:58 +08:00
%0 = tail call i32 asm sideeffect "# $0 = aaa($1)", "=r,r"(i32 %r) #0, !srcloc !0
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
ret i32 %0
}
; CHECK-LABEL: imm:
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK-NEXT: .local i32{{$}}
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
; CHECK-NEXT: #APP{{$}}
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK-NEXT: # 0 = ccc(42){{$}}
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
; CHECK-NEXT: #NO_APP{{$}}
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK-NEXT: get_local $push0=, 0{{$}}
; CHECK-NEXT: return $pop0{{$}}
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
define i32 @imm() {
entry:
[WebAssembly] Make bogus inline asm strings in tests be comments. These tests aren't testing that the result is valid syntax; they're testing that the compiler emits the inline asm operands correctly. llvm-svn: 253469
2015-11-19 00:28:58 +08:00
%0 = tail call i32 asm sideeffect "# $0 = ccc($1)", "=r,i"(i32 42) #0, !srcloc !2
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
ret i32 %0
}
[WebAssembly] Fix inline asm support for i64 operands. llvm-svn: 254106
2015-11-26 06:28:50 +08:00
; CHECK-LABEL: foo_i64:
; CHECK-NEXT: .param i64{{$}}
; CHECK-NEXT: .result i64{{$}}
; CHECK-NEXT: #APP{{$}}
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK-NEXT: # 0 = aaa(0){{$}}
[WebAssembly] Fix inline asm support for i64 operands. llvm-svn: 254106
2015-11-26 06:28:50 +08:00
; CHECK-NEXT: #NO_APP{{$}}
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK-NEXT: get_local $push0=, 0{{$}}
; CHECK-NEXT: return $pop0{{$}}
[WebAssembly] Fix inline asm support for i64 operands. llvm-svn: 254106
2015-11-26 06:28:50 +08:00
define i64 @foo_i64(i64 %r) {
entry:
%0 = tail call i64 asm sideeffect "# $0 = aaa($1)", "=r,r"(i64 %r) #0, !srcloc !0
ret i64 %0
}
[WebAssembly] Support inline asm constraints of type i16 and similar. llvm-svn: 254861
2015-12-06 04:03:44 +08:00
; CHECK-LABEL: X_i16:
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK: foo 1{{$}}
; CHECK: get_local $push[[S0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: get_local $push[[S1:[0-9]+]]=, 1{{$}}
; CHECK-NEXT: i32.store16 0($pop[[S0]]), $pop[[S1]]{{$}}
[WebAssembly] Support inline asm constraints of type i16 and similar. llvm-svn: 254861
2015-12-06 04:03:44 +08:00
define void @X_i16(i16 * %t) {
call void asm sideeffect "foo $0", "=*X,~{dirflag},~{fpsr},~{flags},~{memory}"(i16* %t)
ret void
}
; CHECK-LABEL: X_ptr:
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK: foo 1{{$}}
; CHECK: get_local $push[[S0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: get_local $push[[S1:[0-9]+]]=, 1{{$}}
; CHECK-NEXT: i32.store 0($pop[[S0]]), $pop[[S1]]{{$}}
[WebAssembly] Support inline asm constraints of type i16 and similar. llvm-svn: 254861
2015-12-06 04:03:44 +08:00
define void @X_ptr(i16 ** %t) {
call void asm sideeffect "foo $0", "=*X,~{dirflag},~{fpsr},~{flags},~{memory}"(i16** %t)
ret void
}
[WebAssembly] Support more kinds of inline asm operands llvm-svn: 255782
2015-12-17 01:15:17 +08:00
; CHECK-LABEL: funcname:
; CHECK: foo funcname{{$}}
define void @funcname() {
tail call void asm sideeffect "foo $0", "i"(void ()* nonnull @funcname) #0, !srcloc !0
ret void
}
; CHECK-LABEL: varname:
; CHECK: foo gv+37{{$}}
@gv = global [0 x i8] zeroinitializer
define void @varname() {
tail call void asm sideeffect "foo $0", "i"(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @gv, i64 0, i64 37)) #0, !srcloc !0
ret void
}
[WebAssembly] Revise the strategy for inline asm. Previously, an "r" constraint would mean the compiler provides a value on WebAssembly's operand stack. This was tricky to use properly, particularly since it isn't possible to declare a new local from within an inline asm string. With this patch, "r" provides the value in a WebAssembly local, and the local index is provided to the inline asm string. This requires inline asm to use get_local and set_local to read the register. This does potentially result in larger code size, however inline asm should hopefully be quite rare in WebAssembly. This also means that the "m" constraint can no longer be supported, as WebAssembly has nothing like a "memory operand" that includes an implicit get_local. This fixes PR34599 for the wasm32-unknown-unknown-wasm target (though not for the ELF target). llvm-svn: 317707
2017-11-09 03:18:08 +08:00
; CHECK-LABEL: r_constraint
; CHECK: i32.const $push[[S0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: set_local [[L0:[0-9]+]], $pop[[S0]]{{$}}
; CHECK-NEXT: i32.const $push[[S1:[0-9]+]]=, 37{{$}}
; CHECK-NEXT: set_local [[L1:[0-9]+]], $pop[[S1]]{{$}}
; CHECK: foo [[L2:[0-9]+]], 1, [[L0]], [[L1]]{{$}}
; CHECK: get_local $push{{[0-9]+}}=, [[L2]]{{$}}
define hidden i32 @r_constraint(i32 %a, i32 %y) {
entry:
%z = bitcast i32 0 to i32
%t0 = tail call i32 asm "foo $0, $1, $2, $3", "=r,r,r,r"(i32 %y, i32 %z, i32 37) #0, !srcloc !0
ret i32 %t0
}
[WebAssembly] Inline asm support. llvm-svn: 252997
2015-11-13 09:42:29 +08:00
attributes #0 = { nounwind }
!0 = !{i32 47}
!1 = !{i32 145}
!2 = !{i32 231}