if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val))
if (EV->getAggregateOperand()->getType() == Agg->getType() &&
EV->getIndices() == Idxs) {
- // insertvalue undef, (extractvalue y, n), n -> y
- if (Q.isUndefValue(Agg))
+ // insertvalue poison, (extractvalue y, n), n -> y
+ // insertvalue undef, (extractvalue y, n), n -> y if y cannot be poison
+ if (isa<PoisonValue>(Agg) ||
+ (Q.isUndefValue(Agg) &&
+ isGuaranteedNotToBePoison(EV->getAggregateOperand())))
return EV->getAggregateOperand();
// insertvalue y, (extractvalue y, n), n -> y
define { ptr } @callee(ptr %x) {
; CHECK-LABEL: @callee(
-; CHECK-NEXT: [[RES:%.*]] = insertvalue { ptr } undef, ptr [[X:%.*]], 0
+; CHECK-NEXT: [[RES:%.*]] = insertvalue { ptr } poison, ptr [[X:%.*]], 0
; CHECK-NEXT: ret { ptr } [[RES]]
;
- %res = insertvalue { ptr } undef, ptr %x, 0
+ %res = insertvalue { ptr } poison, ptr %x, 0
ret { ptr } %res
}
; @opaque_callee() should not receive noalias metadata here.
define void @caller() {
; CHECK-LABEL: @caller(
-; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata !0)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META0:![0-9]+]])
; CHECK-NEXT: [[S:%.*]] = call { ptr } @opaque_callee()
; CHECK-NEXT: [[X:%.*]] = extractvalue { ptr } [[S]], 0
; CHECK-NEXT: ret void
; else branch, not as the load in the if branch.
define { ptr } @self_caller(i1 %c, ptr %a) {
; CHECK-LABEL: @self_caller(
-; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata !0)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META0]])
; CHECK-NEXT: br i1 [[C:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
; CHECK: if:
; CHECK-NEXT: [[S:%.*]] = call { ptr } @opaque_callee(), !noalias !0
; CHECK-NEXT: [[X:%.*]] = extractvalue { ptr } [[S]], 0
-; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata !3)
+; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META3:![0-9]+]])
; CHECK-NEXT: [[TMP1:%.*]] = load volatile i64, ptr [[X]], align 4, !alias.scope !3
; CHECK-NEXT: ret { ptr } [[S]]
; CHECK: else:
-; CHECK-NEXT: [[R2:%.*]] = insertvalue { ptr } undef, ptr [[A:%.*]], 0
+; CHECK-NEXT: [[R2:%.*]] = insertvalue { ptr } poison, ptr [[A:%.*]], 0
; CHECK-NEXT: [[TMP2:%.*]] = load volatile i64, ptr [[A]], align 4, !alias.scope !0
; CHECK-NEXT: ret { ptr } [[R2]]
;
ret { ptr } %r
else:
- %r2 = insertvalue { ptr } undef, ptr %a, 0
+ %r2 = insertvalue { ptr } poison, ptr %a, 0
load volatile i64, ptr %a, !alias.scope !0
ret { ptr } %r2
}
%ex = landingpad { ptr, i32 } cleanup
%exc_ptr = extractvalue { ptr, i32 } %ex, 0
%filter = extractvalue { ptr, i32 } %ex, 1
- %exc_ptr2 = insertvalue { ptr, i32 } undef, ptr %exc_ptr, 0
+ %exc_ptr2 = insertvalue { ptr, i32 } poison, ptr %exc_ptr, 0
%filter2 = insertvalue { ptr, i32 } %exc_ptr2, i32 %filter, 1
resume { ptr, i32 } %filter2
}
define {i32, i32} @insert_into_undef({i32, i32} %x) {
; CHECK-LABEL: @insert_into_undef(
-; CHECK-NEXT: ret { i32, i32 } [[X:%.*]]
+; CHECK-NEXT: [[ELEM:%.*]] = extractvalue { i32, i32 } [[X:%.*]], 0
+; CHECK-NEXT: [[V:%.*]] = insertvalue { i32, i32 } undef, i32 [[ELEM]], 0
+; CHECK-NEXT: ret { i32, i32 } [[V]]
;
%elem = extractvalue {i32, i32} %x, 0
%v = insertvalue {i32, i32} undef, i32 %elem, 0