| ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6 | |
| ; RUN: opt -S -passes=structurizecfg < %s | FileCheck %s --implicit-check-not="!llvm.loop" | |
| ; Loop metadata should be kept on the backedge of a restructured loop. | |
| define void @single_latch(i32 %n) { | |
| ; CHECK-LABEL: define void @single_latch( | |
| ; CHECK-SAME: i32 [[N:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*]]: | |
| ; CHECK-NEXT: br label %[[LOOP:.*]] | |
| ; CHECK: [[LOOP]]: | |
| ; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[LOOP]] ] | |
| ; CHECK-NEXT: [[I_NEXT]] = add i32 [[I]], 1 | |
| ; CHECK-NEXT: [[C:%.*]] = icmp uge i32 [[I_NEXT]], [[N]] | |
| ; CHECK-NEXT: br i1 [[C]], label %[[EXIT:.*]], label %[[LOOP]] | |
| ; CHECK: [[EXIT]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br label %loop | |
| loop: | |
| %i = phi i32 [ 0, %entry ], [ %i.next, %loop ] | |
| %i.next = add i32 %i, 1 | |
| %c = icmp ult i32 %i.next, %n | |
| br i1 %c, label %loop, label %exit, !llvm.loop !0 | |
| exit: | |
| ret void | |
| } | |
| ; The two latches are in a nested region and carry the same metadata. | |
| define void @two_latches(i32 %n, i1 %c2) { | |
| ; CHECK-LABEL: define void @two_latches( | |
| ; CHECK-SAME: i32 [[N:%.*]], i1 [[C2:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*]]: | |
| ; CHECK-NEXT: [[C2_INV:%.*]] = xor i1 [[C2]], true | |
| ; CHECK-NEXT: br label %[[HEADER:.*]] | |
| ; CHECK: [[FLOW1:.*]]: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = phi i32 [ [[I_A:%.*]], %[[A:.*]] ], [ [[TMP1:%.*]], %[[FLOW:.*]] ] | |
| ; CHECK-NEXT: br label %[[FLOW2:.*]] | |
| ; CHECK: [[HEADER]]: | |
| ; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[TMP3:%.*]], %[[FLOW2]] ] | |
| ; CHECK-NEXT: [[C1:%.*]] = icmp ult i32 [[I]], [[N]] | |
| ; CHECK-NEXT: br i1 [[C1]], label %[[BODY:.*]], label %[[FLOW2]] | |
| ; CHECK: [[BODY]]: | |
| ; CHECK-NEXT: br i1 [[C2_INV]], label %[[B:.*]], label %[[FLOW]] | |
| ; CHECK: [[FLOW]]: | |
| ; CHECK-NEXT: [[TMP1]] = phi i32 [ [[I_B:%.*]], %[[B]] ], [ poison, %[[BODY]] ] | |
| ; CHECK-NEXT: [[TMP2:%.*]] = phi i1 [ false, %[[B]] ], [ true, %[[BODY]] ] | |
| ; CHECK-NEXT: br i1 [[TMP2]], label %[[A]], label %[[FLOW1]] | |
| ; CHECK: [[A]]: | |
| ; CHECK-NEXT: [[I_A]] = add i32 [[I]], 1 | |
| ; CHECK-NEXT: br label %[[FLOW1]] | |
| ; CHECK: [[B]]: | |
| ; CHECK-NEXT: [[I_B]] = add i32 [[I]], 2 | |
| ; CHECK-NEXT: br label %[[FLOW]] | |
| ; CHECK: [[FLOW2]]: | |
| ; CHECK-NEXT: [[TMP3]] = phi i32 [ [[TMP0]], %[[FLOW1]] ], [ poison, %[[HEADER]] ] | |
| ; CHECK-NEXT: [[TMP4:%.*]] = phi i1 [ false, %[[FLOW1]] ], [ true, %[[HEADER]] ] | |
| ; CHECK-NEXT: br i1 [[TMP4]], label %[[EXIT:.*]], label %[[HEADER]] | |
| ; CHECK: [[EXIT]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br label %header | |
| header: | |
| %i = phi i32 [ 0, %entry ], [ %i.a, %a ], [ %i.b, %b ] | |
| %c1 = icmp ult i32 %i, %n | |
| br i1 %c1, label %body, label %exit | |
| body: | |
| br i1 %c2, label %a, label %b | |
| a: | |
| %i.a = add i32 %i, 1 | |
| br label %header, !llvm.loop !2 | |
| b: | |
| %i.b = add i32 %i, 2 | |
| br label %header, !llvm.loop !2 | |
| exit: | |
| ret void | |
| } | |
| ; One of the latches has no metadata. | |
| define void @latch_without_metadata(i32 %n, i1 %c2) { | |
| ; CHECK-LABEL: define void @latch_without_metadata( | |
| ; CHECK-SAME: i32 [[N:%.*]], i1 [[C2:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*]]: | |
| ; CHECK-NEXT: [[C2_INV:%.*]] = xor i1 [[C2]], true | |
| ; CHECK-NEXT: br label %[[HEADER:.*]] | |
| ; CHECK: [[FLOW1:.*]]: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = phi i32 [ [[I_A:%.*]], %[[A:.*]] ], [ [[TMP1:%.*]], %[[FLOW:.*]] ] | |
| ; CHECK-NEXT: br label %[[FLOW2:.*]] | |
| ; CHECK: [[HEADER]]: | |
| ; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[TMP3:%.*]], %[[FLOW2]] ] | |
| ; CHECK-NEXT: [[C1:%.*]] = icmp ult i32 [[I]], [[N]] | |
| ; CHECK-NEXT: br i1 [[C1]], label %[[BODY:.*]], label %[[FLOW2]] | |
| ; CHECK: [[BODY]]: | |
| ; CHECK-NEXT: br i1 [[C2_INV]], label %[[B:.*]], label %[[FLOW]] | |
| ; CHECK: [[FLOW]]: | |
| ; CHECK-NEXT: [[TMP1]] = phi i32 [ [[I_B:%.*]], %[[B]] ], [ poison, %[[BODY]] ] | |
| ; CHECK-NEXT: [[TMP2:%.*]] = phi i1 [ false, %[[B]] ], [ true, %[[BODY]] ] | |
| ; CHECK-NEXT: br i1 [[TMP2]], label %[[A]], label %[[FLOW1]] | |
| ; CHECK: [[A]]: | |
| ; CHECK-NEXT: [[I_A]] = add i32 [[I]], 1 | |
| ; CHECK-NEXT: br label %[[FLOW1]] | |
| ; CHECK: [[B]]: | |
| ; CHECK-NEXT: [[I_B]] = add i32 [[I]], 2 | |
| ; CHECK-NEXT: br label %[[FLOW]] | |
| ; CHECK: [[FLOW2]]: | |
| ; CHECK-NEXT: [[TMP3]] = phi i32 [ [[TMP0]], %[[FLOW1]] ], [ poison, %[[HEADER]] ] | |
| ; CHECK-NEXT: [[TMP4:%.*]] = phi i1 [ false, %[[FLOW1]] ], [ true, %[[HEADER]] ] | |
| ; CHECK-NEXT: br i1 [[TMP4]], label %[[EXIT:.*]], label %[[HEADER]] | |
| ; CHECK: [[EXIT]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br label %header | |
| header: | |
| %i = phi i32 [ 0, %entry ], [ %i.a, %a ], [ %i.b, %b ] | |
| %c1 = icmp ult i32 %i, %n | |
| br i1 %c1, label %body, label %exit | |
| body: | |
| br i1 %c2, label %a, label %b | |
| a: | |
| %i.a = add i32 %i, 1 | |
| br label %header, !llvm.loop !3 | |
| b: | |
| %i.b = add i32 %i, 2 | |
| br label %header | |
| exit: | |
| ret void | |
| } | |
| ; The latches carry different metadata. | |
| define void @latches_with_different_metadata(i32 %n, i1 %c2) { | |
| ; CHECK-LABEL: define void @latches_with_different_metadata( | |
| ; CHECK-SAME: i32 [[N:%.*]], i1 [[C2:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*]]: | |
| ; CHECK-NEXT: [[C2_INV:%.*]] = xor i1 [[C2]], true | |
| ; CHECK-NEXT: br label %[[HEADER:.*]] | |
| ; CHECK: [[FLOW1:.*]]: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = phi i32 [ [[I_A:%.*]], %[[A:.*]] ], [ [[TMP1:%.*]], %[[FLOW:.*]] ] | |
| ; CHECK-NEXT: br label %[[FLOW2:.*]] | |
| ; CHECK: [[HEADER]]: | |
| ; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[TMP3:%.*]], %[[FLOW2]] ] | |
| ; CHECK-NEXT: [[C1:%.*]] = icmp ult i32 [[I]], [[N]] | |
| ; CHECK-NEXT: br i1 [[C1]], label %[[BODY:.*]], label %[[FLOW2]] | |
| ; CHECK: [[BODY]]: | |
| ; CHECK-NEXT: br i1 [[C2_INV]], label %[[B:.*]], label %[[FLOW]] | |
| ; CHECK: [[FLOW]]: | |
| ; CHECK-NEXT: [[TMP1]] = phi i32 [ [[I_B:%.*]], %[[B]] ], [ poison, %[[BODY]] ] | |
| ; CHECK-NEXT: [[TMP2:%.*]] = phi i1 [ false, %[[B]] ], [ true, %[[BODY]] ] | |
| ; CHECK-NEXT: br i1 [[TMP2]], label %[[A]], label %[[FLOW1]] | |
| ; CHECK: [[A]]: | |
| ; CHECK-NEXT: [[I_A]] = add i32 [[I]], 1 | |
| ; CHECK-NEXT: br label %[[FLOW1]] | |
| ; CHECK: [[B]]: | |
| ; CHECK-NEXT: [[I_B]] = add i32 [[I]], 2 | |
| ; CHECK-NEXT: br label %[[FLOW]] | |
| ; CHECK: [[FLOW2]]: | |
| ; CHECK-NEXT: [[TMP3]] = phi i32 [ [[TMP0]], %[[FLOW1]] ], [ poison, %[[HEADER]] ] | |
| ; CHECK-NEXT: [[TMP4:%.*]] = phi i1 [ false, %[[FLOW1]] ], [ true, %[[HEADER]] ] | |
| ; CHECK-NEXT: br i1 [[TMP4]], label %[[EXIT:.*]], label %[[HEADER]] | |
| ; CHECK: [[EXIT]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br label %header | |
| header: | |
| %i = phi i32 [ 0, %entry ], [ %i.a, %a ], [ %i.b, %b ] | |
| %c1 = icmp ult i32 %i, %n | |
| br i1 %c1, label %body, label %exit | |
| body: | |
| br i1 %c2, label %a, label %b | |
| a: | |
| %i.a = add i32 %i, 1 | |
| br label %header, !llvm.loop !4 | |
| b: | |
| %i.b = add i32 %i, 2 | |
| br label %header, !llvm.loop !5 | |
| exit: | |
| ret void | |
| } | |
| define void @nested_loops(i32 %n, i32 %m) { | |
| ; CHECK-LABEL: define void @nested_loops( | |
| ; CHECK-SAME: i32 [[N:%.*]], i32 [[M:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*]]: | |
| ; CHECK-NEXT: br label %[[OUTER:.*]] | |
| ; CHECK: [[OUTER]]: | |
| ; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ] | |
| ; CHECK-NEXT: br label %[[INNER:.*]] | |
| ; CHECK: [[INNER]]: | |
| ; CHECK-NEXT: [[J:%.*]] = phi i32 [ [[J_NEXT:%.*]], %[[INNER]] ], [ 0, %[[OUTER]] ] | |
| ; CHECK-NEXT: [[J_NEXT]] = add i32 [[J]], 1 | |
| ; CHECK-NEXT: [[C_INNER:%.*]] = icmp uge i32 [[J_NEXT]], [[M]] | |
| ; CHECK-NEXT: br i1 [[C_INNER]], label %[[OUTER_LATCH]], label %[[INNER]] | |
| ; CHECK: [[OUTER_LATCH]]: | |
| ; CHECK-NEXT: [[I_NEXT]] = add i32 [[I]], 1 | |
| ; CHECK-NEXT: [[C_OUTER:%.*]] = icmp uge i32 [[I_NEXT]], [[N]] | |
| ; CHECK-NEXT: br i1 [[C_OUTER]], label %[[EXIT:.*]], label %[[OUTER]] | |
| ; CHECK: [[EXIT]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br label %outer | |
| outer: | |
| %i = phi i32 [ 0, %entry ], [ %i.next, %outer.latch ] | |
| br label %inner | |
| inner: | |
| %j = phi i32 [ 0, %outer ], [ %j.next, %inner ] | |
| %j.next = add i32 %j, 1 | |
| %c.inner = icmp ult i32 %j.next, %m | |
| br i1 %c.inner, label %inner, label %outer.latch, !llvm.loop !6 | |
| outer.latch: | |
| %i.next = add i32 %i, 1 | |
| %c.outer = icmp ult i32 %i.next, %n | |
| br i1 %c.outer, label %outer, label %exit, !llvm.loop !7 | |
| exit: | |
| ret void | |
| } | |
| ; The backedge targets a flow block in front of the header. | |
| define i32 @backedge_to_flow_block(i32 %s) { | |
| ; CHECK-LABEL: define i32 @backedge_to_flow_block( | |
| ; CHECK-SAME: i32 [[S:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*]]: | |
| ; CHECK-NEXT: [[C0:%.*]] = trunc i32 [[S]] to i1 | |
| ; CHECK-NEXT: [[C0_INV:%.*]] = xor i1 [[C0]], true | |
| ; CHECK-NEXT: br label %[[FLOW:.*]] | |
| ; CHECK: [[FLOW]]: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = phi i32 [ [[TMP4:%.*]], %[[FLOW1:.*]] ], [ poison, %[[ENTRY]] ] | |
| ; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP5:%.*]], %[[FLOW1]] ], [ 0, %[[ENTRY]] ] | |
| ; CHECK-NEXT: [[TMP2:%.*]] = phi i1 [ [[TMP7:%.*]], %[[FLOW1]] ], [ [[C0_INV]], %[[ENTRY]] ] | |
| ; CHECK-NEXT: [[TMP3:%.*]] = phi i1 [ true, %[[FLOW1]] ], [ [[C0]], %[[ENTRY]] ] | |
| ; CHECK-NEXT: br i1 [[TMP3]], label %[[HEADER:.*]], label %[[FLOW1]] | |
| ; CHECK: [[HEADER]]: | |
| ; CHECK-NEXT: [[I_NEXT:%.*]] = add i32 [[TMP1]], 1 | |
| ; CHECK-NEXT: [[C1:%.*]] = icmp ult i32 [[I_NEXT]], [[S]] | |
| ; CHECK-NEXT: br i1 [[C1]], label %[[LATCH:.*]], label %[[FLOW2:.*]] | |
| ; CHECK: [[FLOW1]]: | |
| ; CHECK-NEXT: [[TMP4]] = phi i32 [ [[I_NEXT]], %[[FLOW2]] ], [ [[TMP0]], %[[FLOW]] ] | |
| ; CHECK-NEXT: [[TMP5]] = phi i32 [ [[I_NEXT]], %[[FLOW2]] ], [ [[TMP1]], %[[FLOW]] ] | |
| ; CHECK-NEXT: [[TMP6:%.*]] = phi i1 [ [[TMP8:%.*]], %[[FLOW2]] ], [ true, %[[FLOW]] ] | |
| ; CHECK-NEXT: [[TMP7]] = phi i1 [ [[TMP9:%.*]], %[[FLOW2]] ], [ [[TMP2]], %[[FLOW]] ] | |
| ; CHECK-NEXT: br i1 [[TMP6]], label %[[FLOW3:.*]], label %[[FLOW]] | |
| ; CHECK: [[LATCH]]: | |
| ; CHECK-NEXT: [[C2:%.*]] = icmp uge i32 [[I_NEXT]], 3 | |
| ; CHECK-NEXT: br label %[[FLOW2]] | |
| ; CHECK: [[FLOW2]]: | |
| ; CHECK-NEXT: [[TMP8]] = phi i1 [ [[C2]], %[[LATCH]] ], [ true, %[[HEADER]] ] | |
| ; CHECK-NEXT: [[TMP9]] = phi i1 [ [[C2]], %[[LATCH]] ], [ [[TMP2]], %[[HEADER]] ] | |
| ; CHECK-NEXT: br label %[[FLOW1]] | |
| ; CHECK: [[FLOW3]]: | |
| ; CHECK-NEXT: br i1 [[TMP7]], label %[[OTHER:.*]], label %[[RET:.*]] | |
| ; CHECK: [[OTHER]]: | |
| ; CHECK-NEXT: br label %[[RET]] | |
| ; CHECK: [[RET]]: | |
| ; CHECK-NEXT: [[R:%.*]] = phi i32 [ [[TMP4]], %[[FLOW3]] ], [ 0, %[[OTHER]] ] | |
| ; CHECK-NEXT: ret i32 [[R]] | |
| ; | |
| entry: | |
| %c0 = trunc i32 %s to i1 | |
| br i1 %c0, label %header, label %other | |
| header: | |
| %i = phi i32 [ 0, %entry ], [ %i.next, %latch ] | |
| %i.next = add i32 %i, 1 | |
| %c1 = icmp ult i32 %i.next, %s | |
| br i1 %c1, label %latch, label %ret | |
| latch: | |
| %c2 = icmp ult i32 %i.next, 3 | |
| br i1 %c2, label %header, label %other, !llvm.loop !8 | |
| other: | |
| br label %ret | |
| ret: | |
| %r = phi i32 [ %i.next, %header ], [ 0, %other ] | |
| ret i32 %r | |
| } | |
| ; The latches are in two nested regions that both start at the header. | |
| define void @latches_in_nested_regions(i1 %c1, i1 %c2, i1 %c3, i1 %c4) { | |
| ; CHECK-LABEL: define void @latches_in_nested_regions( | |
| ; CHECK-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]], i1 [[C3:%.*]], i1 [[C4:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*:]] | |
| ; CHECK-NEXT: [[C4_INV:%.*]] = xor i1 [[C4]], true | |
| ; CHECK-NEXT: [[C2_INV:%.*]] = xor i1 [[C2]], true | |
| ; CHECK-NEXT: br label %[[HEADER:.*]] | |
| ; CHECK: [[HEADER]]: | |
| ; CHECK-NEXT: br i1 [[C1]], label %[[A:.*]], label %[[FLOW:.*]] | |
| ; CHECK: [[A]]: | |
| ; CHECK-NEXT: br label %[[FLOW]] | |
| ; CHECK: [[FLOW]]: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = phi i1 [ [[C2_INV]], %[[A]] ], [ true, %[[HEADER]] ] | |
| ; CHECK-NEXT: br i1 [[TMP0]], label %[[MID:.*]], label %[[HEADER]] | |
| ; CHECK: [[MID]]: | |
| ; CHECK-NEXT: br i1 [[C3]], label %[[B:.*]], label %[[FLOW1:.*]] | |
| ; CHECK: [[B]]: | |
| ; CHECK-NEXT: br label %[[FLOW1]] | |
| ; CHECK: [[FLOW1]]: | |
| ; CHECK-NEXT: [[TMP1:%.*]] = phi i1 [ [[C4_INV]], %[[B]] ], [ true, %[[MID]] ] | |
| ; CHECK-NEXT: br i1 [[TMP1]], label %[[EXIT:.*]], label %[[HEADER]] | |
| ; CHECK: [[EXIT]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br label %header | |
| header: | |
| br i1 %c1, label %a, label %mid | |
| a: | |
| br i1 %c2, label %header, label %mid, !llvm.loop !9 | |
| mid: | |
| br i1 %c3, label %b, label %exit | |
| b: | |
| br i1 %c4, label %header, label %exit, !llvm.loop !9 | |
| exit: | |
| ret void | |
| } | |
| ; Nothing is kept in a function with irreducible control flow. | |
| define void @irreducible(i1 %c0, i1 %c1, i1 %c2) { | |
| ; CHECK-LABEL: define void @irreducible( | |
| ; CHECK-SAME: i1 [[C0:%.*]], i1 [[C1:%.*]], i1 [[C2:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*]]: | |
| ; CHECK-NEXT: [[C1_INV:%.*]] = xor i1 [[C1]], true | |
| ; CHECK-NEXT: br label %[[FLOW:.*]] | |
| ; CHECK: [[FLOW]]: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = phi i1 [ false, %[[FLOW2:.*]] ], [ true, %[[ENTRY]] ] | |
| ; CHECK-NEXT: [[TMP1:%.*]] = phi i1 [ true, %[[FLOW2]] ], [ [[C0]], %[[ENTRY]] ] | |
| ; CHECK-NEXT: br i1 [[TMP1]], label %[[HEADER:.*]], label %[[FLOW1:.*]] | |
| ; CHECK: [[HEADER]]: | |
| ; CHECK-NEXT: br i1 [[C1_INV]], label %[[NEXT:.*]], label %[[HEADER]] | |
| ; CHECK: [[FLOW1]]: | |
| ; CHECK-NEXT: [[TMP2:%.*]] = phi i1 [ [[C2]], %[[NEXT]] ], [ [[TMP0]], %[[FLOW]] ] | |
| ; CHECK-NEXT: br i1 [[TMP2]], label %[[OTHER:.*]], label %[[FLOW2]] | |
| ; CHECK: [[NEXT]]: | |
| ; CHECK-NEXT: br label %[[FLOW1]] | |
| ; CHECK: [[OTHER]]: | |
| ; CHECK-NEXT: br label %[[FLOW2]] | |
| ; CHECK: [[FLOW2]]: | |
| ; CHECK-NEXT: [[TMP3:%.*]] = phi i1 [ false, %[[OTHER]] ], [ true, %[[FLOW1]] ] | |
| ; CHECK-NEXT: br i1 [[TMP3]], label %[[EXIT:.*]], label %[[FLOW]] | |
| ; CHECK: [[EXIT]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br i1 %c0, label %header, label %other | |
| header: | |
| br i1 %c1, label %header, label %next, !llvm.loop !10 | |
| next: | |
| br i1 %c2, label %other, label %exit | |
| other: | |
| br label %header | |
| exit: | |
| ret void | |
| } | |
| ; The header is in the top level region and the latches are in a nested one. | |
| define void @latches_below_top_level_header(i1 %c1, i1 %c2, i1 %c3) { | |
| ; CHECK-LABEL: define void @latches_below_top_level_header( | |
| ; CHECK-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]], i1 [[C3:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*:]] | |
| ; CHECK-NEXT: [[C3_INV:%.*]] = xor i1 [[C3]], true | |
| ; CHECK-NEXT: br label %[[HEADER:.*]] | |
| ; CHECK: [[FLOW1:.*]]: | |
| ; CHECK-NEXT: br label %[[HEADER]] | |
| ; CHECK: [[HEADER]]: | |
| ; CHECK-NEXT: br i1 [[C1]], label %[[BODY:.*]], label %[[EXIT1:.*]] | |
| ; CHECK: [[BODY]]: | |
| ; CHECK-NEXT: br i1 [[C2]], label %[[SPLIT:.*]], label %[[EXIT2:.*]] | |
| ; CHECK: [[SPLIT]]: | |
| ; CHECK-NEXT: br i1 [[C3_INV]], label %[[B:.*]], label %[[FLOW:.*]] | |
| ; CHECK: [[FLOW]]: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = phi i1 [ false, %[[B]] ], [ true, %[[SPLIT]] ] | |
| ; CHECK-NEXT: br i1 [[TMP0]], label %[[A:.*]], label %[[FLOW1]] | |
| ; CHECK: [[A]]: | |
| ; CHECK-NEXT: br label %[[FLOW1]] | |
| ; CHECK: [[B]]: | |
| ; CHECK-NEXT: br label %[[FLOW]] | |
| ; CHECK: [[EXIT1]]: | |
| ; CHECK-NEXT: ret void | |
| ; CHECK: [[EXIT2]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br label %header | |
| header: | |
| br i1 %c1, label %body, label %exit1 | |
| body: | |
| br i1 %c2, label %split, label %exit2 | |
| split: | |
| br i1 %c3, label %a, label %b | |
| a: | |
| br label %header, !llvm.loop !11 | |
| b: | |
| br label %header, !llvm.loop !11 | |
| exit1: | |
| ret void | |
| exit2: | |
| ret void | |
| } | |
| ; The inner loop is merged into the outer one. | |
| define void @inner_loop_merged_into_outer(i1 %c0, i1 %c1, i1 %c2) { | |
| ; CHECK-LABEL: define void @inner_loop_merged_into_outer( | |
| ; CHECK-SAME: i1 [[C0:%.*]], i1 [[C1:%.*]], i1 [[C2:%.*]]) { | |
| ; CHECK-NEXT: [[ENTRY:.*:]] | |
| ; CHECK-NEXT: [[C2_INV:%.*]] = xor i1 [[C2]], true | |
| ; CHECK-NEXT: br label %[[OUTER:.*]] | |
| ; CHECK: [[OUTER]]: | |
| ; CHECK-NEXT: br i1 [[C0]], label %[[INNER:.*]], label %[[FLOW:.*]] | |
| ; CHECK: [[INNER]]: | |
| ; CHECK-NEXT: br i1 [[C1]], label %[[INNER_LATCH:.*]], label %[[FLOW1:.*]] | |
| ; CHECK: [[FLOW]]: | |
| ; CHECK-NEXT: [[TMP0:%.*]] = phi i1 [ [[C1]], %[[FLOW1]] ], [ true, %[[OUTER]] ] | |
| ; CHECK-NEXT: [[TMP1:%.*]] = phi i1 [ [[TMP2:%.*]], %[[FLOW1]] ], [ true, %[[OUTER]] ] | |
| ; CHECK-NEXT: br i1 [[TMP1]], label %[[FLOW2:.*]], label %[[OUTER]] | |
| ; CHECK: [[INNER_LATCH]]: | |
| ; CHECK-NEXT: br label %[[FLOW1]] | |
| ; CHECK: [[FLOW1]]: | |
| ; CHECK-NEXT: [[TMP2]] = phi i1 [ [[C2_INV]], %[[INNER_LATCH]] ], [ true, %[[INNER]] ] | |
| ; CHECK-NEXT: br label %[[FLOW]] | |
| ; CHECK: [[FLOW2]]: | |
| ; CHECK-NEXT: br i1 [[TMP0]], label %[[EXIT:.*]], label %[[OUTER]] | |
| ; CHECK: [[EXIT]]: | |
| ; CHECK-NEXT: ret void | |
| ; | |
| entry: | |
| br label %outer | |
| outer: | |
| br i1 %c0, label %inner, label %exit | |
| inner: | |
| br i1 %c1, label %inner.latch, label %outer, !llvm.loop !12 | |
| inner.latch: | |
| br i1 %c2, label %inner, label %exit, !llvm.loop !13 | |
| exit: | |
| ret void | |
| } | |
| !0 = distinct !{!0, !1} | |
| !1 = !{!"llvm.loop.align", i32 64} | |
| !2 = distinct !{!2, !1} | |
| !3 = distinct !{!3, !1} | |
| !4 = distinct !{!4, !1} | |
| !5 = distinct !{!5, !1} | |
| !6 = distinct !{!6, !1} | |
| !7 = distinct !{!7, !1} | |
| !8 = distinct !{!8, !1} | |
| !9 = distinct !{!9, !1} | |
| !10 = distinct !{!10, !1} | |
| !11 = distinct !{!11, !1} | |
| !12 = distinct !{!12, !1} | |
| !13 = distinct !{!13, !14} | |
| !14 = !{!"llvm.loop.align", i32 32} |