[ISEL] Legalize arithmetic.fence.f128 for 32-bits target

[xiangzhangllvm]

Summary

We meet an ERROR about arithmetic fence in building some libs in m32 target.
The reason is Legalize not consider "transfer/convert" illegal type fp128 (in m32) for arithmetic.fence.
Now fix it.

clang -cc1 -triple i386-pc-linux-gnu -mreassociate t.c -emit-llvm -o t.ll; llc t.l
clang -cc1 -triple i386-pc-linux-gnu -mreassociate -S -o t.s -x c t.c

typedef __float128 TYPE;

TYPE foo(TYPE *qr) {
TYPE re =__arithmetic_fence(*qr);
return re;
}

[xiangzhangllvm]

Update clang-format (some places keep same style with the existed code)

[pengfei]

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

210

Can we do the same think as SoftenFloatRes_FREEZE?

[xiangzhangllvm]

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

210

Actually they are same, SoftenFloatRes_FREEZE looks more standard, let me change it soon, thanks a lot!

[xiangzhangllvm]

Refine, let it follow with SoftenFloatRes_FREEZE style.

[pengfei]

LGTM.

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

212–214

Nit: We can return it directly.

[xiangzhangllvm]

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

212–214

Yes, seems no affect, let it be (at least easy for debug). : )

[craig.topper]

LGTM

[xiangzhangllvm]

Thanks again!

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

void DAGTypeLegalizer::SoftenFloatResult(SDNode *N, unsigned ResNo) {
   switch (N->getOpcode()) {
   default:
 #ifndef NDEBUG
     dbgs() << "SoftenFloatResult #" << ResNo << ": ";
     N->dump(&DAG); dbgs() << "\n";
 #endif
     llvm_unreachable("Do not know how to soften the result of this operator!");
 
+    case ISD::ARITH_FENCE: R = SoftenFloatRes_ARITH_FENCE(N); break;
     case ISD::MERGE_VALUES:R = SoftenFloatRes_MERGE_VALUES(N, ResNo); break;
     case ISD::BITCAST:     R = SoftenFloatRes_BITCAST(N); break;
     case ISD::BUILD_PAIR:  R = SoftenFloatRes_BUILD_PAIR(N); break;
     case ISD::ConstantFP:  R = SoftenFloatRes_ConstantFP(N); break;
     case ISD::EXTRACT_VECTOR_ELT:
       R = SoftenFloatRes_EXTRACT_VECTOR_ELT(N, ResNo); break;
     case ISD::FABS:        R = SoftenFloatRes_FABS(N); break;
     case ISD::STRICT_FMINNUM:

 }
 
 SDValue DAGTypeLegalizer::SoftenFloatRes_FREEZE(SDNode *N) {
   EVT Ty = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
   return DAG.getNode(ISD::FREEZE, SDLoc(N), Ty,
                      GetSoftenedFloat(N->getOperand(0)));
 }
 
+SDValue DAGTypeLegalizer::SoftenFloatRes_ARITH_FENCE(SDNode *N) {
+  EVT Ty = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
+  SDValue NewFence = DAG.getNode(ISD::ARITH_FENCE, SDLoc(N), Ty,
+                                 GetSoftenedFloat(N->getOperand(0)));
+  return NewFence;
+}
+
 SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N,
                                                       unsigned ResNo) {
   SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
   return BitConvertToInteger(Op);
 }
 
 SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {
   // Convert the inputs to integers, and build a new pair out of them.

llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

void DAGTypeLegalizer::ExpandIntegerResult(SDNode *N, unsigned ResNo) {
   default:
 #ifndef NDEBUG
     dbgs() << "ExpandIntegerResult #" << ResNo << ": ";
     N->dump(&DAG); dbgs() << "\n";
 #endif
     report_fatal_error("Do not know how to expand the result of this "
                        "operator!");
 
+  case ISD::ARITH_FENCE:  SplitRes_ARITH_FENCE(N, Lo, Hi); break;
   case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
   case ISD::SELECT:       SplitRes_SELECT(N, Lo, Hi); break;
   case ISD::SELECT_CC:    SplitRes_SELECT_CC(N, Lo, Hi); break;
   case ISD::UNDEF:        SplitRes_UNDEF(N, Lo, Hi); break;
   case ISD::FREEZE:       SplitRes_FREEZE(N, Lo, Hi); break;
 
   case ISD::BITCAST:            ExpandRes_BITCAST(N, Lo, Hi); break;
   case ISD::BUILD_PAIR:         ExpandRes_BUILD_PAIR(N, Lo, Hi); break;

llvm/lib/CodeGen/SelectionDAG/LegalizeTypes.h

private:
   }
   void SetSoftenedFloat(SDValue Op, SDValue Result);
 
   // Convert Float Results to Integer.
   void SoftenFloatResult(SDNode *N, unsigned ResNo);
   SDValue SoftenFloatRes_Unary(SDNode *N, RTLIB::Libcall LC);
   SDValue SoftenFloatRes_Binary(SDNode *N, RTLIB::Libcall LC);
   SDValue SoftenFloatRes_MERGE_VALUES(SDNode *N, unsigned ResNo);
+  SDValue SoftenFloatRes_ARITH_FENCE(SDNode *N);
   SDValue SoftenFloatRes_BITCAST(SDNode *N);
   SDValue SoftenFloatRes_BUILD_PAIR(SDNode *N);
   SDValue SoftenFloatRes_ConstantFP(SDNode *N);
   SDValue SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N, unsigned ResNo);
   SDValue SoftenFloatRes_FABS(SDNode *N);
   SDValue SoftenFloatRes_FMINNUM(SDNode *N);
   SDValue SoftenFloatRes_FMAXNUM(SDNode *N);
   SDValue SoftenFloatRes_FADD(SDNode *N);
private:
 
   /// Use ISD::EXTRACT_ELEMENT nodes to extract the low and high parts of the
   /// given value.
   void GetPairElements(SDValue Pair, SDValue &Lo, SDValue &Hi);
 
   // Generic Result Splitting.
   void SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
                              SDValue &Lo, SDValue &Hi);
+  void SplitRes_ARITH_FENCE (SDNode *N, SDValue &Lo, SDValue &Hi);
   void SplitRes_SELECT      (SDNode *N, SDValue &Lo, SDValue &Hi);
   void SplitRes_SELECT_CC   (SDNode *N, SDValue &Lo, SDValue &Hi);
   void SplitRes_UNDEF       (SDNode *N, SDValue &Lo, SDValue &Hi);
   void SplitRes_FREEZE      (SDNode *N, SDValue &Lo, SDValue &Hi);
 
   //===--------------------------------------------------------------------===//
   // Generic Expansion: LegalizeTypesGeneric.cpp
   //===--------------------------------------------------------------------===//

llvm/lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp

 void DAGTypeLegalizer::SplitRes_FREEZE(SDNode *N, SDValue &Lo, SDValue &Hi) {
   SDValue L, H;
   SDLoc dl(N);
   GetSplitOp(N->getOperand(0), L, H);
 
   Lo = DAG.getNode(ISD::FREEZE, dl, L.getValueType(), L);
   Hi = DAG.getNode(ISD::FREEZE, dl, H.getValueType(), H);
 }
+
+void DAGTypeLegalizer::SplitRes_ARITH_FENCE(SDNode *N, SDValue &Lo,
+                                            SDValue &Hi) {
+  SDValue L, H;
+  SDLoc DL(N);
+  GetSplitOp(N->getOperand(0), L, H);
+
+  Lo = DAG.getNode(ISD::ARITH_FENCE, DL, L.getValueType(), L);
+  Hi = DAG.getNode(ISD::ARITH_FENCE, DL, H.getValueType(), H);
+}

llvm/test/CodeGen/X86/arithmetic_fence.ll

 ; X64-NEXT:    retq
   %1 = fadd fast <2 x float> %a, %a
   %t = call <2 x float> @llvm.arithmetic.fence.v2f32(<2 x float> %1)
   %2 = fadd fast <2 x float> %a, %a
   %3 = fadd fast <2 x float> %t, %2
   ret <2 x float> %3
 }
 
+; This @f7 IR test can be generated from flowing c test:
+;
+; typedef __float128 TYPE;
+; TYPE foo(TYPE *qr) {
+;   TYPE re =__arithmetic_fence(*qr);
+;   return re;
+;}
+;
+; with flowing build command:
+; clang -cc1  -triple i386-pc-linux-gnu -mreassociate  t.c -emit-llvm -O2
+
+define dso_local fp128 @foo(fp128* nocapture readonly %qr) local_unnamed_addr{
+; X86-LABEL: foo:
+; X86:       # %bb.0: # %entry
+; X86-NEXT:    pushl %edi
+; X86-NEXT:    .cfi_def_cfa_offset 8
+; X86-NEXT:    pushl %esi
+; X86-NEXT:    .cfi_def_cfa_offset 12
+; X86-NEXT:    .cfi_offset %esi, -12
+; X86-NEXT:    .cfi_offset %edi, -8
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT:    movl 12(%ecx), %edx
+; X86-NEXT:    movl 8(%ecx), %esi
+; X86-NEXT:    movl (%ecx), %edi
+; X86-NEXT:    movl 4(%ecx), %ecx
+; X86-NEXT:    #ARITH_FENCE
+; X86-NEXT:    #ARITH_FENCE
+; X86-NEXT:    #ARITH_FENCE
+; X86-NEXT:    #ARITH_FENCE
+; X86-NEXT:    movl %edx, 12(%eax)
+; X86-NEXT:    movl %esi, 8(%eax)
+; X86-NEXT:    movl %ecx, 4(%eax)
+; X86-NEXT:    movl %edi, (%eax)
+; X86-NEXT:    popl %esi
+; X86-NEXT:    .cfi_def_cfa_offset 8
+; X86-NEXT:    popl %edi
+; X86-NEXT:    .cfi_def_cfa_offset 4
+; X86-NEXT:    retl $4
+;
+; X64-LABEL: foo:
+; X64:       # %bb.0: # %entry
+; X64-NEXT:    vmovaps (%rdi), %xmm0
+; X64-NEXT:    #ARITH_FENCE
+; X64-NEXT:    retq
+entry:
+  %0 = load fp128, fp128* %qr, align 16
+  %1 = tail call reassoc fp128 @llvm.arithmetic.fence.f128(fp128 %0)
+  ret fp128 %1
+}
+
+declare fp128 @llvm.arithmetic.fence.f128(fp128)
 declare float @llvm.arithmetic.fence.f32(float)
 declare double @llvm.arithmetic.fence.f64(double)
 declare <2 x float> @llvm.arithmetic.fence.v2f32(<2 x float>)