This is an archive of the discontinued LLVM Phabricator instance.

Differential D22432

llc: Add support for -run-pass none
ClosedPublic

Authored by MatzeB on Jul 15 2016, 6:43 PM.

Details

Reviewers
qcolombet
• tstellarAMD
dexonsmith
Commits
rG538859cca351: llc: Add support for -run-pass none
rL275664: llc: Add support for -run-pass none
Summary

This does not schedule any passes besides the ones necessary to
construct and print the machine function. This is useful to test .mir
file parsing and printing.

Diff Detail

Repository
rL LLVM

Event Timeline

MatzeB updated this revision to Diff 64218.Jul 15 2016, 6:43 PM
MatzeB retitled this revision from to llc: Add support for -run-pass none.
MatzeB updated this object.
MatzeB added reviewers: qcolombet, dexonsmith.
MatzeB set the repository for this revision to rL LLVM.
MatzeB added a subscriber: llvm-commits.
Herald added a reviewer: • tstellarAMD. · View Herald TranscriptJul 15 2016, 6:43 PM
Herald added subscribers: nemanjai, mcrosier, dsanders and 2 others. · View Herald Transcript
Closed by commit rL275664: llc: Add support for -run-pass none (authored by matze). · Explain WhyJul 15 2016, 7:32 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
test/
CodeGen/
MIR/
AArch64/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
AMDGPU/
2 lines
2 lines
2 lines
ARM/
2 lines
2 lines
2 lines
2 lines
2 lines
Generic/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Mips/
2 lines
2 lines
NVPTX/
2 lines
2 lines
2 lines
PowerPC/
2 lines
X86/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
tools/
llc/
56 lines

Diff 64218

test/CodeGen/MIR/AArch64/cfi-def-cfa.mir

# RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -mtriple=aarch64-none-linux-gnu -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the .cfi_def_cfa operands # This test ensures that the MIR parser parses the .cfi_def_cfa operands
# correctly. # correctly.
--- | --- |
declare void @foo() declare void @foo()
define void @trivial_fp_func() { define void @trivial_fp_func() {
Show All 22 Lines

test/CodeGen/MIR/AArch64/expected-target-flag-name.mir

# RUN: not llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -mtriple=aarch64-none-linux-gnu -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@var_i32 = global i32 42 @var_i32 = global i32 42
@var_i64 = global i64 0 @var_i64 = global i64 0
define i32 @sub_small() { define i32 @sub_small() {
entry: entry:
Show All 14 Lines

test/CodeGen/MIR/AArch64/generic-virtual-registers-error.mir

# RUN: not llc -mtriple=aarch64-apple-ios -start-after machine-sink -stop-after machine-sink -o - %s 2> %t.log \ # RUN: not llc -mtriple=aarch64-apple-ios -run-pass none -o - %s 2> %t.log \
# RUN: | FileCheck %s --check-prefix=CHECK # RUN: | FileCheck %s --check-prefix=CHECK
# RUN: FileCheck %s -input-file=%t.log --check-prefix=ERR # RUN: FileCheck %s -input-file=%t.log --check-prefix=ERR
# RUN: rm -f %t.log # RUN: rm -f %t.log
# REQUIRES: global-isel # REQUIRES: global-isel
# This test ensures that the MIR parser errors out when # This test ensures that the MIR parser errors out when
# generic virtual register definitions are not correct. # generic virtual register definitions are not correct.
--- | --- |
Show All 34 Lines

test/CodeGen/MIR/AArch64/invalid-target-flag-name.mir

# RUN: not llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -mtriple=aarch64-none-linux-gnu -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@var_i32 = global i32 42 @var_i32 = global i32 42
@var_i64 = global i64 0 @var_i64 = global i64 0
define i32 @sub_small() { define i32 @sub_small() {
entry: entry:
Show All 14 Lines

test/CodeGen/MIR/AArch64/multiple-lhs-operands.mir

# RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -mtriple=aarch64-none-linux-gnu -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser can parse multiple register machine # This test ensures that the MIR parser can parse multiple register machine
# operands before '='. # operands before '='.
--- | --- |
declare void @foo() declare void @foo()
define void @trivial_fp_func() { define void @trivial_fp_func() {
Show All 19 Lines

test/CodeGen/MIR/AArch64/stack-object-local-offset.mir

# RUN: llc -mtriple=aarch64-none-linux-gnu -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -mtriple=aarch64-none-linux-gnu -run-pass none -o - %s | FileCheck %s
--- | --- |
@var = global i64 0 @var = global i64 0
@local_addr = global i64* null @local_addr = global i64* null
define void @stack_local() { define void @stack_local() {
entry: entry:
%local_var = alloca i64 %local_var = alloca i64
Show All 32 Lines

test/CodeGen/MIR/AArch64/target-flags.mir

# RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -mtriple=aarch64-none-linux-gnu -run-pass none -o - %s | FileCheck %s
--- | --- |
@var_i32 = global i32 42 @var_i32 = global i32 42
@var_i64 = global i64 0 @var_i64 = global i64 0
define void @sub_small() { define void @sub_small() {
entry: entry:
Show All 30 Lines

test/CodeGen/MIR/AMDGPU/expected-target-index-name.mir

# RUN: not llc -march=amdgcn -mcpu=SI -start-after postrapseudos -stop-after postrapseudos -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=amdgcn -mcpu=SI -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
%struct.foo = type { float, [5 x i32] } %struct.foo = type { float, [5 x i32] }
@float_gv = internal unnamed_addr addrspace(2) constant [5 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00], align 4 @float_gv = internal unnamed_addr addrspace(2) constant [5 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00], align 4
define void @float(float addrspace(1)* %out, i32 %index) #0 { define void @float(float addrspace(1)* %out, i32 %index) #0 {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/CodeGen/MIR/AMDGPU/invalid-target-index-operand.mir

# RUN: not llc -march=amdgcn -mcpu=SI -start-after postrapseudos -stop-after postrapseudos -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=amdgcn -mcpu=SI -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
%struct.foo = type { float, [5 x i32] } %struct.foo = type { float, [5 x i32] }
@float_gv = internal unnamed_addr addrspace(2) constant [5 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00], align 4 @float_gv = internal unnamed_addr addrspace(2) constant [5 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00], align 4
define void @float(float addrspace(1)* %out, i32 %index) #0 { define void @float(float addrspace(1)* %out, i32 %index) #0 {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/CodeGen/MIR/AMDGPU/target-index-operands.mir

# RUN: llc -march=amdgcn -mcpu=SI -start-after postrapseudos -stop-after postrapseudos -o - %s | FileCheck %s # RUN: llc -march=amdgcn -mcpu=SI -run-pass none -o - %s | FileCheck %s
# This test verifies that the MIR parser can parse target index operands. # This test verifies that the MIR parser can parse target index operands.
--- | --- |
%struct.foo = type { float, [5 x i32] } %struct.foo = type { float, [5 x i32] }
@float_gv = internal unnamed_addr addrspace(2) constant [5 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00], align 4 @float_gv = internal unnamed_addr addrspace(2) constant [5 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00], align 4
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

test/CodeGen/MIR/ARM/bundled-instructions.mir

# RUN: llc -mtriple thumbv7-apple-ios -start-after block-placement -stop-after block-placement -o - %s | FileCheck %s # RUN: llc -mtriple thumbv7-apple-ios -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the bundled machine instructions # This test ensures that the MIR parser parses the bundled machine instructions
# and 'internal' register flags correctly. # and 'internal' register flags correctly.
--- | --- |
define i32 @test1(i32 %a) { define i32 @test1(i32 %a) {
entry: entry:
%cmp = icmp sgt i32 %a, -78 %cmp = icmp sgt i32 %a, -78
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/CodeGen/MIR/ARM/cfi-same-value.mir

# RUN: llc -mtriple=arm-linux-unknown-gnueabi -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -mtriple=arm-linux-unknown-gnueabi -run-pass none -o - %s | FileCheck %s
--- | --- |
declare void @dummy_use(i32*, i32) declare void @dummy_use(i32*, i32)
define void @test_basic() #0 { define void @test_basic() #0 {
entry: entry:
%mem = alloca i32, i32 10 %mem = alloca i32, i32 10
call void @dummy_use(i32* %mem, i32 10) call void @dummy_use(i32* %mem, i32 10)
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

test/CodeGen/MIR/ARM/expected-closing-brace.mir

# RUN: not llc -mtriple thumbv7-apple-ios -start-after block-placement -stop-after block-placement -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -mtriple thumbv7-apple-ios -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@G = external global i32 @G = external global i32
define i32 @test1(i32 %a) { define i32 @test1(i32 %a) {
entry: entry:
br label %foo br label %foo
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/CodeGen/MIR/ARM/extraneous-closing-brace-error.mir

# RUN: not llc -mtriple thumbv7-apple-ios -start-after block-placement -stop-after block-placement -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -mtriple thumbv7-apple-ios -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test1(i32 %a) { define i32 @test1(i32 %a) {
entry: entry:
ret i32 %a ret i32 %a
} }
... ...
--- ---
Show All 11 Lines

test/CodeGen/MIR/ARM/nested-instruction-bundle-error.mir

# RUN: not llc -mtriple thumbv7-apple-ios -start-after block-placement -stop-after block-placement -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -mtriple thumbv7-apple-ios -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test1(i32 %a) { define i32 @test1(i32 %a) {
entry: entry:
%cmp = icmp sgt i32 %a, -78 %cmp = icmp sgt i32 %a, -78
%. = zext i1 %cmp to i32 %. = zext i1 %cmp to i32
ret i32 %. ret i32 %.
} }
Show All 21 Lines

test/CodeGen/MIR/Generic/basic-blocks.mir

# RUN: llc -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses machine functions correctly. # This test ensures that the MIR parser parses machine functions correctly.
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }
Show All 40 Lines

test/CodeGen/MIR/Generic/expected-colon-after-basic-block.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }
... ...
--- ---
name: foo name: foo
body: | body: |
; CHECK: [[@LINE+1]]:13: expected ':' ; CHECK: [[@LINE+1]]:13: expected ':'
bb.0.entry bb.0.entry
... ...

test/CodeGen/MIR/Generic/expected-mbb-reference-for-successor-mbb.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
Show All 19 Lines

test/CodeGen/MIR/Generic/frame-info.mir

# RUN: llc -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses machine frame info properties # This test ensures that the MIR parser parses machine frame info properties
# correctly. # correctly.
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%b = alloca i32 %b = alloca i32
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/CodeGen/MIR/Generic/function-missing-machine-function.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test verifies that an error is reported when a MIR file has some # This test verifies that an error is reported when a MIR file has some
# function but is missing a corresponding machine function. # function but is missing a corresponding machine function.
# CHECK: no machine function information for function 'foo' in the MIR file # CHECK: no machine function information for function 'foo' in the MIR file
--- | --- |
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
} }
... ...

test/CodeGen/MIR/Generic/invalid-jump-table-kind.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test_jumptable(i32 %in) { define i32 @test_jumptable(i32 %in) {
entry: entry:
switch i32 %in, label %def [ switch i32 %in, label %def [
i32 0, label %lbl1 i32 0, label %lbl1
i32 1, label %lbl2 i32 1, label %lbl2
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/CodeGen/MIR/Generic/llvm-ir-error-reported.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures an error is reported if the embedded LLVM IR contains an # This test ensures an error is reported if the embedded LLVM IR contains an
# error. # error.
--- | --- |
; CHECK: [[@LINE+3]]:15: use of undefined value '%a' ; CHECK: [[@LINE+3]]:15: use of undefined value '%a'
define i32 @foo(i32 %x, i32 %y) { define i32 @foo(i32 %x, i32 %y) {
%z = alloca i32, align 4 %z = alloca i32, align 4
Show All 13 Lines

test/CodeGen/MIR/Generic/llvmIR.mir

# RUN: llc -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -run-pass none -o - %s | FileCheck %s
# This test ensures that the LLVM IR that's embedded with MIR is parsed # This test ensures that the LLVM IR that's embedded with MIR is parsed
# correctly. # correctly.
--- | --- |
; CHECK: define i32 @foo(i32 %x, i32 %y) ; CHECK: define i32 @foo(i32 %x, i32 %y)
; CHECK: %z = alloca i32, align 4 ; CHECK: %z = alloca i32, align 4
; CHECK: store i32 %x, i32* %z, align 4 ; CHECK: store i32 %x, i32* %z, align 4
; CHECK: br label %Test ; CHECK: br label %Test
Show All 28 Lines

test/CodeGen/MIR/Generic/llvmIRMissing.mir

# RUN: llc -start-after branch-folder -stop-after branch-folder -o - %s 2>&1 | FileCheck %s # RUN: llc -run-pass none -o - %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser accepts files without the LLVM IR. # This test ensures that the MIR parser accepts files without the LLVM IR.
--- ---
# CHECK: name: foo # CHECK: name: foo
name: foo name: foo
body: | body: |
bb.0: bb.0:
... ...

test/CodeGen/MIR/Generic/machine-basic-block-ir-block-reference.mir

# RUN: llc -start-after branch-folder -stop-after branch-folder -o - %s 2>&1 | FileCheck %s # RUN: llc -run-pass none -o - %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser preserves unnamed LLVM IR block # This test ensures that the MIR parser preserves unnamed LLVM IR block
# references. # references.
--- | --- |
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
} }
... ...
--- ---
name: foo name: foo
body: | body: |
; CHECK: bb.0 (%ir-block.0): ; CHECK: bb.0 (%ir-block.0):
bb.0 (%ir-block.0): bb.0 (%ir-block.0):
... ...

test/CodeGen/MIR/Generic/machine-basic-block-redefinition-error.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }
Show All 9 Lines

test/CodeGen/MIR/Generic/machine-basic-block-undefined-ir-block.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
} }
... ...
--- ---
name: foo name: foo
body: | body: |
; CHECK: [[@LINE+1]]:9: use of undefined IR block '%ir-block.10' ; CHECK: [[@LINE+1]]:9: use of undefined IR block '%ir-block.10'
bb.0 (%ir-block.10): bb.0 (%ir-block.10):
... ...

test/CodeGen/MIR/Generic/machine-basic-block-unknown-name.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported whenever the MIR parser can't find # This test ensures that an error is reported whenever the MIR parser can't find
# a basic block with the machine basis block's name. # a basic block with the machine basis block's name.
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
Show All 9 Lines

test/CodeGen/MIR/Generic/machine-function-missing-body-error.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser reports an error when it encounters a # This test ensures that the MIR parser reports an error when it encounters a
# machine function with an empty body. # machine function with an empty body.
--- | --- |
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
} }
... ...
--- ---
# CHECK: machine function 'foo' requires at least one machine basic block in its body # CHECK: machine function 'foo' requires at least one machine basic block in its body
name: foo name: foo
... ...

test/CodeGen/MIR/Generic/machine-function-missing-function.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when the mir file has LLVM IR and # This test ensures that an error is reported when the mir file has LLVM IR and
# one of the machine functions has a name that doesn't match any function in # one of the machine functions has a name that doesn't match any function in
# the LLVM IR. # the LLVM IR.
--- | --- |
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
Show All 14 Lines

test/CodeGen/MIR/Generic/machine-function-missing-name.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when a machine function doesn't # This test ensures that an error is reported when a machine function doesn't
# have a name attribute. # have a name attribute.
--- | --- |
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
} }
Show All 17 Lines

test/CodeGen/MIR/Generic/machine-function-redefinition-error.mir

# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the machine function errors are reported correctly. # This test ensures that the machine function errors are reported correctly.
--- ---
name: foo name: foo
... ...
--- ---
# CHECK: redefinition of machine function 'foo' # CHECK: redefinition of machine function 'foo'
name: foo name: foo
... ...

test/CodeGen/MIR/Generic/machine-function.mir

# RUN: llc -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses machine functions correctly. # This test ensures that the MIR parser parses machine functions correctly.
--- | --- |
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
} }
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/CodeGen/MIR/Generic/register-info.mir

# RUN: llc -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses machine register info properties # This test ensures that the MIR parser parses machine register info properties
# correctly. # correctly.
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
Show All 31 Lines

test/CodeGen/MIR/Mips/expected-global-value-or-symbol-after-call-entry.mir

# RUN: not llc -march=mipsel -mattr=mips16 -relocation-model=pic -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=mipsel -mattr=mips16 -relocation-model=pic -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%call = call i32 @foo(i32 %a) %call = call i32 @foo(i32 %a)
ret i32 0 ret i32 0
} }
declare i32 @foo(i32) declare i32 @foo(i32)
Show All 32 Lines

test/CodeGen/MIR/Mips/memory-operands.mir

# RUN: llc -march=mipsel -mattr=mips16 -relocation-model=pic -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=mipsel -mattr=mips16 -relocation-model=pic -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the call entry pseudo source # This test ensures that the MIR parser parses the call entry pseudo source
# values in memory operands correctly. # values in memory operands correctly.
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%call = call i32 @foo(i32 %a) %call = call i32 @foo(i32 %a)
ret i32 0 ret i32 0
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

test/CodeGen/MIR/NVPTX/expected-floating-point-literal.mir

# RUN: not llc -march=nvptx -mcpu=sm_20 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=nvptx -mcpu=sm_20 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define float @test(float %k) { define float @test(float %k) {
entry: entry:
%0 = fadd float %k, 3.250000e+00 %0 = fadd float %k, 3.250000e+00
ret float %0 ret float %0
} }
Show All 15 Lines

test/CodeGen/MIR/NVPTX/floating-point-immediate-operands.mir

# RUN: llc -march=nvptx -mcpu=sm_20 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=nvptx -mcpu=sm_20 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses floating point constant operands # This test ensures that the MIR parser parses floating point constant operands
# correctly. # correctly.
--- | --- |
define float @test(float %k, i32 %i) { define float @test(float %k, i32 %i) {
entry: entry:
%0 = fpext float %k to double %0 = fpext float %k to double
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/CodeGen/MIR/NVPTX/floating-point-invalid-type-error.mir

# RUN: not llc -march=nvptx -mcpu=sm_20 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=nvptx -mcpu=sm_20 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define float @test(float %k) { define float @test(float %k) {
entry: entry:
%0 = fadd float %k, 3.250000e+00 %0 = fadd float %k, 3.250000e+00
ret float %0 ret float %0
} }
Show All 15 Lines

test/CodeGen/MIR/PowerPC/unordered-implicit-registers.mir

# RUN: llc -mtriple=powerpc64-unknown-linux-gnu -start-after machine-combiner -stop-after machine-combiner -o - %s | FileCheck %s # RUN: llc -mtriple=powerpc64-unknown-linux-gnu -run-pass none -o - %s | FileCheck %s
# PR24724 # PR24724
--- | --- |
define signext i32 @main(i32* %p) #0 { define signext i32 @main(i32* %p) #0 {
entry: entry:
%0 = load i32, i32* %p, align 4 %0 = load i32, i32* %p, align 4
%or = or i32 0, %0 %or = or i32 0, %0
store i32 %or, i32* %p, align 4 store i32 %or, i32* %p, align 4
Show All 36 Lines

test/CodeGen/MIR/X86/basic-block-liveins.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses basic block liveins correctly. # This test ensures that the MIR parser parses basic block liveins correctly.
--- | --- |
define i32 @test(i32 %a, i32 %b) { define i32 @test(i32 %a, i32 %b) {
body: body:
%c = add i32 %a, %b %c = add i32 %a, %b
ret i32 %c ret i32 %c
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/basic-block-not-at-start-of-line-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
Show All 32 Lines

test/CodeGen/MIR/X86/block-address-operands.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the block address operands # This test ensures that the MIR parser parses the block address operands
# correctly. # correctly.
--- | --- |
@addr = global i8* null @addr = global i8* null
define void @test() { define void @test() {
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/callee-saved-info.mir

# RUN: llc -march=x86-64 -start-after prologepilog -stop-after prologepilog -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses callee saved information in the # This test ensures that the MIR parser parses callee saved information in the
# stack objects correctly. # stack objects correctly.
--- | --- |
define i32 @compute(i32 %a) { define i32 @compute(i32 %a) {
body: body:
ret i32 %a ret i32 %a
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/cfi-def-cfa-offset.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the .cfi_def_cfa_offset operands # This test ensures that the MIR parser parses the .cfi_def_cfa_offset operands
# correctly. # correctly.
--- | --- |
define void @test() { define void @test() {
entry: entry:
%tmp = alloca [4168 x i8], align 4 %tmp = alloca [4168 x i8], align 4
Show All 20 Lines

test/CodeGen/MIR/X86/cfi-def-cfa-register.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the .cfi_def_cfa_register # This test ensures that the MIR parser parses the .cfi_def_cfa_register
# operands correctly. # operands correctly.
--- | --- |
define void @func() #0 { define void @func() #0 {
entry: entry:
unreachable unreachable
Show All 23 Lines

test/CodeGen/MIR/X86/cfi-offset.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the .cfi_offset operands # This test ensures that the MIR parser parses the .cfi_offset operands
# correctly. # correctly.
--- | --- |
declare void @foo(i32) declare void @foo(i32)
define i32 @test(i32 %a, i32 %b, i32 %c, i32 %d) { define i32 @test(i32 %a, i32 %b, i32 %c, i32 %d) {
Show All 38 Lines

test/CodeGen/MIR/X86/constant-pool-item-redefinition-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define double @test(double %a, float %b) { define double @test(double %a, float %b) {
entry: entry:
%c = fadd double %a, 3.250000e+00 %c = fadd double %a, 3.250000e+00
ret double %c ret double %c
} }
Show All 16 Lines

test/CodeGen/MIR/X86/constant-pool.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses constant pool constants and # This test ensures that the MIR parser parses constant pool constants and
# constant pool operands correctly. # constant pool operands correctly.
--- | --- |
define double @test(double %a, float %b) { define double @test(double %a, float %b) {
entry: entry:
%c = fadd double %a, 3.250000e+00 %c = fadd double %a, 3.250000e+00
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/constant-value-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser reports an error when parsing an invalid # This test ensures that the MIR parser reports an error when parsing an invalid
# constant value. # constant value.
--- | --- |
define double @test(double %a, float %b) { define double @test(double %a, float %b) {
entry: entry:
%c = fadd double %a, 3.250000e+00 %c = fadd double %a, 3.250000e+00
Show All 16 Lines

test/CodeGen/MIR/X86/dead-register-flag.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the 'dead' register flags # This test ensures that the MIR parser parses the 'dead' register flags
# correctly. # correctly.
--- | --- |
define i32 @foo(i32 %a) #0 { define i32 @foo(i32 %a) #0 {
body: body:
%c = mul i32 %a, 11 %c = mul i32 %a, 11
Show All 15 Lines

test/CodeGen/MIR/X86/def-register-already-tied-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i64 @test(i64 %x) #0 { define i64 @test(i64 %x) #0 {
entry: entry:
%asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind %asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind
ret i64 %asm ret i64 %asm
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }
Show All 16 Lines

test/CodeGen/MIR/X86/duplicate-memory-operand-flag.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @volatile_inc(i32* %x) { define i32 @volatile_inc(i32* %x) {
entry: entry:
%0 = load volatile i32, i32* %x %0 = load volatile i32, i32* %x
%1 = add i32 %0, 1 %1 = add i32 %0, 1
store volatile i32 %1, i32* %x store volatile i32 %1, i32* %x
Show All 18 Lines

test/CodeGen/MIR/X86/duplicate-register-flag-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
Show All 26 Lines

test/CodeGen/MIR/X86/early-clobber-register-flag.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the 'early-clobber' register # This test ensures that the MIR parser parses the 'early-clobber' register
# flags correctly. # flags correctly.
--- | --- |
declare void @foo(i32) declare void @foo(i32)
define void @test(i32 %a, i32 %b) #0 { define void @test(i32 %a, i32 %b) #0 {
Show All 36 Lines

test/CodeGen/MIR/X86/expected-align-in-memory-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define void @memory_alignment(<8 x float>* %vec) { define void @memory_alignment(<8 x float>* %vec) {
entry: entry:
%v = load <8 x float>, <8 x float>* %vec %v = load <8 x float>, <8 x float>* %vec
%v2 = insertelement <8 x float> %v, float 0.0, i32 4 %v2 = insertelement <8 x float> %v, float 0.0, i32 4
store <8 x float> %v2, <8 x float>* %vec store <8 x float> %v2, <8 x float>* %vec
Show All 21 Lines

test/CodeGen/MIR/X86/expected-alignment-after-align-in-memory-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define void @memory_alignment(<8 x float>* %vec) { define void @memory_alignment(<8 x float>* %vec) {
entry: entry:
%v = load <8 x float>, <8 x float>* %vec %v = load <8 x float>, <8 x float>* %vec
%v2 = insertelement <8 x float> %v, float 0.0, i32 4 %v2 = insertelement <8 x float> %v, float 0.0, i32 4
store <8 x float> %v2, <8 x float>* %vec store <8 x float> %v2, <8 x float>* %vec
Show All 21 Lines

test/CodeGen/MIR/X86/expected-basic-block-at-start-of-body.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
Show All 31 Lines

test/CodeGen/MIR/X86/expected-block-reference-in-blockaddress.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@addr = global i8* null @addr = global i8* null
define void @test() { define void @test() {
entry: entry:
store volatile i8* blockaddress(@test, %block), i8** @addr store volatile i8* blockaddress(@test, %block), i8** @addr
Show All 21 Lines

test/CodeGen/MIR/X86/expected-comma-after-cfi-register.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
declare void @foo(i32) declare void @foo(i32)
define i32 @test(i32 %a, i32 %b, i32 %c, i32 %d) { define i32 @test(i32 %a, i32 %b, i32 %c, i32 %d) {
entry: entry:
%add = add nsw i32 %b, %a %add = add nsw i32 %b, %a
Show All 33 Lines

test/CodeGen/MIR/X86/expected-comma-after-memory-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define void @test(i32* %a) { define void @test(i32* %a) {
entry2: entry2:
%b = load i32, i32* %a %b = load i32, i32* %a
%c = add i32 %b, 1 %c = add i32 %b, 1
store i32 %c, i32* %a store i32 %c, i32* %a
Show All 16 Lines

test/CodeGen/MIR/X86/expected-different-implicit-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32* %p) { define i32 @foo(i32* %p) {
entry: entry:
%a = load i32, i32* %p %a = load i32, i32* %p
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
Show All 25 Lines

test/CodeGen/MIR/X86/expected-different-implicit-register-flag.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32* %p) { define i32 @foo(i32* %p) {
entry: entry:
%a = load i32, i32* %p %a = load i32, i32* %p
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
Show All 25 Lines

test/CodeGen/MIR/X86/expected-function-reference-after-blockaddress.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@addr = global i8* null @addr = global i8* null
define void @test() { define void @test() {
entry: entry:
store volatile i8* blockaddress(@test, %block), i8** @addr store volatile i8* blockaddress(@test, %block), i8** @addr
Show All 21 Lines

test/CodeGen/MIR/X86/expected-global-value-after-blockaddress.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@addr = global i8* null @addr = global i8* null
define void @test() { define void @test() {
entry: entry:
store volatile i8* blockaddress(@test, %block), i8** @addr store volatile i8* blockaddress(@test, %block), i8** @addr
Show All 21 Lines

test/CodeGen/MIR/X86/expected-integer-after-offset-sign.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@G = external global i32 @G = external global i32
define i32 @inc() { define i32 @inc() {
entry: entry:
%a = load i32, i32* @G %a = load i32, i32* @G
Show All 15 Lines

test/CodeGen/MIR/X86/expected-integer-after-tied-def.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i64 @test(i64 %x) #0 { define i64 @test(i64 %x) #0 {
entry: entry:
%asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind %asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind
ret i64 %asm ret i64 %asm
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }
Show All 16 Lines

test/CodeGen/MIR/X86/expected-integer-in-successor-weight.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
Show All 29 Lines

test/CodeGen/MIR/X86/expected-load-or-store-in-memory-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32* %a) { define i32 @test(i32* %a) {
entry: entry:
%b = load i32, i32* %a %b = load i32, i32* %a
ret i32 %b ret i32 %b
} }
Show All 14 Lines

test/CodeGen/MIR/X86/expected-machine-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }
Show All 10 Lines

test/CodeGen/MIR/X86/expected-metadata-node-after-debug-location.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %x) #0 !dbg !4 { define i32 @test(i32 %x) #0 !dbg !4 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
store i32 %x, i32* %x.addr, align 4 store i32 %x, i32* %x.addr, align 4
call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !12, metadata !13), !dbg !14 call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !12, metadata !13), !dbg !14
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/expected-metadata-node-after-exclaim.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %x) #0 !dbg !4 { define i32 @test(i32 %x) #0 !dbg !4 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
store i32 %x, i32* %x.addr, align 4 store i32 %x, i32* %x.addr, align 4
call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !12, metadata !13), !dbg !14 call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !12, metadata !13), !dbg !14
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/expected-metadata-node-in-stack-object.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %x) { define i32 @test(i32 %x) {
entry: entry:
%xa = alloca i32, align 4 %xa = alloca i32, align 4
store i32 %x, i32* %xa, align 4 store i32 %x, i32* %xa, align 4
%0 = load i32, i32* %xa, align 4 %0 = load i32, i32* %xa, align 4
ret i32 %0 ret i32 %0
} }
Show All 16 Lines

test/CodeGen/MIR/X86/expected-named-register-in-allocation-hint.mir

# RUN: not llc -march=x86-64 -start-after machine-scheduler -stop-after machine-scheduler -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a, i32 %b) { define i32 @test(i32 %a, i32 %b) {
body: body:
%c = mul i32 %a, %b %c = mul i32 %a, %b
ret i32 %c ret i32 %c
} }
Show All 20 Lines

test/CodeGen/MIR/X86/expected-named-register-in-callee-saved-register.mir

# RUN: not llc -march=x86-64 -start-after prologepilog -stop-after prologepilog -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @compute(i32 %a) { define i32 @compute(i32 %a) {
body: body:
ret i32 %a ret i32 %a
} }
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/expected-named-register-in-functions-livein.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
body: body:
ret i32 %a ret i32 %a
} }
Show All 18 Lines

test/CodeGen/MIR/X86/expected-named-register-livein.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
body: body:
ret i32 %a ret i32 %a
} }
Show All 11 Lines

test/CodeGen/MIR/X86/expected-newline-at-end-of-list.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
Show All 32 Lines

test/CodeGen/MIR/X86/expected-number-after-bb.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32* %p) { define i32 @foo(i32* %p) {
entry: entry:
%a = load i32, i32* %p %a = load i32, i32* %p
%b = icmp sle i32 %a, 10 %b = icmp sle i32 %a, 10
br i1 %b, label %yes, label %nah br i1 %b, label %yes, label %nah
Show All 24 Lines

test/CodeGen/MIR/X86/expected-offset-after-cfi-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define void @test() { define void @test() {
entry: entry:
%tmp = alloca [4168 x i8], align 4 %tmp = alloca [4168 x i8], align 4
ret void ret void
} }
Show All 18 Lines

test/CodeGen/MIR/X86/expected-pointer-value-in-memory-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32* %a) { define i32 @test(i32* %a) {
entry: entry:
%b = load i32, i32* %a %b = load i32, i32* %a
ret i32 %b ret i32 %b
} }
Show All 15 Lines

test/CodeGen/MIR/X86/expected-positive-alignment-after-align.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define void @memory_alignment(<8 x float>* %vec) { define void @memory_alignment(<8 x float>* %vec) {
entry: entry:
%v = load <8 x float>, <8 x float>* %vec %v = load <8 x float>, <8 x float>* %vec
%v2 = insertelement <8 x float> %v, float 0.0, i32 4 %v2 = insertelement <8 x float> %v, float 0.0, i32 4
store <8 x float> %v2, <8 x float>* %vec store <8 x float> %v2, <8 x float>* %vec
Show All 21 Lines

test/CodeGen/MIR/X86/expected-register-after-cfi-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
declare void @foo(i32) declare void @foo(i32)
define i32 @test(i32 %a, i32 %b, i32 %c, i32 %d) { define i32 @test(i32 %a, i32 %b, i32 %c, i32 %d) {
entry: entry:
%add = add nsw i32 %b, %a %add = add nsw i32 %b, %a
Show All 33 Lines

test/CodeGen/MIR/X86/expected-register-after-flags.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when a register operand doesn't # This test ensures that an error is reported when a register operand doesn't
# follow register flags. # follow register flags.
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
Show All 11 Lines

test/CodeGen/MIR/X86/expected-size-integer-after-memory-operation.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32* %a) { define i32 @test(i32* %a) {
entry: entry:
%b = load i32, i32* %a %b = load i32, i32* %a
ret i32 %b ret i32 %b
} }
Show All 15 Lines

test/CodeGen/MIR/X86/expected-stack-object.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
@__stack_chk_guard = external global i8* @__stack_chk_guard = external global i8*
define i32 @test() #0 { define i32 @test() #0 {
entry: entry:
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/expected-subregister-after-colon.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define zeroext i1 @t(i1 %c) { define zeroext i1 @t(i1 %c) {
entry: entry:
ret i1 %c ret i1 %c
} }
Show All 18 Lines

test/CodeGen/MIR/X86/expected-target-flag-name.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@G = external global i32 @G = external global i32
define i32 @inc() { define i32 @inc() {
entry: entry:
%a = load i32, i32* @G %a = load i32, i32* @G
Show All 15 Lines

test/CodeGen/MIR/X86/expected-tied-def-after-lparen.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i64 @test(i64 %x) #0 { define i64 @test(i64 %x) #0 {
entry: entry:
%asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind %asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind
ret i64 %asm ret i64 %asm
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }
Show All 16 Lines

test/CodeGen/MIR/X86/expected-value-in-memory-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32* %a) { define i32 @test(i32* %a) {
entry: entry:
%b = load i32, i32* %a %b = load i32, i32* %a
ret i32 %b ret i32 %b
} }
Show All 15 Lines

test/CodeGen/MIR/X86/expected-virtual-register-in-functions-livein.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
body: body:
ret i32 %a ret i32 %a
} }
Show All 18 Lines

test/CodeGen/MIR/X86/external-symbol-operands.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the external symbol machine # This test ensures that the MIR parser parses the external symbol machine
# operands correctly. # operands correctly.
--- | --- |
@__stack_chk_guard = external global i8* @__stack_chk_guard = external global i8*
define i32 @test(i32 %n) #0 { define i32 @test(i32 %n) #0 {
entry: entry:
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/fixed-stack-memory-operands.mir

# RUN: llc -march=x86 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses fixed stack memory operands # This test ensures that the MIR parser parses fixed stack memory operands
# correctly. # correctly.
--- | --- |
define i32 @test(i32 %a) #0 { define i32 @test(i32 %a) #0 {
entry: entry:
%b = alloca i32 %b = alloca i32
Show All 30 Lines

test/CodeGen/MIR/X86/fixed-stack-object-redefinition-error.mir

# RUN: not llc -march=x86 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a, i32 %b) #0 { define i32 @test(i32 %a, i32 %b) #0 {
entry: entry:
%c = add i32 %a, %b %c = add i32 %a, %b
ret i32 %c ret i32 %c
} }
Show All 19 Lines

test/CodeGen/MIR/X86/fixed-stack-objects.mir

# RUN: llc -march=x86 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses fixed stack objects correctly. # This test ensures that the MIR parser parses fixed stack objects correctly.
--- | --- |
define i32 @test(i32 %a) #0 { define i32 @test(i32 %a) #0 {
entry: entry:
%b = alloca i32 %b = alloca i32
store i32 %a, i32* %b store i32 %a, i32* %b
Show All 24 Lines

test/CodeGen/MIR/X86/frame-info-save-restore-points.mir

# RUN: llc -march=x86-64 -enable-shrink-wrap=true -start-after shrink-wrap -stop-after shrink-wrap -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the save and restore points in # This test ensures that the MIR parser parses the save and restore points in
# the machine frame info correctly. # the machine frame info correctly.
--- | --- |
define i32 @foo(i32 %a, i32 %b) { define i32 @foo(i32 %a, i32 %b) {
entry: entry:
%tmp = alloca i32, align 4 %tmp = alloca i32, align 4
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/frame-info-stack-references.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the stack protector stack # This test ensures that the MIR parser parses the stack protector stack
# object reference in the machine frame info correctly. # object reference in the machine frame info correctly.
--- | --- |
@.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
@__stack_chk_guard = external global i8* @__stack_chk_guard = external global i8*
define i32 @test() #0 { define i32 @test() #0 {
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/frame-setup-instruction-flag.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the frame setup instruction flag. # This test ensures that the MIR parser parses the frame setup instruction flag.
--- | --- |
define i32 @compute(i32 %a) { define i32 @compute(i32 %a) {
body: body:
%c = mul i32 %a, 11 %c = mul i32 %a, 11
ret i32 %c ret i32 %c
Show All 26 Lines

test/CodeGen/MIR/X86/function-liveins.mir

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses machine function's liveins # This test ensures that the MIR parser parses machine function's liveins
# correctly. # correctly.
--- | --- |
define i32 @test(i32 %a, i32 %b) { define i32 @test(i32 %a, i32 %b) {
body: body:
%c = add i32 %a, %b %c = add i32 %a, %b
Show All 28 Lines

test/CodeGen/MIR/X86/generic-instr-type-error.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser report an error for # This test ensures that the MIR parser report an error for
# opaque types used on generic instruction. # opaque types used on generic instruction.
--- ---
name: bar name: bar
isSSA: true isSSA: true
registers: registers:
- { id: 0, class: gr32 } - { id: 0, class: gr32 }
body: | body: |
bb.0.entry: bb.0.entry:
liveins: %edi liveins: %edi
; CHECK: [[@LINE+1]]:20: expected a sized type ; CHECK: [[@LINE+1]]:20: expected a sized type
%0(32) = G_ADD %opaque %edi, %edi %0(32) = G_ADD %opaque %edi, %edi
... ...

test/CodeGen/MIR/X86/generic-virtual-registers.mir

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# REQUIRES: global-isel # REQUIRES: global-isel
# This test ensures that the MIR parser parses generic virtual # This test ensures that the MIR parser parses generic virtual
# register definitions correctly. # register definitions correctly.
--- | --- |
; ModuleID = 'generic-virtual-registers-type-error.mir' ; ModuleID = 'generic-virtual-registers-type-error.mir'
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
%type_alias = type <2 x i32> %type_alias = type <2 x i32>
Show All 39 Lines

test/CodeGen/MIR/X86/global-value-operands.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses global value operands correctly. # This test ensures that the MIR parser parses global value operands correctly.
--- | --- |
@G = external global i32 @G = external global i32
@0 = external global i32 @0 = external global i32
define i32 @inc() { define i32 @inc() {
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/immediate-operands.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses immediate machine operands. # This test ensures that the MIR parser parses immediate machine operands.
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 42 ret i32 42
} }
Show All 27 Lines

test/CodeGen/MIR/X86/implicit-register-flag.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the 'implicit' and 'implicit-def' # This test ensures that the MIR parser parses the 'implicit' and 'implicit-def'
# register flags correctly. # register flags correctly.
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/inline-asm-registers.mir

# RUN: llc -march=x86-64 -start-after block-placement -stop-after block-placement -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
--- | --- |
define i64 @test(i64 %x, i64 %y) #0 { define i64 @test(i64 %x, i64 %y) #0 {
entry: entry:
%x0 = call { i64, i64 } asm "foo", "=r,=r,1,0,~{dirflag},~{fpsr},~{flags}"(i64 %x, i64 %y) #0 %x0 = call { i64, i64 } asm "foo", "=r,=r,1,0,~{dirflag},~{fpsr},~{flags}"(i64 %x, i64 %y) #0
%x1 = extractvalue { i64, i64 } %x0, 0 %x1 = extractvalue { i64, i64 } %x0, 0
ret i64 %x1 ret i64 %x1
} }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/instructions-debug-location.mir

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the machine instruction's # This test ensures that the MIR parser parses the machine instruction's
# debug location metadata correctly. # debug location metadata correctly.
--- | --- |
define i32 @test(i32 %x) #0 !dbg !4 { define i32 @test(i32 %x) #0 !dbg !4 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/invalid-constant-pool-item.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser reports an error when parsing an invalid # This test ensures that the MIR parser reports an error when parsing an invalid
# constant pool item operand. # constant pool item operand.
--- | --- |
define double @test(double %a, float %b) { define double @test(double %a, float %b) {
entry: entry:
%c = fadd double %a, 3.250000e+00 %c = fadd double %a, 3.250000e+00
Show All 16 Lines

test/CodeGen/MIR/X86/invalid-metadata-node-type.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
declare void @llvm.dbg.declare(metadata, metadata, metadata) #0 declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
define void @foo() #1 { define void @foo() #1 {
entry: entry:
%x.i = alloca i8, align 1 %x.i = alloca i8, align 1
%y.i = alloca [256 x i8], align 16 %y.i = alloca [256 x i8], align 16
%0 = bitcast i8* %x.i to i8* %0 = bitcast i8* %x.i to i8*
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/invalid-target-flag-name.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@G = external global i32 @G = external global i32
define i32 @inc() { define i32 @inc() {
entry: entry:
%a = load i32, i32* @G %a = load i32, i32* @G
Show All 15 Lines

test/CodeGen/MIR/X86/invalid-tied-def-index-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i64 @test(i64 %x) #0 { define i64 @test(i64 %x) #0 {
entry: entry:
%asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind %asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind
ret i64 %asm ret i64 %asm
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }
Show All 16 Lines

test/CodeGen/MIR/X86/jump-table-info.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the jump table info and jump # This test ensures that the MIR parser parses the jump table info and jump
# table operands correctly. # table operands correctly.
--- | --- |
define i32 @test_jumptable(i32 %in) { define i32 @test_jumptable(i32 %in) {
entry: entry:
switch i32 %in, label %def [ switch i32 %in, label %def [
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/jump-table-redefinition-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test_jumptable(i32 %in) { define i32 @test_jumptable(i32 %in) {
entry: entry:
switch i32 %in, label %def [ switch i32 %in, label %def [
i32 0, label %lbl1 i32 0, label %lbl1
i32 1, label %lbl2 i32 1, label %lbl2
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/killed-register-flag.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the 'killed' register flags # This test ensures that the MIR parser parses the 'killed' register flags
# correctly. # correctly.
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
Show All 31 Lines

test/CodeGen/MIR/X86/large-cfi-offset-number-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define void @test() { define void @test() {
entry: entry:
%tmp = alloca [4168 x i8], align 4 %tmp = alloca [4168 x i8], align 4
ret void ret void
} }
Show All 18 Lines

test/CodeGen/MIR/X86/large-immediate-operand-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 42 ret i32 42
} }
Show All 9 Lines

test/CodeGen/MIR/X86/large-index-number-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo(i32* %p) { define i32 @foo(i32* %p) {
entry: entry:
%a = load i32, i32* %p %a = load i32, i32* %p
%b = icmp sle i32 %a, 10 %b = icmp sle i32 %a, 10
br i1 %b, label %0, label %1 br i1 %b, label %0, label %1
Show All 24 Lines

test/CodeGen/MIR/X86/large-offset-number-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@G = external global i32 @G = external global i32
define i32 @inc() { define i32 @inc() {
entry: entry:
%a = load i32, i32* @G %a = load i32, i32* @G
Show All 15 Lines

test/CodeGen/MIR/X86/large-size-in-memory-operand-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32* %a) { define i32 @test(i32* %a) {
entry: entry:
%b = load i32, i32* %a %b = load i32, i32* %a
ret i32 %b ret i32 %b
} }
Show All 15 Lines

test/CodeGen/MIR/X86/liveout-register-mask.mir

# RUN: llc -march=x86-64 -start-after stackmap-liveness -stop-after stackmap-liveness -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the liveout register mask # This test ensures that the MIR parser parses the liveout register mask
# machine operands correctly. # machine operands correctly.
--- | --- |
define void @small_patchpoint_codegen(i64 %p1, i64 %p2, i64 %p3, i64 %p4) { define void @small_patchpoint_codegen(i64 %p1, i64 %p2, i64 %p3, i64 %p4) {
entry: entry:
%result = tail call i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 5, i32 5, i8* null, i32 2, i64 %p1, i64 %p2) %result = tail call i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 5, i32 5, i8* null, i32 2, i64 %p1, i64 %p2)
Show All 33 Lines

test/CodeGen/MIR/X86/machine-basic-block-operands.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses machine basic block operands. # This test ensures that the MIR parser parses machine basic block operands.
--- | --- |
define i32 @foo(i32* %p) { define i32 @foo(i32* %p) {
entry: entry:
%a = load i32, i32* %p %a = load i32, i32* %p
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/machine-instructions.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses X86 machine instructions # This test ensures that the MIR parser parses X86 machine instructions
# correctly. # correctly.
--- | --- |
define i32 @inc(i32 %a) { define i32 @inc(i32 %a) {
entry: entry:
%b = mul i32 %a, 11 %b = mul i32 %a, 11
Show All 14 Lines

test/CodeGen/MIR/X86/machine-verifier.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser runs the machine verifier after parsing. # This test ensures that the MIR parser runs the machine verifier after parsing.
--- | --- |
define i32 @inc(i32 %a) { define i32 @inc(i32 %a) {
entry: entry:
ret i32 %a ret i32 %a
} }
Show All 13 Lines

test/CodeGen/MIR/X86/memory-operands.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the machine memory operands # This test ensures that the MIR parser parses the machine memory operands
# correctly. # correctly.
--- | --- |
define i32 @test(i32* %a) { define i32 @test(i32* %a) {
entry: entry:
%b = load i32, i32* %a %b = load i32, i32* %a
▲ Show 20 Lines • Show All 527 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/metadata-operands.mir

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the metadata machine operands # This test ensures that the MIR parser parses the metadata machine operands
# correctly. # correctly.
--- | --- |
define i32 @test(i32 %x) #0 !dbg !4 { define i32 @test(i32 %x) #0 !dbg !4 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/missing-closing-quote.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@"quoted name" = external global i32 @"quoted name" = external global i32
define i32 @test() { define i32 @test() {
entry: entry:
%a = load i32, i32* @"quoted name" %a = load i32, i32* @"quoted name"
Show All 13 Lines

test/CodeGen/MIR/X86/missing-comma.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }
Show All 10 Lines

test/CodeGen/MIR/X86/missing-implicit-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser reports an error when an instruction # This test ensures that the MIR parser reports an error when an instruction
# is missing one of its implicit register operands. # is missing one of its implicit register operands.
--- | --- |
define i32 @foo(i32* %p) { define i32 @foo(i32* %p) {
entry: entry:
%a = load i32, i32* %p %a = load i32, i32* %p
Show All 29 Lines

test/CodeGen/MIR/X86/named-registers.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses X86 registers correctly. # This test ensures that the MIR parser parses X86 registers correctly.
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }
Show All 12 Lines

test/CodeGen/MIR/X86/newline-handling.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/null-register-operands.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses null register operands correctly. # This test ensures that the MIR parser parses null register operands correctly.
--- | --- |
define i32 @deref(i32* %p) { define i32 @deref(i32* %p) {
entry: entry:
%a = load i32, i32* %p %a = load i32, i32* %p
ret i32 %a ret i32 %a
Show All 13 Lines

test/CodeGen/MIR/X86/register-mask-operands.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses register mask operands correctly. # This test ensures that the MIR parser parses register mask operands correctly.
--- | --- |
define i32 @compute(i32 %a) #0 { define i32 @compute(i32 %a) #0 {
body: body:
%c = mul i32 %a, 11 %c = mul i32 %a, 11
ret i32 %c ret i32 %c
Show All 30 Lines

test/CodeGen/MIR/X86/register-operands-target-flag-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@G = external global i32 @G = external global i32
define i32 @inc() { define i32 @inc() {
entry: entry:
%a = load i32, i32* @G %a = load i32, i32* @G
Show All 15 Lines

test/CodeGen/MIR/X86/simple-register-allocation-hints.mir

# RUN: llc -march=x86-64 -start-after machine-scheduler -stop-after machine-scheduler -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses simple register allocation hints # This test ensures that the MIR parser parses simple register allocation hints
# correctly. # correctly.
--- | --- |
define i32 @test(i32 %a, i32 %b) { define i32 @test(i32 %a, i32 %b) {
body: body:
%c = mul i32 %a, %b %c = mul i32 %a, %b
Show All 25 Lines

test/CodeGen/MIR/X86/spill-slot-fixed-stack-object-aliased.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) #0 { define i32 @test(i32 %a) #0 {
entry: entry:
%b = alloca i32 %b = alloca i32
store i32 %a, i32* %b store i32 %a, i32* %b
%c = load i32, i32* %b %c = load i32, i32* %b
Show All 21 Lines

test/CodeGen/MIR/X86/spill-slot-fixed-stack-object-immutable.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) #0 { define i32 @test(i32 %a) #0 {
entry: entry:
%b = alloca i32 %b = alloca i32
store i32 %a, i32* %b store i32 %a, i32* %b
%c = load i32, i32* %b %c = load i32, i32* %b
Show All 21 Lines

test/CodeGen/MIR/X86/spill-slot-fixed-stack-objects.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses fixed stack objects correctly. # This test ensures that the MIR parser parses fixed stack objects correctly.
--- | --- |
define i32 @test(i32 %a) #0 { define i32 @test(i32 %a) #0 {
entry: entry:
%b = alloca i32 %b = alloca i32
store i32 %a, i32* %b store i32 %a, i32* %b
Show All 23 Lines

test/CodeGen/MIR/X86/stack-object-debug-info.mir

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the stack object's debug info # This test ensures that the MIR parser parses the stack object's debug info
# correctly. # correctly.
--- | --- |
declare void @llvm.dbg.declare(metadata, metadata, metadata) #0 declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
define void @foo() #1 { define void @foo() #1 {
entry: entry:
%x.i = alloca i8, align 1 %x.i = alloca i8, align 1
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/stack-object-invalid-name.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser reports an error when it encounters a # This test ensures that the MIR parser reports an error when it encounters a
# stack object with a name that can't be associated with an alloca instruction. # stack object with a name that can't be associated with an alloca instruction.
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%b = alloca i32 %b = alloca i32
Show All 19 Lines

test/CodeGen/MIR/X86/stack-object-operand-name-mismatch-error.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an stack object reference # This test ensures that an error is reported when an stack object reference
# uses a different name then the stack object definition. # uses a different name then the stack object definition.
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%b = alloca i32 %b = alloca i32
Show All 24 Lines

test/CodeGen/MIR/X86/stack-object-operands.mir

# RUN: llc -march=x86 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses stack object machine operands # This test ensures that the MIR parser parses stack object machine operands
# correctly. # correctly.
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%b = alloca i32 %b = alloca i32
Show All 36 Lines

test/CodeGen/MIR/X86/stack-object-redefinition-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) #0 { define i32 @test(i32 %a) #0 {
entry: entry:
%b = alloca i32 %b = alloca i32
%x = alloca i64 %x = alloca i64
store i32 %a, i32* %b store i32 %a, i32* %b
Show All 28 Lines

test/CodeGen/MIR/X86/stack-objects.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses stack objects correctly. # This test ensures that the MIR parser parses stack objects correctly.
--- | --- |
define i32 @test(i32 %a) #0 { define i32 @test(i32 %a) #0 {
entry: entry:
%b = alloca i32 %b = alloca i32
%x = alloca i64 %x = alloca i64
Show All 28 Lines

test/CodeGen/MIR/X86/standalone-register-error.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
body: body:
ret i32 %a ret i32 %a
} }
... ...
--- ---
name: test name: test
Show All 15 Lines

test/CodeGen/MIR/X86/subreg-on-physreg.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported for subreg index on a physreg. # This test ensures that an error is reported for subreg index on a physreg.
--- | --- |
define void @t() { ret void } define void @t() { ret void }
... ...
--- ---
name: t name: t
body: | body: |
bb.0: bb.0:
; CHECK: [[@LINE+1]]:19: subregister index expects a virtual register ; CHECK: [[@LINE+1]]:19: subregister index expects a virtual register
%eax:sub_8bit = COPY %bl %eax:sub_8bit = COPY %bl
... ...

test/CodeGen/MIR/X86/subregister-index-operands.mir

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses and prints subregisters index # This test ensures that the MIR parser parses and prints subregisters index
# operands correctly. # operands correctly.
--- | --- |
define zeroext i1 @t(i1 %c) { define zeroext i1 @t(i1 %c) {
entry: entry:
ret i1 %c ret i1 %c
Show All 23 Lines

test/CodeGen/MIR/X86/subregister-operands.mir

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses subregisters in register operands # This test ensures that the MIR parser parses subregisters in register operands
# correctly. # correctly.
--- | --- |
define zeroext i1 @t(i1 %c) { define zeroext i1 @t(i1 %c) {
entry: entry:
ret i1 %c ret i1 %c
Show All 23 Lines

test/CodeGen/MIR/X86/successor-basic-blocks-weights.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses basic block successors and # This test ensures that the MIR parser parses basic block successors and
# probabilities correctly. # probabilities correctly.
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
Show All 33 Lines

test/CodeGen/MIR/X86/successor-basic-blocks.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses basic block successors correctly. # This test ensures that the MIR parser parses basic block successors correctly.
--- | --- |
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
br i1 %0, label %less, label %exit br i1 %0, label %less, label %exit
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/tied-def-operand-invalid.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i64 @test(i64 %x) #0 { define i64 @test(i64 %x) #0 {
entry: entry:
%asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind %asm = tail call i64 asm sideeffect "$foo", "=r,0"(i64 %x) nounwind
ret i64 %asm ret i64 %asm
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }
Show All 16 Lines

test/CodeGen/MIR/X86/undef-register-flag.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the 'undef' register flags # This test ensures that the MIR parser parses the 'undef' register flags
# correctly. # correctly.
--- | --- |
define i32 @compute(i32 %a) #0 { define i32 @compute(i32 %a) #0 {
body: body:
%c = mul i32 %a, 11 %c = mul i32 %a, 11
Show All 29 Lines

test/CodeGen/MIR/X86/undefined-fixed-stack-object.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%b = alloca i32 %b = alloca i32
%0 = alloca i32 %0 = alloca i32
store i32 %a, i32* %b store i32 %a, i32* %b
store i32 2, i32* %0 store i32 2, i32* %0
Show All 29 Lines

test/CodeGen/MIR/X86/undefined-global-value.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an invalid global value index # This test ensures that an error is reported when an invalid global value index
# is used. # is used.
--- | --- |
@0 = external global i32 @0 = external global i32
define i32 @inc() { define i32 @inc() {
Show All 17 Lines

test/CodeGen/MIR/X86/undefined-ir-block-in-blockaddress.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@addr = global i8* null @addr = global i8* null
define void @test() { define void @test() {
entry: entry:
store volatile i8* blockaddress(@test, %block), i8** @addr store volatile i8* blockaddress(@test, %block), i8** @addr
Show All 21 Lines

test/CodeGen/MIR/X86/undefined-ir-block-slot-in-blockaddress.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
@addr = global i8* null @addr = global i8* null
define void @test() { define void @test() {
entry: entry:
store volatile i8* blockaddress(@test, %0), i8** @addr store volatile i8* blockaddress(@test, %0), i8** @addr
Show All 20 Lines

test/CodeGen/MIR/X86/undefined-jump-table-id.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test_jumptable(i32 %in) { define i32 @test_jumptable(i32 %in) {
entry: entry:
switch i32 %in, label %def [ switch i32 %in, label %def [
i32 0, label %lbl1 i32 0, label %lbl1
i32 1, label %lbl2 i32 1, label %lbl2
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/undefined-named-global-value.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an undefined global value is # This test ensures that an error is reported when an undefined global value is
# used. # used.
--- | --- |
@G = external global i32 @G = external global i32
define i32 @inc() { define i32 @inc() {
Show All 17 Lines

test/CodeGen/MIR/X86/undefined-register-class.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser reports an error when it encounters an # This test ensures that the MIR parser reports an error when it encounters an
# unknown register class. # unknown register class.
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
ret i32 %a ret i32 %a
Show All 15 Lines

test/CodeGen/MIR/X86/undefined-stack-object.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%b = alloca i32 %b = alloca i32
store i32 %a, i32* %b store i32 %a, i32* %b
%c = load i32, i32* %b %c = load i32, i32* %b
ret i32 %c ret i32 %c
Show All 21 Lines

test/CodeGen/MIR/X86/undefined-value-in-memory-operand.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32* %a) { define i32 @test(i32* %a) {
entry: entry:
%b = load i32, i32* %a %b = load i32, i32* %a
ret i32 %b ret i32 %b
} }
Show All 15 Lines

test/CodeGen/MIR/X86/undefined-virtual-register.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that the MIR parser reports an error when parsing a # This test ensures that the MIR parser reports an error when parsing a
# reference to an undefined virtual register. # reference to an undefined virtual register.
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
ret i32 %a ret i32 %a
Show All 17 Lines

test/CodeGen/MIR/X86/unknown-instruction.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an unknown instruction is # This test ensures that an error is reported when an unknown instruction is
# encountered. # encountered.
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
Show All 10 Lines

test/CodeGen/MIR/X86/unknown-machine-basic-block.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an invalid machine basic # This test ensures that an error is reported when an invalid machine basic
# block index is used. # block index is used.
--- | --- |
define i32 @foo(i32* %p) { define i32 @foo(i32* %p) {
entry: entry:
Show All 27 Lines

test/CodeGen/MIR/X86/unknown-metadata-keyword.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @inc(i32* %x) { define i32 @inc(i32* %x) {
entry: entry:
%0 = load i32, i32* %x %0 = load i32, i32* %x
%1 = add i32 %0, 1 %1 = add i32 %0, 1
store i32 %1, i32* %x store i32 %1, i32* %x
ret i32 %1 ret i32 %1
Show All 16 Lines

test/CodeGen/MIR/X86/unknown-metadata-node.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %x) #0 !dbg !4 { define i32 @test(i32 %x) #0 !dbg !4 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
store i32 %x, i32* %x.addr, align 4 store i32 %x, i32* %x.addr, align 4
call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !12, metadata !13), !dbg !14 call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !12, metadata !13), !dbg !14
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/unknown-named-machine-basic-block.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an unknown named machine # This test ensures that an error is reported when an unknown named machine
# basic block is encountered. # basic block is encountered.
--- | --- |
define i32 @foo(i32* %p) { define i32 @foo(i32* %p) {
entry: entry:
%a = load i32, i32* %p %a = load i32, i32* %p
Show All 26 Lines

test/CodeGen/MIR/X86/unknown-register.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an unknown register is # This test ensures that an error is reported when an unknown register is
# encountered. # encountered.
--- | --- |
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
Show All 11 Lines

test/CodeGen/MIR/X86/unknown-subregister-index-op.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an unknown subregister index # This test ensures that an error is reported when an unknown subregister index
# is encountered. # is encountered.
--- | --- |
define zeroext i1 @t(i1 %c) { define zeroext i1 @t(i1 %c) {
entry: entry:
ret i1 %c ret i1 %c
Show All 17 Lines

test/CodeGen/MIR/X86/unknown-subregister-index.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
# This test ensures that an error is reported when an unknown subregister index # This test ensures that an error is reported when an unknown subregister index
# is encountered. # is encountered.
--- | --- |
define zeroext i1 @t(i1 %c) { define zeroext i1 @t(i1 %c) {
entry: entry:
ret i1 %c ret i1 %c
Show All 20 Lines

test/CodeGen/MIR/X86/unrecognized-character.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define void @foo() { define void @foo() {
entry: entry:
ret void ret void
} }
... ...
--- ---
name: foo name: foo
body: | body: |
bb.0.entry: bb.0.entry:
; CHECK: [[@LINE+1]]:5: unexpected character '\' ; CHECK: [[@LINE+1]]:5: unexpected character '\'
\ RETQ \ RETQ
... ...

test/CodeGen/MIR/X86/used-physical-register-info.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses the callee saved register mask # This test ensures that the MIR parser parses the callee saved register mask
# correctly and that the MIR parser can infer it as well. # correctly and that the MIR parser can infer it as well.
--- | --- |
define i32 @compute(i32 %a) #0 { define i32 @compute(i32 %a) #0 {
body: body:
%c = mul i32 %a, 11 %c = mul i32 %a, 11
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

test/CodeGen/MIR/X86/variable-sized-stack-object-size-error.mir

# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%b = alloca i32 %b = alloca i32
%x = alloca i64 %x = alloca i64
%y = alloca i32, i32 %a %y = alloca i32, i32 %a
store i32 %a, i32* %b store i32 %a, i32* %b
Show All 25 Lines

test/CodeGen/MIR/X86/variable-sized-stack-objects.mir

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses variable sized stack objects # This test ensures that the MIR parser parses variable sized stack objects
# correctly. # correctly.
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
entry: entry:
%b = alloca i32 %b = alloca i32
Show All 31 Lines

test/CodeGen/MIR/X86/virtual-register-redefinition-error.mir

# RUN: not llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | FileCheck %s # RUN: not llc -march=x86-64 -run-pass none -o /dev/null %s 2>&1 | FileCheck %s
--- | --- |
define i32 @test(i32 %a) { define i32 @test(i32 %a) {
body: body:
ret i32 %a ret i32 %a
} }
Show All 18 Lines

test/CodeGen/MIR/X86/virtual-registers.mir

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o - %s | FileCheck %s # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
# This test ensures that the MIR parser parses virtual register definitions and # This test ensures that the MIR parser parses virtual register definitions and
# references correctly. # references correctly.
--- | --- |
define i32 @bar(i32 %a) { define i32 @bar(i32 %a) {
entry: entry:
%0 = icmp sle i32 %a, 10 %0 = icmp sle i32 %a, 10
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

tools/llc/llc.cpp

Show First 20 Lines • Show All 261 Lines • ▼ Show 20 Linesint main(int argc, char **argv) {
// Compile the module TimeCompilations times to give better compile time // Compile the module TimeCompilations times to give better compile time
// metrics. // metrics.
for (unsigned I = TimeCompilations; I; --I) for (unsigned I = TimeCompilations; I; --I)
if (int RetVal = compileModule(argv, Context)) if (int RetVal = compileModule(argv, Context))
return RetVal; return RetVal;
return 0; return 0;
} }
static bool addPass(PassManagerBase &PM, const char *argv0,
StringRef PassName, TargetPassConfig &TPC) {
if (PassName == "none")
return false;
const PassRegistry *PR = PassRegistry::getPassRegistry();
const PassInfo *PI = PR->getPassInfo(PassName);
if (!PI) {
errs() << argv0 << ": run-pass " << PassName << " is not registered.\n";
return true;
}
Pass *P;
if (PI->getTargetMachineCtor())
P = PI->getTargetMachineCtor()(&TPC.getTM<TargetMachine>());
else if (PI->getNormalCtor())
P = PI->getNormalCtor()();
else {
errs() << argv0 << ": cannot create pass: " << PI->getPassName() << "\n";
return true;
}
std::string Banner = std::string("After ") + std::string(P->getPassName());
PM.add(P);
TPC.printAndVerify(Banner);
return false;
}
static int compileModule(char **argv, LLVMContext &Context) { static int compileModule(char **argv, LLVMContext &Context) {
// Load the module to be compiled... // Load the module to be compiled...
SMDiagnostic Err; SMDiagnostic Err;
std::unique_ptr<Module> M; std::unique_ptr<Module> M;
std::unique_ptr<MIRParser> MIR; std::unique_ptr<MIRParser> MIR;
Triple TheTriple; Triple TheTriple;
bool SkipModule = MCPU == "help" || bool SkipModule = MCPU == "help" ||
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines if (!RunPassNames->empty()) {
"redundant when run-pass is specified.\n"; "redundant when run-pass is specified.\n";
return 1; return 1;
} }
if (!MIR) { if (!MIR) {
errs() << argv[0] << ": run-pass needs a .mir input.\n"; errs() << argv[0] << ": run-pass needs a .mir input.\n";
return 1; return 1;
} }
LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine&>(*Target); LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine&>(*Target);
TargetPassConfig *TPC = LLVMTM.createPassConfig(PM); TargetPassConfig &TPC = *LLVMTM.createPassConfig(PM);
PM.add(TPC); PM.add(&TPC);
LLVMTM.addMachineModuleInfo(PM); LLVMTM.addMachineModuleInfo(PM);
LLVMTM.addMachineFunctionAnalysis(PM, MIR.get()); LLVMTM.addMachineFunctionAnalysis(PM, MIR.get());
TPC->printAndVerify(""); TPC.printAndVerify("");
for (std::string &RunPassName : *RunPassNames) { for (const std::string &RunPassName : *RunPassNames) {
const PassInfo *PI = PR->getPassInfo(RunPassName); if (addPass(PM, argv[0], RunPassName, TPC))
if (!PI) {
errs() << argv[0] << ": run-pass " << RunPassName << " is not registered.\n";
return 1; return 1;
} }
Pass *P;
if (PI->getTargetMachineCtor())
P = PI->getTargetMachineCtor()(Target.get());
else if (PI->getNormalCtor())
P = PI->getNormalCtor()();
else {
errs() << argv[0] << ": cannot create pass: "
<< PI->getPassName() << "\n";
return 1;
}
std::string Banner
= std::string("After ") + std::string(P->getPassName());
PM.add(P);
TPC->printAndVerify(Banner);
}
PM.add(createPrintMIRPass(*OS)); PM.add(createPrintMIRPass(*OS));
} else { } else {
if (!StartAfter.empty()) { if (!StartAfter.empty()) {
const PassInfo *PI = PR->getPassInfo(StartAfter); const PassInfo *PI = PR->getPassInfo(StartAfter);
if (!PI) { if (!PI) {
errs() << argv[0] << ": start-after pass is not registered.\n"; errs() << argv[0] << ": start-after pass is not registered.\n";
return 1; return 1;
} }
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines