address comments

Author: zhaoqi5

llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp

@@ -2612,93 +2612,87 @@ LoongArchTargetLowering::lowerEXTRACT_VECTOR_ELT(SDValue Op,
   SDValue Vec = Op->getOperand(0);
   EVT VecTy = Vec->getValueType(0);
   SDValue Idx = Op->getOperand(1);
-  unsigned NumElts = VecTy.getVectorNumElements();
   SDLoc DL(Op);
   MVT GRLenVT = Subtarget.getGRLenVT();
 
   assert(VecTy.is256BitVector() && "Unexpected EXTRACT_VECTOR_ELT vector type");
 
-  if (isa<ConstantSDNode>(Idx) && Idx->getAsZExtVal() < NumElts)
+  if (isa<ConstantSDNode>(Idx))
     return Op;
 
-  if (!isa<ConstantSDNode>(Idx)) {
-    switch (VecTy.getSimpleVT().SimpleTy) {
-    default:
-      llvm_unreachable("Unexpected type");
-    case MVT::v32i8:
-    case MVT::v16i16: {
-      // Consider the source vector as v8i32 type.
-      SDValue NewVec = DAG.getBitcast(MVT::v8i32, Vec);
-
-      // Compute the adjusted index and use it to broadcast the vector.
-      // The original desired i8/i16 element is now replicated in each
-      // i32 lane of the splatted vector.
-      SDValue NewIdx = DAG.getNode(
-          LoongArchISD::BSTRPICK, DL, GRLenVT, Idx,
-          DAG.getConstant(31, DL, GRLenVT),
-          DAG.getConstant(((VecTy == MVT::v32i8) ? 2 : 1), DL, GRLenVT));
-      SDValue SplatIdx = DAG.getSplatBuildVector(MVT::v8i32, DL, NewIdx);
-      SDValue SplatValue =
-          DAG.getNode(LoongArchISD::XVPERM, DL, MVT::v8i32, NewVec, SplatIdx);
-      SDValue SplatVec = DAG.getBitcast(VecTy, SplatValue);
-
-      // Compute the local index of the original i8/i16 element within the
-      // i32 element and then use it to broadcast the vector. Each elements
-      // of the vector will be the desired element.
-      SDValue LocalIdx = DAG.getNode(
-          ISD::AND, DL, GRLenVT, Idx,
-          DAG.getConstant(((VecTy == MVT::v32i8) ? 3 : 1), DL, GRLenVT));
-      SDValue ExtractVec =
-          DAG.getNode(LoongArchISD::VREPLVE, DL, VecTy, SplatVec, LocalIdx);
-
-      return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, ExtractVec,
-                         DAG.getConstant(0, DL, GRLenVT));
-    }
-    case MVT::v8i32:
-    case MVT::v8f32: {
-      SDValue SplatIdx = DAG.getSplatBuildVector(MVT::v8i32, DL, Idx);
-      SDValue SplatValue =
-          DAG.getNode(LoongArchISD::XVPERM, DL, VecTy, Vec, SplatIdx);
-
-      return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, SplatValue,
-                         DAG.getConstant(0, DL, GRLenVT));
-    }
-    case MVT::v4i64:
-    case MVT::v4f64: {
-      // Consider the source vector as v8i32 type.
-      SDValue NewVec = DAG.getBitcast(MVT::v8i32, Vec);
-
-      // Split the original element index into low and high parts:
-      // Lo = Idx * 2, Hi = Idx * 2 + 1.
-      SDValue SplatIdx = DAG.getSplatBuildVector(MVT::v8i32, DL, Idx);
-      SDValue SplatIdxLo =
-          DAG.getNode(LoongArchISD::VSLLI, DL, MVT::v8i32, SplatIdx,
-                      DAG.getConstant(1, DL, GRLenVT));
-      SDValue SplatIdxHi =
-          DAG.getNode(ISD::ADD, DL, MVT::v8i32, SplatIdxLo,
-                      DAG.getSplatBuildVector(MVT::v8i32, DL,
-                                              DAG.getConstant(1, DL, GRLenVT)));
-
-      // Use the broadcasted index to broadcast the low and high parts of the
-      // vector separately.
-      SDValue SplatVecLo =
-          DAG.getNode(LoongArchISD::XVPERM, DL, MVT::v8i32, NewVec, SplatIdxLo);
-      SDValue SplatVecHi =
-          DAG.getNode(LoongArchISD::XVPERM, DL, MVT::v8i32, NewVec, SplatIdxHi);
-
-      // Combine the low and high i32 parts to reconstruct the original i64/f64
-      // element.
-      SDValue SplatValue = DAG.getNode(LoongArchISD::VILVL, DL, MVT::v8i32,
-                                       SplatVecHi, SplatVecLo);
-      SDValue ExtractVec = DAG.getBitcast(VecTy, SplatValue);
-
-      return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, ExtractVec,
-                         DAG.getConstant(0, DL, GRLenVT));
-    }
-    }
+  switch (VecTy.getSimpleVT().SimpleTy) {
+  default:
+    llvm_unreachable("Unexpected type");
+  case MVT::v32i8:
+  case MVT::v16i16: {
+    // Consider the source vector as v8i32 type.
+    SDValue NewVec = DAG.getBitcast(MVT::v8i32, Vec);
+
+    // Compute the adjusted index and use it to broadcast the vector.
+    // The original desired i8/i16 element is now replicated in each
+    // i32 lane of the splatted vector.
+    SDValue NewIdx = DAG.getNode(
+        LoongArchISD::BSTRPICK, DL, GRLenVT, Idx,
+        DAG.getConstant(31, DL, GRLenVT),
+        DAG.getConstant(((VecTy == MVT::v32i8) ? 2 : 1), DL, GRLenVT));
+    SDValue SplatIdx = DAG.getSplatBuildVector(MVT::v8i32, DL, NewIdx);
+    SDValue SplatValue =
+        DAG.getNode(LoongArchISD::XVPERM, DL, MVT::v8i32, NewVec, SplatIdx);
+    SDValue SplatVec = DAG.getBitcast(VecTy, SplatValue);
+
+    // Compute the local index of the original i8/i16 element within the
+    // i32 element and then use it to broadcast the vector. Each elements
+    // of the vector will be the desired element.
+    SDValue LocalIdx = DAG.getNode(
+        ISD::AND, DL, GRLenVT, Idx,
+        DAG.getConstant(((VecTy == MVT::v32i8) ? 3 : 1), DL, GRLenVT));
+    SDValue ExtractVec =
+        DAG.getNode(LoongArchISD::VREPLVE, DL, VecTy, SplatVec, LocalIdx);
+
+    return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, ExtractVec,
+                       DAG.getConstant(0, DL, GRLenVT));
+  }
+  case MVT::v8i32:
+  case MVT::v8f32: {
+    SDValue SplatIdx = DAG.getSplatBuildVector(MVT::v8i32, DL, Idx);
+    SDValue SplatValue =
+        DAG.getNode(LoongArchISD::XVPERM, DL, VecTy, Vec, SplatIdx);
+
+    return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, SplatValue,
+                       DAG.getConstant(0, DL, GRLenVT));
+  }
+  case MVT::v4i64:
+  case MVT::v4f64: {
+    // Consider the source vector as v8i32 type.
+    SDValue NewVec = DAG.getBitcast(MVT::v8i32, Vec);
+
+    // Split the original element index into low and high parts:
+    // Lo = Idx * 2, Hi = Idx * 2 + 1.
+    SDValue SplatIdx = DAG.getSplatBuildVector(MVT::v8i32, DL, Idx);
+    SDValue SplatIdxLo = DAG.getNode(LoongArchISD::VSLLI, DL, MVT::v8i32,
+                                     SplatIdx, DAG.getConstant(1, DL, GRLenVT));
+    SDValue SplatIdxHi =
+        DAG.getNode(ISD::ADD, DL, MVT::v8i32, SplatIdxLo,
+                    DAG.getSplatBuildVector(MVT::v8i32, DL,
+                                            DAG.getConstant(1, DL, GRLenVT)));
+
+    // Use the broadcasted index to broadcast the low and high parts of the
+    // vector separately.
+    SDValue SplatVecLo =
+        DAG.getNode(LoongArchISD::XVPERM, DL, MVT::v8i32, NewVec, SplatIdxLo);
+    SDValue SplatVecHi =
+        DAG.getNode(LoongArchISD::XVPERM, DL, MVT::v8i32, NewVec, SplatIdxHi);
+
+    // Combine the low and high i32 parts to reconstruct the original i64/f64
+    // element.
+    SDValue SplatValue = DAG.getNode(LoongArchISD::VILVL, DL, MVT::v8i32,
+                                     SplatVecHi, SplatVecLo);
+    SDValue ExtractVec = DAG.getBitcast(VecTy, SplatValue);
+
+    return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, ExtractVec,
+                       DAG.getConstant(0, DL, GRLenVT));
+  }
   }
-
-  return SDValue();
 }
 
 SDValue