This is an archive of the discontinued LLVM Phabricator instance.

Differential D139321

InstCombine: Fix metadata arguments blocking freeze combining
ClosedPublic

Authored by arsenm on Dec 5 2022, 5:41 AM.

Details

Reviewers
nlopes
aqjune
jdoerfert
sstefan1
nikic
Summary

These are used for special arguments to intrinsics and don't make any
sense to consider for poisonness. Fixes not pushing freeze through
llvm.fptrunc.round.




92106641ae297c24877085e0357e8095aa7b43c9 made

isGuaranteedNotToBeUndefOrPoison return false for metadata arguments,

which doesn't entirely make sense. An alternate patch could switch

that to true, and try to filter out adding some pointless noundefs on

metadata arguments (I tried that, attributor breaks one case with a

llvm.dbg.value in it).
Diff Detail
Event Timeline
arsenm created this revision.Dec 5 2022, 5:41 AM
Herald added a project: Restricted Project.  ·  View Herald TranscriptDec 5 2022, 5:41 AM
Herald added a subscriber: hiraditya.  ·  View Herald Transcript
arsenm requested review of this revision.Dec 5 2022, 5:41 AM
Herald added a reviewer: sstefan1.  ·  View Herald TranscriptDec 5 2022, 5:41 AM
Herald added a project: Restricted Project.  ·  View Herald Transcript
Herald added a subscriber: wdng.  ·  View Herald Transcript
arsenm added a parent revision: D139314: ValueTracking: Teach canCreateUndefOrPoison about FP ops.Dec 5 2022, 5:42 AM
Harbormaster completed remote builds in B201094: Diff 480079.Dec 5 2022, 5:42 AM
nikic accepted this revision.Dec 5 2022, 6:01 AM
nikic added a subscriber: nikic.
LG
This revision is now accepted and ready to land.Dec 5 2022, 6:01 AM
arsenm closed this revision.Dec 12 2022, 8:23 PM
1bf261c89b96df33ed14c6695f5f8590578e825d
Revision Contents
PathSize
llvm/
lib/
Transforms/
InstCombine/
3 lines
test/
Transforms/
InstCombine/
6 lines
Diff 480079
llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
Show First 20 Lines • Show All 3,797 Lines • ▼ Show 20 LinesInstCombinerImpl::pushFreezeToPreventPoisonFromPropagating(FreezeInst &OrigFI) {

  if (canCreateUndefOrPoison(cast<Operator>(OrigOp), /*ConsiderFlags*/ false))
  if (canCreateUndefOrPoison(cast<Operator>(OrigOp), /*ConsiderFlags*/ false))

    return nullptr;
    return nullptr;




  // If operand is guaranteed not to be poison, there is no need to add freeze
  // If operand is guaranteed not to be poison, there is no need to add freeze

  // to the operand. So we first find the operand that is not guaranteed to be
  // to the operand. So we first find the operand that is not guaranteed to be

  // poison.
  // poison.

  Use *MaybePoisonOperand = nullptr;
  Use *MaybePoisonOperand = nullptr;

  for (Use &U : OrigOpInst->operands()) {
  for (Use &U : OrigOpInst->operands()) {

    if (isGuaranteedNotToBeUndefOrPoison(U.get()))
    if (isa<MetadataAsValue>(U.get()) ||

        isGuaranteedNotToBeUndefOrPoison(U.get()))

      continue;
      continue;

    if (!MaybePoisonOperand)
    if (!MaybePoisonOperand)

      MaybePoisonOperand = &U;
      MaybePoisonOperand = &U;

    else
    else

      return nullptr;
      return nullptr;

  }
  }




  OrigOpInst->dropPoisonGeneratingFlags();
  OrigOpInst->dropPoisonGeneratingFlags();

▲ Show 20 Lines • Show All 919 Lines • Show Last 20 Lines
llvm/test/Transforms/InstCombine/freeze-fp-ops.ll
Show First 20 Lines • Show All 502 Lines • ▼ Show 20 Lines
;
;

  %op = call i1 @llvm.is.fpclass.f32(float %arg0, i32 27)
  %op = call i1 @llvm.is.fpclass.f32(float %arg0, i32 27)

  %freeze = freeze i1 %op
  %freeze = freeze i1 %op

  ret i1 %freeze
  ret i1 %freeze

}
}




define float @freeze_fptrunc_round(double %arg0) {
define float @freeze_fptrunc_round(double %arg0) {

; CHECK-LABEL: @freeze_fptrunc_round(
; CHECK-LABEL: @freeze_fptrunc_round(

; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[ARG0:%.*]], metadata !"round.downward")
; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze double [[ARG0:%.*]]

; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[OP]]
; CHECK-NEXT:    [[OP:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[ARG0_FR]], metadata !"round.downward")

; CHECK-NEXT:    ret float [[FREEZE]]
; CHECK-NEXT:    ret float [[OP]]

;
;

  %op = call float @llvm.fptrunc.round.f32.f64(double %arg0, metadata !"round.downward")
  %op = call float @llvm.fptrunc.round.f32.f64(double %arg0, metadata !"round.downward")

  %freeze = freeze float %op
  %freeze = freeze float %op

  ret float %freeze
  ret float %freeze

}
}




declare float @llvm.fma.f32(float, float, float)
declare float @llvm.fma.f32(float, float, float)

declare float @llvm.fmuladd.f32(float, float, float)
declare float @llvm.fmuladd.f32(float, float, float)

Show All 31 Lines