RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
Code Issues Projects Releases Wiki Activity
d3598a0449
llvm-mirror/test/Transforms/InstCombine/aggregate-reconstruction.ll
Roman Lebedev e44f2bc0d5 [InstCombine] Aggregate reconstruction simplification (PR47060) 
This pattern happens in clang C++ exception lowering code, on unwind branch.
We end up having a `landingpad` block after each `invoke`, where RAII
cleanup is performed, and the elements of an aggregate `{i8*, i32}`
holding exception info are `extractvalue`'d, and we then branch to common block
that takes extracted `i8*` and `i32` elements (via `phi` nodes),
form a new aggregate, and finally `resume`'s the exception.

The problem is that, if the cleanup block is effectively empty,
it shouldn't be there, there shouldn't be that `landingpad` and `resume`,
said `invoke` should be a  `call`.

Indeed, we do that simplification in e.g. SimplifyCFG `SimplifyCFGOpt::simplifyResume()`.
But the thing is, all this extra `extractvalue` + `phi` + `insertvalue` cruft,
while it is pointless, does not look like "empty cleanup block".
So the `SimplifyCFGOpt::simplifyResume()` fails, and the exception is has
higher cost than it could have on unwind branch :S

This doesn't happen *that* often, but it will basically happen once per C++
function with complex CFG that called more than one other function
that isn't known to be `nounwind`.

I think, this is a missing fold in InstCombine, so i've implemented it.

I think, the algorithm/implementation is rather self-explanatory:
1. Find a chain of `insertvalue`'s that fully tell us the initializer of the aggregate.
2. For each element, try to find from which aggregate it was extracted.
   If it was extracted from the aggregate with identical type,
   from identical element index, great.
3. If all elements were found to have been extracted from the same aggregate,
   then we can just use said original source aggregate directly,
   instead of re-creating it.
4. If we fail to find said aggregate when looking only in the current block,
   we need be PHI-aware - we might have different source aggregate when coming
   from each predecessor.

I'm not sure if this already handles everything, and there are some FIXME's,
i'll deal with all that later in followups.

I'd be fine with going with post-commit review here code-wise,
but just in case there are thoughts, i'm posting this.

On RawSpeed, for example, this has the following effect:
```
| statistic name                                    | baseline | proposed |     Δ |       % | abs(%) |
|---------------------------------------------------|---------:|---------:|------:|--------:|-------:|
| instcombine.NumAggregateReconstructionsSimplified |        0 |     1253 |  1253 |   0.00% |  0.00% |
| simplifycfg.NumInvokes                            |      948 |     1355 |   407 |  42.93% | 42.93% |
| instcount.NumInsertValueInst                      |     4382 |     3210 | -1172 | -26.75% | 26.75% |
| simplifycfg.NumSinkCommonCode                     |      574 |      458 |  -116 | -20.21% | 20.21% |
| simplifycfg.NumSinkCommonInstrs                   |     1154 |      921 |  -233 | -20.19% | 20.19% |
| instcount.NumExtractValueInst                     |    29017 |    26397 | -2620 |  -9.03% |  9.03% |
| instcombine.NumDeadInst                           |   166618 |   174705 |  8087 |   4.85% |  4.85% |
| instcount.NumPHIInst                              |    51526 |    50678 |  -848 |  -1.65% |  1.65% |
| instcount.NumLandingPadInst                       |    20865 |    20609 |  -256 |  -1.23% |  1.23% |
| instcount.NumInvokeInst                           |    34023 |    33675 |  -348 |  -1.02% |  1.02% |
| simplifycfg.NumSimpl                              |   113634 |   114708 |  1074 |   0.95% |  0.95% |
| instcombine.NumSunkInst                           |    15030 |    14930 |  -100 |  -0.67% |  0.67% |
| instcount.TotalBlocks                             |   219544 |   219024 |  -520 |  -0.24% |  0.24% |
| instcombine.NumCombined                           |   644562 |   645805 |  1243 |   0.19% |  0.19% |
| instcount.TotalInsts                              |  2139506 |  2135377 | -4129 |  -0.19% |  0.19% |
| instcount.NumBrInst                               |   156988 |   156821 |  -167 |  -0.11% |  0.11% |
| instcount.NumCallInst                             |  1206144 |  1207076 |   932 |   0.08% |  0.08% |
| instcount.NumResumeInst                           |     5193 |     5190 |    -3 |  -0.06% |  0.06% |
| asm-printer.EmittedInsts                          |   948580 |   948299 |  -281 |  -0.03% |  0.03% |
| instcount.TotalFuncs                              |    11509 |    11507 |    -2 |  -0.02% |  0.02% |
| inline.NumDeleted                                 |    97595 |    97597 |     2 |   0.00% |  0.00% |
| inline.NumInlined                                 |   210514 |   210522 |     8 |   0.00% |  0.00% |
```
So we manage to increase the amount of `invoke` -> `call` conversions in SimplifyCFG by almost a half,
and there is a very apparent decrease in instruction and basic block count.

On vanilla llvm-test-suite:
```
| statistic name                                    | baseline | proposed |     Δ |       % | abs(%) |
|---------------------------------------------------|---------:|---------:|------:|--------:|-------:|
| instcombine.NumAggregateReconstructionsSimplified |        0 |      744 |   744 |   0.00% |  0.00% |
| instcount.NumInsertValueInst                      |     2705 |     2053 |  -652 | -24.10% | 24.10% |
| simplifycfg.NumInvokes                            |     1212 |     1424 |   212 |  17.49% | 17.49% |
| instcount.NumExtractValueInst                     |    21681 |    20139 | -1542 |  -7.11% |  7.11% |
| simplifycfg.NumSinkCommonInstrs                   |    14575 |    14361 |  -214 |  -1.47% |  1.47% |
| simplifycfg.NumSinkCommonCode                     |     6815 |     6743 |   -72 |  -1.06% |  1.06% |
| instcount.NumLandingPadInst                       |    14851 |    14712 |  -139 |  -0.94% |  0.94% |
| instcount.NumInvokeInst                           |    27510 |    27332 |  -178 |  -0.65% |  0.65% |
| instcombine.NumDeadInst                           |  1438173 |  1443371 |  5198 |   0.36% |  0.36% |
| instcount.NumResumeInst                           |     2880 |     2872 |    -8 |  -0.28% |  0.28% |
| instcombine.NumSunkInst                           |    55187 |    55076 |  -111 |  -0.20% |  0.20% |
| instcount.NumPHIInst                              |   321366 |   320916 |  -450 |  -0.14% |  0.14% |
| instcount.TotalBlocks                             |   886816 |   886493 |  -323 |  -0.04% |  0.04% |
| instcount.TotalInsts                              |  7663845 |  7661108 | -2737 |  -0.04% |  0.04% |
| simplifycfg.NumSimpl                              |   886791 |   887171 |   380 |   0.04% |  0.04% |
| instcount.NumCallInst                             |   553552 |   553733 |   181 |   0.03% |  0.03% |
| instcombine.NumCombined                           |  3200512 |  3201202 |   690 |   0.02% |  0.02% |
| instcount.NumBrInst                               |   741794 |   741656 |  -138 |  -0.02% |  0.02% |
| simplifycfg.NumHoistCommonInstrs                  |    14443 |    14445 |     2 |   0.01% |  0.01% |
| asm-printer.EmittedInsts                          |  7978085 |  7977916 |  -169 |   0.00% |  0.00% |
| inline.NumDeleted                                 |    73188 |    73189 |     1 |   0.00% |  0.00% |
| inline.NumInlined                                 |   291959 |   291968 |     9 |   0.00% |  0.00% |
```
Roughly similar effect, less instructions and blocks total.

See also: rGe492f0e03b01a5e4ec4b6333abb02d303c3e479e.

Compile-time wise, this appears to be roughly geomean-neutral:
http://llvm-compile-time-tracker.com/compare.php?from=39617aaed95ac00957979bc1525598c1be80e85e&to=b59866cf30420da8f8e3ca239ed3bec577b23387&stat=instructions

And this is a win size-wize in general:
http://llvm-compile-time-tracker.com/compare.php?from=39617aaed95ac00957979bc1525598c1be80e85e&to=b59866cf30420da8f8e3ca239ed3bec577b23387&stat=size-text

See https://bugs.llvm.org/show_bug.cgi?id=47060

Reviewed By: spatel

Differential Revision: https://reviews.llvm.org/D85787
2020-08-16 23:27:56 +03:00

304 lines
12 KiB
LLVM
Raw Blame History

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s
declare void @foo()
declare void @bar()
declare void @baz()
declare void @usei32(i32)
declare void @usei32i32agg({ i32, i32 })
; Most basic test - we explode the original aggregate into it's elements,
; and then merge them back together exactly the way they were.
; We should just return the source aggregate.
define { i32, i32 } @test0({ i32, i32 } %srcagg) {
; CHECK-LABEL: @test0(
; CHECK-NEXT: ret { i32, i32 } [[SRCAGG:%.*]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
%i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i3 = insertvalue { i32, i32 } %i2, i32 %i1, 1
ret { i32, i32 } %i3
}
; Arrays are still aggregates
define [2 x i32] @test1([2 x i32] %srcagg) {
; CHECK-LABEL: @test1(
; CHECK-NEXT: ret [2 x i32] [[SRCAGG:%.*]]
;
%i0 = extractvalue [2 x i32] %srcagg, 0
%i1 = extractvalue [2 x i32] %srcagg, 1
%i2 = insertvalue [2 x i32] undef, i32 %i0, 0
%i3 = insertvalue [2 x i32] %i2, i32 %i1, 1
ret [2 x i32] %i3
}
; Right now we don't deal with case where there are more than 2 elements.
; FIXME: should we?
define [3 x i32] @test2([3 x i32] %srcagg) {
; CHECK-LABEL: @test2(
; CHECK-NEXT: [[I0:%.*]] = extractvalue [3 x i32] [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I1:%.*]] = extractvalue [3 x i32] [[SRCAGG]], 1
; CHECK-NEXT: [[I2:%.*]] = extractvalue [3 x i32] [[SRCAGG]], 2
; CHECK-NEXT: [[I3:%.*]] = insertvalue [3 x i32] undef, i32 [[I0]], 0
; CHECK-NEXT: [[I4:%.*]] = insertvalue [3 x i32] [[I3]], i32 [[I1]], 1
; CHECK-NEXT: [[I5:%.*]] = insertvalue [3 x i32] [[I4]], i32 [[I2]], 2
; CHECK-NEXT: ret [3 x i32] [[I5]]
;
%i0 = extractvalue [3 x i32] %srcagg, 0
%i1 = extractvalue [3 x i32] %srcagg, 1
%i2 = extractvalue [3 x i32] %srcagg, 2
%i3 = insertvalue [3 x i32] undef, i32 %i0, 0
%i4 = insertvalue [3 x i32] %i3, i32 %i1, 1
%i5 = insertvalue [3 x i32] %i4, i32 %i2, 2
ret [3 x i32] %i5
}
; Likewise, we only deal with a single-level aggregates.
; FIXME: should we?
define {{ i32, i32 }} @test3({{ i32, i32 }} %srcagg) {
; CHECK-LABEL: @test3(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { { i32, i32 } } [[SRCAGG:%.*]], 0, 0
; CHECK-NEXT: [[I1:%.*]] = extractvalue { { i32, i32 } } [[SRCAGG]], 0, 1
; CHECK-NEXT: [[I2:%.*]] = insertvalue { { i32, i32 } } undef, i32 [[I0]], 0, 0
; CHECK-NEXT: [[I3:%.*]] = insertvalue { { i32, i32 } } [[I2]], i32 [[I1]], 0, 1
; CHECK-NEXT: ret { { i32, i32 } } [[I3]]
;
%i0 = extractvalue {{ i32, i32 }} %srcagg, 0, 0
%i1 = extractvalue {{ i32, i32 }} %srcagg, 0, 1
%i2 = insertvalue {{ i32, i32 }} undef, i32 %i0, 0, 0
%i3 = insertvalue {{ i32, i32 }} %i2, i32 %i1, 0, 1
ret {{ i32, i32 }} %i3
}
; This is fine, however, all elements are on the same level
define { i32, { i32 } } @test4({ i32, { i32 } } %srcagg) {
; CHECK-LABEL: @test4(
; CHECK-NEXT: ret { i32, { i32 } } [[SRCAGG:%.*]]
;
%i0 = extractvalue { i32, { i32 } } %srcagg, 0
%i1 = extractvalue { i32, { i32 } } %srcagg, 1
%i2 = insertvalue { i32, { i32 } } undef, i32 %i0, 0
%i3 = insertvalue { i32, { i32 } } %i2, { i32 } %i1, 1
ret { i32, { i32 } } %i3
}
; All element of the newly-created aggregate must come from the same base
; aggregate. Here the second element comes from some other origin.
define { i32, i32 } @negative_test5({ i32, i32 } %srcagg, i32 %replacement) {
; CHECK-LABEL: @negative_test5(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32 } [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 0
; CHECK-NEXT: [[I3:%.*]] = insertvalue { i32, i32 } [[I2]], i32 [[REPLACEMENT:%.*]], 1
; CHECK-NEXT: ret { i32, i32 } [[I3]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
; %i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i3 = insertvalue { i32, i32 } %i2, i32 %replacement, 1
ret { i32, i32 } %i3
}
; Here we don't know the value of second element of %otheragg,
define { i32, i32 } @negative_test6({ i32, i32 } %srcagg, { i32, i32 } %otheragg) {
; CHECK-LABEL: @negative_test6(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32 } [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } [[OTHERAGG:%.*]], i32 [[I0]], 0
; CHECK-NEXT: ret { i32, i32 } [[I2]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
; %i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } %otheragg, i32 %i0, 0
ret { i32, i32 } %i2
}
; All element of the newly-created aggregate must come from the same base
; aggregate. Here different elements come from different base aggregates.
define { i32, i32 } @negative_test7({ i32, i32 } %srcagg0, { i32, i32 } %srcagg1) {
; CHECK-LABEL: @negative_test7(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32 } [[SRCAGG0:%.*]], 0
; CHECK-NEXT: [[I3:%.*]] = extractvalue { i32, i32 } [[SRCAGG1:%.*]], 1
; CHECK-NEXT: [[I4:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 0
; CHECK-NEXT: [[I5:%.*]] = insertvalue { i32, i32 } [[I4]], i32 [[I3]], 1
; CHECK-NEXT: ret { i32, i32 } [[I5]]
;
%i0 = extractvalue { i32, i32 } %srcagg0, 0
; %i1 = extractvalue { i32, i32 } %srcagg0, 1
; %i2 = extractvalue { i32, i32 } %srcagg1, 0
%i3 = extractvalue { i32, i32 } %srcagg1, 1
%i4 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i5 = insertvalue { i32, i32 } %i4, i32 %i3, 1
ret { i32, i32 } %i5
}
; Here the element order is swapped as compared to the base aggregate.
define { i32, i32 } @negative_test8({ i32, i32 } %srcagg) {
; CHECK-LABEL: @negative_test8(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32 } [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I1:%.*]] = extractvalue { i32, i32 } [[SRCAGG]], 1
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 1
; CHECK-NEXT: [[I3:%.*]] = insertvalue { i32, i32 } [[I2]], i32 [[I1]], 0
; CHECK-NEXT: ret { i32, i32 } [[I3]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
%i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 1
%i3 = insertvalue { i32, i32 } %i2, i32 %i1, 0
ret { i32, i32 } %i3
}
; Here both elements of the new aggregate come from the same element of the old aggregate.
define { i32, i32 } @negative_test9({ i32, i32 } %srcagg) {
; CHECK-LABEL: @negative_test9(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32 } [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 0
; CHECK-NEXT: [[I3:%.*]] = insertvalue { i32, i32 } [[I2]], i32 [[I0]], 1
; CHECK-NEXT: ret { i32, i32 } [[I3]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
; %i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i3 = insertvalue { i32, i32 } %i2, i32 %i0, 1
ret { i32, i32 } %i3
}
; Here the second element of the new aggregate is undef, , so we must keep this as-is, because in %srcagg it might be poison.
; FIXME: defer to noundef attribute on %srcagg
define { i32, i32 } @negative_test10({ i32, i32 } %srcagg) {
; CHECK-LABEL: @negative_test10(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32 } [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 0
; CHECK-NEXT: ret { i32, i32 } [[I2]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
; %i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
ret { i32, i32 } %i2
}
; Here the second element of the new aggregate is undef, so we must keep this as-is, because in %srcagg it might be poison.
; FIXME: defer to noundef attribute on %srcagg
define { i32, i32 } @negative_test11({ i32, i32 } %srcagg) {
; CHECK-LABEL: @negative_test11(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32 } [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 0
; CHECK-NEXT: [[I3:%.*]] = insertvalue { i32, i32 } [[I2]], i32 undef, 1
; CHECK-NEXT: ret { i32, i32 } [[I3]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
; %i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i3 = insertvalue { i32, i32 } %i2, i32 undef, 1
ret { i32, i32 } %i3
}
; This fold does not care whether or not intermediate instructions have extra uses.
define { i32, i32 } @test12({ i32, i32 } %srcagg) {
; CHECK-LABEL: @test12(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32 } [[SRCAGG:%.*]], 0
; CHECK-NEXT: call void @usei32(i32 [[I0]])
; CHECK-NEXT: [[I1:%.*]] = extractvalue { i32, i32 } [[SRCAGG]], 1
; CHECK-NEXT: call void @usei32(i32 [[I1]])
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 0
; CHECK-NEXT: call void @usei32i32agg({ i32, i32 } [[I2]])
; CHECK-NEXT: ret { i32, i32 } [[SRCAGG]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
call void @usei32(i32 %i0)
%i1 = extractvalue { i32, i32 } %srcagg, 1
call void @usei32(i32 %i1)
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
call void @usei32i32agg({ i32, i32 } %i2)
%i3 = insertvalue { i32, i32 } %i2, i32 %i1, 1
ret { i32, i32 } %i3
}
; Even though we originally store %i1 into first element, it is later
; overwritten with %i0, so all is fine.
define { i32, i32 } @test13({ i32, i32 } %srcagg) {
; CHECK-LABEL: @test13(
; CHECK-NEXT: ret { i32, i32 } [[SRCAGG:%.*]]
;
%i0 = extractvalue { i32, i32 } %srcagg, 0
%i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i1, 0
%i3 = insertvalue { i32, i32 } %i2, i32 %i0, 0
%i4 = insertvalue { i32, i32 } %i3, i32 %i1, 1
ret { i32, i32 } %i4
}
; The aggregate type must match exactly between the original and recreation.
define { i32, i32 } @negative_test14({ i32, i32, i32 } %srcagg) {
; CHECK-LABEL: @negative_test14(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, i32, i32 } [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I1:%.*]] = extractvalue { i32, i32, i32 } [[SRCAGG]], 1
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 0
; CHECK-NEXT: [[I3:%.*]] = insertvalue { i32, i32 } [[I2]], i32 [[I1]], 1
; CHECK-NEXT: ret { i32, i32 } [[I3]]
;
%i0 = extractvalue { i32, i32, i32 } %srcagg, 0
%i1 = extractvalue { i32, i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i3 = insertvalue { i32, i32 } %i2, i32 %i1, 1
ret { i32, i32 } %i3
}
define { i32, i32 } @negative_test15({ i32, {i32} } %srcagg) {
; CHECK-LABEL: @negative_test15(
; CHECK-NEXT: [[I0:%.*]] = extractvalue { i32, { i32 } } [[SRCAGG:%.*]], 0
; CHECK-NEXT: [[I1:%.*]] = extractvalue { i32, { i32 } } [[SRCAGG]], 1, 0
; CHECK-NEXT: [[I2:%.*]] = insertvalue { i32, i32 } undef, i32 [[I0]], 0
; CHECK-NEXT: [[I3:%.*]] = insertvalue { i32, i32 } [[I2]], i32 [[I1]], 1
; CHECK-NEXT: ret { i32, i32 } [[I3]]
;
%i0 = extractvalue { i32, {i32} } %srcagg, 0
%i1 = extractvalue { i32, {i32} } %srcagg, 1, 0
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i3 = insertvalue { i32, i32 } %i2, i32 %i1, 1
ret { i32, i32 } %i3
}
; Just because there are predecessors doesn't mean we should look into them.
define { i32, i32 } @test16({ i32, i32 } %srcagg) {
; CHECK-LABEL: @test16(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[END:%.*]]
; CHECK: end:
; CHECK-NEXT: ret { i32, i32 } [[SRCAGG:%.*]]
;
entry:
br label %end
end:
%i0 = extractvalue { i32, i32 } %srcagg, 0
%i1 = extractvalue { i32, i32 } %srcagg, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i3 = insertvalue { i32, i32 } %i2, i32 %i1, 1
ret { i32, i32 } %i3
}
; Again, we should first try to perform local reasoning, without looking to predecessors.
define { i32, i32 } @test17({ i32, i32 } %srcagg0, { i32, i32 } %srcagg1, i1 %c) {
; CHECK-LABEL: @test17(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C:%.*]], label [[INTERMEDIATE:%.*]], label [[END:%.*]]
; CHECK: intermediate:
; CHECK-NEXT: br label [[END]]
; CHECK: end:
; CHECK-NEXT: [[SRCAGG_PHI:%.*]] = phi { i32, i32 } [ [[SRCAGG0:%.*]], [[ENTRY:%.*]] ], [ [[SRCAGG1:%.*]], [[INTERMEDIATE]] ]
; CHECK-NEXT: ret { i32, i32 } [[SRCAGG_PHI]]
;
entry:
br i1 %c, label %intermediate, label %end
intermediate:
br label %end
end:
%srcagg.phi = phi { i32, i32 } [ %srcagg0, %entry ], [ %srcagg1, %intermediate ]
%i0 = extractvalue { i32, i32 } %srcagg.phi, 0
%i1 = extractvalue { i32, i32 } %srcagg.phi, 1
%i2 = insertvalue { i32, i32 } undef, i32 %i0, 0
%i3 = insertvalue { i32, i32 } %i2, i32 %i1, 1
ret { i32, i32 } %i3
}
Reference in New Issue View Git Blame Copy Permalink