This is an archive of the discontinued LLVM Phabricator instance.

Differential D17422

When printing MIR, output to errs() rather than outs().
ClosedPublic

Authored by jlebar on Feb 18 2016, 4:14 PM.

Details

Reviewers
jroelofs
• tstellarAMD
Commits
rGc75d566f566c: When printing MIR, output to errs() rather than outs().
rL261286: When printing MIR, output to errs() rather than outs().
Summary

Without this, this command

$ llvm-run llc -stop-after machine-cp -o - <( echo '' )

outputs an error, because we close stdout twice -- once when closing the
file opened for "-o", and again when closing outs().

Also clarify in the outs() definition that you can't ever call it if you
want to open your own raw_fd_ostream on stdout.

Diff Detail

Repository
rL LLVM

Event Timeline

jlebar updated this revision to Diff 48421.Feb 18 2016, 4:14 PM
jlebar retitled this revision from to When printing MIR, output to errs() rather than outs()..
jlebar updated this object.
jlebar added a reviewer: jroelofs.
jlebar added a subscriber: llvm-commits.
Herald added a reviewer: • tstellarAMD. · View Herald TranscriptFeb 18 2016, 4:14 PM
Herald added subscribers: dsanders, qcolombet, jholewinski. · View Herald Transcript
jroelofs accepted this revision.Feb 18 2016, 4:17 PM
jroelofs edited edge metadata.

LGTM

This revision is now accepted and ready to land.Feb 18 2016, 4:17 PM
Closed by commit rL261286: When printing MIR, output to errs() rather than outs(). (authored by jlebar). · Explain WhyFeb 18 2016, 4:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
lib/
CodeGen/
2 lines
Support/
7 lines
test/
CodeGen/
AArch64/
2 lines
4 lines
ARM/
2 lines
MIR/
AArch64/
2 lines
2 lines
2 lines
2 lines
AMDGPU/
2 lines
ARM/
2 lines
2 lines
Generic/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Mips/
2 lines
NVPTX/
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
PowerPC/
4 lines
X86/
2 lines
4 lines
4 lines
DebugInfo/
MIR/
X86/
2 lines
2 lines
X86/
2 lines
2 lines

Diff 48423

llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp

Show First 20 Lines • Show All 159 Lines • ▼ Show 20 Linesbool LLVMTargetMachine::addPassesToEmitFile(
// Add common CodeGen passes. // Add common CodeGen passes.
MCContext *Context = MCContext *Context =
addPassesToGenerateCode(this, PM, DisableVerify, StartBefore, StartAfter, addPassesToGenerateCode(this, PM, DisableVerify, StartBefore, StartAfter,
StopAfter, MFInitializer); StopAfter, MFInitializer);
if (!Context) if (!Context)
return true; return true;
if (StopAfter) { if (StopAfter) {
PM.add(createPrintMIRPass(outs())); PM.add(createPrintMIRPass(errs()));
return false; return false;
} }
if (Options.MCOptions.MCSaveTempLabels) if (Options.MCOptions.MCSaveTempLabels)
Context->setAllowTemporaryLabels(false); Context->setAllowTemporaryLabels(false);
const MCSubtargetInfo &STI = *getMCSubtargetInfo(); const MCSubtargetInfo &STI = *getMCSubtargetInfo();
const MCAsmInfo &MAI = *getMCAsmInfo(); const MCAsmInfo &MAI = *getMCAsmInfo();
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

llvm/trunk/lib/Support/raw_ostream.cpp

Show First 20 Lines • Show All 709 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// outs(), errs(), nulls() // outs(), errs(), nulls()
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// outs() - This returns a reference to a raw_ostream for standard output. /// outs() - This returns a reference to a raw_ostream for standard output.
/// Use it like: outs() << "foo" << "bar"; /// Use it like: outs() << "foo" << "bar";
raw_ostream &llvm::outs() { raw_ostream &llvm::outs() {
// Set buffer settings to model stdout behavior. // Set buffer settings to model stdout behavior. Delete the file descriptor
// Delete the file descriptor when the program exits, forcing error // when the program exits, forcing error detection. This means that if you
// detection. If you don't want this behavior, don't use outs(). // ever call outs(), you can't open another raw_fd_ostream on stdout, as we'll
// close stdout twice and print an error the second time.
std::error_code EC; std::error_code EC;
static raw_fd_ostream S("-", EC, sys::fs::F_None); static raw_fd_ostream S("-", EC, sys::fs::F_None);
assert(!EC); assert(!EC);
return S; return S;
} }
/// errs() - This returns a reference to a raw_ostream for standard error. /// errs() - This returns a reference to a raw_ostream for standard error.
/// Use it like: errs() << "foo" << "bar"; /// Use it like: errs() << "foo" << "bar";
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/AArch64/branch-folder-merge-mmos.ll

; RUN: llc -march=aarch64 -mtriple=aarch64-none-linux-gnu -stop-after branch-folder -o /dev/null < %s | FileCheck %s ; RUN: llc -march=aarch64 -mtriple=aarch64-none-linux-gnu -stop-after branch-folder -o /dev/null < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
; Function Attrs: norecurse nounwind ; Function Attrs: norecurse nounwind
define void @foo(i32 %a, i32 %b, float* nocapture %foo_arr) #0 { define void @foo(i32 %a, i32 %b, float* nocapture %foo_arr) #0 {
; CHECK: (load 4 from %ir.arrayidx1.{{i[1-2]}}), (load 4 from %ir.arrayidx1.{{i[1-2]}}) ; CHECK: (load 4 from %ir.arrayidx1.{{i[1-2]}}), (load 4 from %ir.arrayidx1.{{i[1-2]}})
entry: entry:
%cmp = icmp sgt i32 %a, 0 %cmp = icmp sgt i32 %a, 0
br i1 %cmp, label %if.then, label %if.end br i1 %cmp, label %if.then, label %if.end
Show All 24 Lines

llvm/trunk/test/CodeGen/AArch64/stackmap-frame-setup.ll

; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=aarch64-apple-darwin -stop-after machine-sink %s | FileCheck %s --check-prefix=ISEL ; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=aarch64-apple-darwin -stop-after machine-sink %s 2>&1 | FileCheck %s --check-prefix=ISEL
; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=aarch64-apple-darwin -fast-isel -fast-isel-abort=1 -stop-after machine-sink %s | FileCheck %s --check-prefix=FAST-ISEL ; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=aarch64-apple-darwin -fast-isel -fast-isel-abort=1 -stop-after machine-sink %s 2>&1 | FileCheck %s --check-prefix=FAST-ISEL
define void @caller_meta_leaf() { define void @caller_meta_leaf() {
entry: entry:
%metadata = alloca i64, i32 3, align 8 %metadata = alloca i64, i32 3, align 8
store i64 11, i64* %metadata store i64 11, i64* %metadata
store i64 12, i64* %metadata store i64 12, i64* %metadata
store i64 13, i64* %metadata store i64 13, i64* %metadata
; ISEL: ADJCALLSTACKDOWN 0, implicit-def ; ISEL: ADJCALLSTACKDOWN 0, implicit-def
Show All 10 Lines

llvm/trunk/test/CodeGen/ARM/thumb1-ldst-opt.ll

; RUN: llc -stop-after block-placement -o /dev/null %s | FileCheck %s ; RUN: llc -stop-after block-placement -o /dev/null %s 2>&1 | FileCheck %s
target triple = "thumbv6m-none-none" target triple = "thumbv6m-none-none"
define i32* @foo(i32* readonly %p0) { define i32* @foo(i32* readonly %p0) {
entry: entry:
%add.ptr = getelementptr inbounds i32, i32* %p0, i32 10 %add.ptr = getelementptr inbounds i32, i32* %p0, i32 10
%arrayidx = getelementptr inbounds i32, i32* %p0, i32 13 %arrayidx = getelementptr inbounds i32, i32* %p0, i32 13
%0 = load i32, i32* %arrayidx, align 4 %0 = load i32, i32* %arrayidx, align 4
Show All 18 Lines

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

# RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

llvm/trunk/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 /dev/null %s | FileCheck %s # RUN: llc -mtriple=aarch64-none-linux-gnu -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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

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

# RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -mtriple=aarch64-none-linux-gnu -start-after branch-folder -stop-after branch-folder -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 void @sub_small() { define void @sub_small() {
entry: entry:
Show All 30 Lines

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

# RUN: llc -march=amdgcn -mcpu=SI -start-after postrapseudos -stop-after postrapseudos -o /dev/null %s | FileCheck %s # RUN: llc -march=amdgcn -mcpu=SI -start-after postrapseudos -stop-after postrapseudos -o /dev/null %s 2>&1 | 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

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

# RUN: llc -mtriple thumbv7-apple-ios -start-after block-placement -stop-after block-placement -o /dev/null %s | FileCheck %s # RUN: llc -mtriple thumbv7-apple-ios -start-after block-placement -stop-after block-placement -o /dev/null %s 2>&1 | 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

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

# RUN: llc -mtriple=arm-linux-unknown-gnueabi -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -mtriple=arm-linux-unknown-gnueabi -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -start-after machine-sink -stop-after machine-sink -o /dev/null %s | FileCheck %s # RUN: llc -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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

llvm/trunk/test/CodeGen/MIR/Generic/llvmIR.mir

# RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

llvm/trunk/test/CodeGen/MIR/Generic/llvmIRMissing.mir

# RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 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:
... ...

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

# RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 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):
... ...

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

# RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

llvm/trunk/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 /dev/null %s | FileCheck %s # RUN: llc -march=mipsel -mattr=mips16 -relocation-model=pic -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

llvm/trunk/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 /dev/null %s | FileCheck %s # RUN: llc -march=nvptx -mcpu=sm_20 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -mtriple=powerpc64-unknown-linux-gnu -start-after machine-combiner -stop-after machine-combiner -o /dev/null %s | FileCheck %s # RUN: llc -mtriple=powerpc64-unknown-linux-gnu -start-after machine-combiner -stop-after machine-combiner -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after prologepilog -stop-after prologepilog -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after prologepilog -stop-after prologepilog -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

llvm/trunk/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 /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -enable-shrink-wrap=true -start-after shrink-wrap -stop-after shrink-wrap -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after block-placement -stop-after block-placement -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after block-placement -stop-after block-placement -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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 89 Lines • Show Last 20 Lines

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after stackmap-liveness -stop-after stackmap-liveness -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after stackmap-liveness -stop-after stackmap-liveness -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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 499 Lines • Show Last 20 Lines

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

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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 54 Lines • Show Last 20 Lines

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -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 20 Lines • Show All 100 Lines • Show Last 20 Lines

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after machine-scheduler -stop-after machine-scheduler -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after machine-scheduler -stop-after machine-scheduler -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86 -start-after machine-sink -stop-after machine-sink -o /dev/null %s | FileCheck %s # RUN: llc -march=x86 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | 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

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

# RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s | FileCheck %s # RUN: llc -march=x86-64 -start-after machine-sink -stop-after machine-sink -o /dev/null %s 2>&1 | 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

llvm/trunk/test/CodeGen/PowerPC/stackmap-frame-setup.ll

; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=powerpc64-unknown-gnu-linux -stop-after machine-sink %s | FileCheck %s --check-prefix=ISEL ; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=powerpc64-unknown-gnu-linux -stop-after machine-sink %s 2>&1 | FileCheck %s --check-prefix=ISEL
; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=powerpc64-unknown-gnu-linux -fast-isel -fast-isel-abort=1 -stop-after machine-sink %s | FileCheck %s --check-prefix=FAST-ISEL ; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=powerpc64-unknown-gnu-linux -fast-isel -fast-isel-abort=1 -stop-after machine-sink %s 2>&1 | FileCheck %s --check-prefix=FAST-ISEL
define void @caller_meta_leaf() { define void @caller_meta_leaf() {
entry: entry:
%metadata = alloca i64, i32 3, align 8 %metadata = alloca i64, i32 3, align 8
store i64 11, i64* %metadata store i64 11, i64* %metadata
store i64 12, i64* %metadata store i64 12, i64* %metadata
store i64 13, i64* %metadata store i64 13, i64* %metadata
; ISEL: ADJCALLSTACKDOWN 0, implicit-def ; ISEL: ADJCALLSTACKDOWN 0, implicit-def
Show All 10 Lines

llvm/trunk/test/CodeGen/X86/expand-vr64-gr64-copy.mir

# RUN: llc -run-pass postrapseudos -mtriple=x86_64-unknown-unknown -mattr=+3dnow -o /dev/null %s | FileCheck %s # RUN: llc -run-pass postrapseudos -mtriple=x86_64-unknown-unknown -mattr=+3dnow -o /dev/null %s 2>&1 | FileCheck %s
# This test verifies that the ExpandPostRA pass expands the GR64 <-> VR64 # This test verifies that the ExpandPostRA pass expands the GR64 <-> VR64
# copies into appropriate MMX_MOV instructions. # copies into appropriate MMX_MOV instructions.
--- | --- |
define <2 x i32> @test_pswapdsi(<2 x i32> %a) nounwind readnone { define <2 x i32> @test_pswapdsi(<2 x i32> %a) nounwind readnone {
entry: entry:
%0 = bitcast <2 x i32> %a to x86_mmx %0 = bitcast <2 x i32> %a to x86_mmx
Show All 27 Lines

llvm/trunk/test/CodeGen/X86/stackmap-frame-setup.ll

; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=x86_64-apple-darwin -mcpu=corei7 -stop-after machine-sink %s | FileCheck %s --check-prefix=ISEL ; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=x86_64-apple-darwin -mcpu=corei7 -stop-after machine-sink %s 2>&1 | FileCheck %s --check-prefix=ISEL
; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=x86_64-apple-darwin -mcpu=corei7 -fast-isel -fast-isel-abort=1 -stop-after machine-sink %s | FileCheck %s --check-prefix=FAST-ISEL ; RUN: llc -o /dev/null -verify-machineinstrs -mtriple=x86_64-apple-darwin -mcpu=corei7 -fast-isel -fast-isel-abort=1 -stop-after machine-sink %s 2>&1 | FileCheck %s --check-prefix=FAST-ISEL
define void @caller_meta_leaf() { define void @caller_meta_leaf() {
entry: entry:
%metadata = alloca i64, i32 3, align 8 %metadata = alloca i64, i32 3, align 8
store i64 11, i64* %metadata store i64 11, i64* %metadata
store i64 12, i64* %metadata store i64 12, i64* %metadata
store i64 13, i64* %metadata store i64 13, i64* %metadata
; ISEL: ADJCALLSTACKDOWN64 0, 0, implicit-def ; ISEL: ADJCALLSTACKDOWN64 0, 0, implicit-def
Show All 10 Lines

llvm/trunk/test/CodeGen/X86/virtual-registers-cleared-in-machine-functions-liveins.ll

; RUN: llc -mtriple=x86_64-unknown-unknown -o /dev/null -stop-after machine-scheduler %s | FileCheck %s --check-prefix=PRE-RA ; RUN: llc -mtriple=x86_64-unknown-unknown -o /dev/null -stop-after machine-scheduler %s 2>&1 | FileCheck %s --check-prefix=PRE-RA
; RUN: llc -mtriple=x86_64-unknown-unknown -o /dev/null -stop-after prologepilog %s | FileCheck %s --check-prefix=POST-RA ; RUN: llc -mtriple=x86_64-unknown-unknown -o /dev/null -stop-after prologepilog %s 2>&1 | FileCheck %s --check-prefix=POST-RA
; This test verifies that the virtual register references in machine function's ; This test verifies that the virtual register references in machine function's
; liveins are cleared after register allocation. ; liveins are cleared after register allocation.
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 9 Lines

llvm/trunk/test/DebugInfo/MIR/X86/live-debug-values-3preds.mir

# RUN: llc -run-pass=livedebugvalues -march=x86-64 -o /dev/null %s | FileCheck %s # RUN: llc -run-pass=livedebugvalues -march=x86-64 -o /dev/null %s 2>&1 | FileCheck %s
# Test the extension of debug ranges from 3 predecessors. # Test the extension of debug ranges from 3 predecessors.
# Generated from the source file LiveDebugValues-3preds.c: # Generated from the source file LiveDebugValues-3preds.c:
# #include <stdio.h> # #include <stdio.h>
# int add(int x, int y, int z, int a) { # int add(int x, int y, int z, int a) {
# int i; # int i;
# for (i = 0; i < x * y; i++) { # for (i = 0; i < x * y; i++) {
# if (i < x) { # if (i < x) {
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

llvm/trunk/test/DebugInfo/MIR/X86/live-debug-values.mir

# RUN: llc -run-pass=livedebugvalues -march=x86-64 -o /dev/null %s | FileCheck %s # RUN: llc -run-pass=livedebugvalues -march=x86-64 -o /dev/null %s 2>&1 | FileCheck %s
# Test the extension of debug ranges from predecessors. # Test the extension of debug ranges from predecessors.
# Generated from the source file LiveDebugValues.c: # Generated from the source file LiveDebugValues.c:
# #include <stdio.h> # #include <stdio.h>
# int m; # int m;
# extern int inc(int n); # extern int inc(int n);
# extern int change(int n); # extern int change(int n);
# extern int modify(int n); # extern int modify(int n);
▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

llvm/trunk/test/DebugInfo/X86/bbjoin.ll

; RUN: llc -mtriple=x86_64-apple-macosx10.9.0 %s -stop-after=livedebugvars \ ; RUN: llc -mtriple=x86_64-apple-macosx10.9.0 %s -stop-after=livedebugvars \
; RUN: -o %t.s | FileCheck %s ; RUN: -o %t.s 2>&1 | FileCheck %s
; Generated from: ; Generated from:
; void g(int *); ; void g(int *);
; int f() { ; int f() {
; int x = 23; ; int x = 23;
; g(&x); ; g(&x);
; if (x == 42) ; if (x == 42)
; ++x; ; ++x;
; return x; // check that x is not a constant here. ; return x; // check that x is not a constant here.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

llvm/trunk/test/DebugInfo/X86/safestack-byval.ll

; Test dwarf codegen for DILocalVariable of a byval function argument that ; Test dwarf codegen for DILocalVariable of a byval function argument that
; points to neither an argument nor an alloca. This kind of IR is generated by ; points to neither an argument nor an alloca. This kind of IR is generated by
; SafeStack for unsafe byval arguments. ; SafeStack for unsafe byval arguments.
; RUN: llc -mtriple=x86_64-unknown-unknown -stop-after expand-isel-pseudos %s -o /dev/null | FileCheck %s ; RUN: llc -mtriple=x86_64-unknown-unknown -stop-after expand-isel-pseudos %s -o /dev/null 2>&1 | FileCheck %s
; This was built by compiling the following source with SafeStack and ; This was built by compiling the following source with SafeStack and
; simplifying the result a little. ; simplifying the result a little.
; struct S { ; struct S {
; int a[100]; ; int a[100];
; }; ; };
; ;
; int f(S zzz, unsigned long len) { ; int f(S zzz, unsigned long len) {
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines