[sycl-post-link] Using early exit to make code more readable

Also some local variables were inlined into function calls.

Signed-off-by: Pavel Samolysov <[email protected]>
Co-authored-by: Alexey Bader <[email protected]>

Author: Pavel Samolysov

llvm/tools/sycl-post-link/SpecConstants.cpp

@@ -298,30 +298,35 @@ void collectCompositeElementsDefaultValuesRecursive(
     size_t NumBytes = M.getDataLayout().getTypeStoreSize(C->getType());
     std::fill_n(std::back_inserter(DefaultValues), NumBytes, 0);
     Offset += NumBytes;
-  } else if (auto *DataSeqC = dyn_cast<ConstantDataSequential>(C)) {
+    return;
+  }
+
+  if (auto *DataSeqC = dyn_cast<ConstantDataSequential>(C)) {
     // This code is generic for both vectors and arrays of scalars
     for (size_t I = 0; I < DataSeqC->getNumElements(); ++I) {
       Constant *El = cast<Constant>(DataSeqC->getElementAsConstant(I));
       collectCompositeElementsDefaultValuesRecursive(M, El, Offset,
                                                      DefaultValues);
     }
-  } else if (auto *ArrayC = dyn_cast<ConstantArray>(C)) {
+    return;
+  }
+
+  if (auto *ArrayC = dyn_cast<ConstantArray>(C)) {
     // This branch handles arrays of composite types (structs, arrays, etc.)
-    auto *ArrTy = ArrayC->getType();
-    for (size_t I = 0; I < ArrTy->getNumElements(); ++I) {
-      // We are shure the array is not a zeroinitializer.
-      Constant *El = cast<Constant>(C->getOperand(I));
-      collectCompositeElementsDefaultValuesRecursive(M, El, Offset,
-                                                     DefaultValues);
+    assert(!C->isZeroValue() && "C must not be a zeroinitializer");
+    for (size_t I = 0; I < ArrayC->getType()->getNumElements(); ++I) {
+      collectCompositeElementsDefaultValuesRecursive(M, ArrayC->getOperand(I),
+                                                     Offset, DefaultValues);
     }
-  } else if (auto *StructC = dyn_cast<ConstantStruct>(C)) {
+    return;
+  }
+
+  if (auto *StructC = dyn_cast<ConstantStruct>(C)) {
+    assert(!C->isZeroValue() && "C must not be a zeroinitializer");
     auto *StructTy = StructC->getType();
     const StructLayout *SL = M.getDataLayout().getStructLayout(StructTy);
     const size_t BaseDefaultValueOffset = DefaultValues.size();
     for (size_t I = 0, E = StructTy->getNumElements(); I < E; ++I) {
-      // We are shure the structure is not a zeroinitializer.
-      Constant *El = cast<Constant>(C->getOperand(I));
-
       // When handling elements of a structure, we do not use manually
       // calculated offsets (which are sum of sizes of all previously
       // encountered elements), but instead rely on data provided for us by
@@ -333,7 +338,8 @@ void collectCompositeElementsDefaultValuesRecursive(
       while (LocalOffset != DefaultValues.size())
         DefaultValues.push_back(0);
 
-      collectCompositeElementsDefaultValuesRecursive(M, El, LocalOffset,
+      collectCompositeElementsDefaultValuesRecursive(M, StructC->getOperand(I),
+                                                     LocalOffset,
                                                      DefaultValues);
     }
     const size_t SLSize = SL->getSizeInBytes();
@@ -346,37 +352,39 @@ void collectCompositeElementsDefaultValuesRecursive(
     // Update "global" offset according to the total size of a handled struct
     // type.
     Offset += SLSize;
-  } else { // Assume that we encountered some scalar element
-    size_t NumBytes = M.getDataLayout().getTypeStoreSize(C->getType());
-    if (auto IntConst = dyn_cast<ConstantInt>(C)) {
-      auto Val = IntConst->getValue().getZExtValue();
-      std::copy_n(reinterpret_cast<char *>(&Val), NumBytes,
+    return;
+  }
+
+  // Assume that we encountered some scalar element
+  size_t NumBytes = M.getDataLayout().getTypeStoreSize(C->getType());
+  if (auto IntConst = dyn_cast<ConstantInt>(C)) {
+    auto Val = IntConst->getValue().getZExtValue();
+    std::copy_n(reinterpret_cast<char *>(&Val), NumBytes,
+                std::back_inserter(DefaultValues));
+  } else if (auto FPConst = dyn_cast<ConstantFP>(C)) {
+    auto Val = FPConst->getValue();
+
+    if (NumBytes == 2) {
+      auto IVal = Val.bitcastToAPInt();
+      assert(IVal.getBitWidth() == 16);
+      auto Storage = static_cast<uint16_t>(IVal.getZExtValue());
+      std::copy_n(reinterpret_cast<char *>(&Storage), NumBytes,
+                  std::back_inserter(DefaultValues));
+    } else if (NumBytes == 4) {
+      float v = Val.convertToFloat();
+      std::copy_n(reinterpret_cast<char *>(&v), NumBytes,
+                  std::back_inserter(DefaultValues));
+    } else if (NumBytes == 8) {
+      double v = Val.convertToDouble();
+      std::copy_n(reinterpret_cast<char *>(&v), NumBytes,
                   std::back_inserter(DefaultValues));
-    } else if (auto FPConst = dyn_cast<ConstantFP>(C)) {
-      auto Val = FPConst->getValue();
-
-      if (NumBytes == 2) {
-        auto IVal = Val.bitcastToAPInt();
-        assert(IVal.getBitWidth() == 16);
-        auto Storage = static_cast<uint16_t>(IVal.getZExtValue());
-        std::copy_n(reinterpret_cast<char *>(&Storage), NumBytes,
-                    std::back_inserter(DefaultValues));
-      } else if (NumBytes == 4) {
-        float v = Val.convertToFloat();
-        std::copy_n(reinterpret_cast<char *>(&v), NumBytes,
-                    std::back_inserter(DefaultValues));
-      } else if (NumBytes == 8) {
-        double v = Val.convertToDouble();
-        std::copy_n(reinterpret_cast<char *>(&v), NumBytes,
-                    std::back_inserter(DefaultValues));
-      } else {
-        llvm_unreachable("Unexpected constant floating point type");
-      }
     } else {
-      llvm_unreachable("Unexpected constant scalar type");
+      llvm_unreachable("Unexpected constant floating point type");
     }
-    Offset += NumBytes;
+  } else {
+    llvm_unreachable("Unexpected constant scalar type");
   }
+  Offset += NumBytes;
 }
 
 MDNode *generateSpecConstantMetadata(const Module &M, StringRef SymbolicID,