2017-02-23 02:47:41 +08:00
|
|
|
# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - | FileCheck %s
|
2016-08-05 05:39:49 +08:00
|
|
|
|
|
|
|
|
--- |
|
|
|
|
|
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
|
2016-10-14 18:19:40 +08:00
|
|
|
target triple = "aarch64--"
|
2016-08-05 05:39:49 +08:00
|
|
|
define void @test_scalar_and_small() {
|
|
|
|
|
entry:
|
|
|
|
|
ret void
|
|
|
|
|
}
|
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
|
name: test_scalar_and_small
|
|
|
|
|
registers:
|
|
|
|
|
- { id: 0, class: _ }
|
|
|
|
|
- { id: 1, class: _ }
|
|
|
|
|
- { id: 2, class: _ }
|
2016-08-31 02:52:46 +08:00
|
|
|
- { id: 3, class: _ }
|
|
|
|
|
- { id: 4, class: _ }
|
|
|
|
|
- { id: 5, class: _ }
|
2016-08-05 05:39:49 +08:00
|
|
|
body: |
|
|
|
|
|
bb.0.entry:
|
|
|
|
|
liveins: %x0, %x1, %x2, %x3
|
|
|
|
|
; CHECK-LABEL: name: test_scalar_and_small
|
2017-08-31 03:32:59 +08:00
|
|
|
; CHECK: [[A:%.*]](s64) = COPY %x0
|
|
|
|
|
; CHECK: [[B:%.*]](s64) = COPY %x1
|
|
|
|
|
; CHECK: [[OP0:%.*]](s32) = G_TRUNC [[A]]
|
|
|
|
|
; CHECK: [[OP1:%.*]](s32) = G_TRUNC [[B]]
|
[AArch64][GlobalISel] Legalize narrow scalar ops again.
Since r279760, we've been marking as legal operations on narrow integer
types that have wider legal equivalents (for instance, G_ADD s8).
Compared to legalizing these operations, this reduced the amount of
extends/truncates required, but was always a weird legalization decision
made at selection time.
So far, we haven't been able to formalize it in a way that permits the
selector generated from SelectionDAG patterns to be sufficient.
Using a wide instruction (say, s64), when a narrower instruction exists
(s32) would introduce register class incompatibilities (when one narrow
generic instruction is selected to the wider variant, but another is
selected to the narrower variant).
It's also impractical to limit which narrow operations are matched for
which instruction, as restricting "narrow selection" to ranges of types
clashes with potentially incompatible instruction predicates.
Concerns were also raised regarding MIPS64's sign-extended register
assumptions, as well as wrapping behavior.
See discussions in https://reviews.llvm.org/D26878.
Instead, legalize the operations.
Should we ever revert to selecting these narrow operations, we should
try to represent this more accurately: for instance, by separating
a "concrete" type on operations, and an "underlying" type on vregs, we
could move the "this narrow-looking op is really legal" decision to the
legalizer, and let the selector use the "underlying" vreg type only,
which would be guaranteed to map to a register class.
In any case, we eventually should mitigate:
- the performance impact by selecting no-op extract/truncates to COPYs
(which we currently do), and the COPYs to register reuses (which we
don't do yet).
- the compile-time impact by optimizing away extract/truncate sequences
in the legalizer.
llvm-svn: 292827
2017-01-24 05:10:05 +08:00
|
|
|
; CHECK: [[RES32:%.*]](s32) = G_AND [[OP0]], [[OP1]]
|
|
|
|
|
; CHECK: [[RES:%.*]](s8) = G_TRUNC [[RES32]](s32)
|
2016-08-05 05:39:49 +08:00
|
|
|
|
2016-09-09 19:47:31 +08:00
|
|
|
%0(s64) = COPY %x0
|
|
|
|
|
%1(s64) = COPY %x1
|
2016-09-09 19:46:34 +08:00
|
|
|
%2(s8) = G_TRUNC %0
|
|
|
|
|
%3(s8) = G_TRUNC %1
|
|
|
|
|
%4(s8) = G_AND %2, %3
|
|
|
|
|
%5(s64) = G_ANYEXT %2
|
2016-08-31 02:52:46 +08:00
|
|
|
%x0 = COPY %5
|
2016-08-05 05:39:49 +08:00
|
|
|
...
|