[mlir][spirv] Propagate LogicalResult in (de)serialization

[antiagainst]

Summary

(void) was added when LogicalResult was marked as non
discard. This commit cleans them up to properly propagate
failures.

Depends On D115534

mlir/include/mlir/Target/SPIRV/SPIRVBinaryUtils.h

 /// `idBound`.
 void appendModuleHeader(SmallVectorImpl<uint32_t> &header,
                         spirv::Version version, uint32_t idBound);
 
 /// Returns the word-count-prefixed opcode for an SPIR-V instruction.
 uint32_t getPrefixedOpcode(uint32_t wordCount, spirv::Opcode opcode);
 
 /// Encodes an SPIR-V `literal` string into the given `binary` vector.
-LogicalResult encodeStringLiteralInto(SmallVectorImpl<uint32_t> &binary,
-                                      StringRef literal);
+void encodeStringLiteralInto(SmallVectorImpl<uint32_t> &binary,
 
 /// Decodes a string literal in `words` starting at `wordIndex`. Update the
 /// latter to point to the position in words after the string literal.
 inline StringRef decodeStringLiteral(ArrayRef<uint32_t> words,
                                      unsigned &wordIndex) {
   StringRef str(reinterpret_cast<const char *>(words.data() + wordIndex));
   wordIndex += str.size() / 4 + 1;
   return str;
 }
 
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_TARGET_SPIRV_BINARY_UTILS_H_

mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp

LogicalResult spirv::Deserializer::processInstruction(
   case spirv::Opcode::OpVariable:
     if (isa<spirv::ModuleOp>(opBuilder.getBlock()->getParentOp())) {
       return processGlobalVariable(operands);
     }
     break;
   case spirv::Opcode::OpLine:
     return processDebugLine(operands);
   case spirv::Opcode::OpNoLine:
-    return clearDebugLine();
+    clearDebugLine();
+    return success();
   case spirv::Opcode::OpName:
     return processName(operands);
   case spirv::Opcode::OpString:
     return processDebugString(operands);
   case spirv::Opcode::OpModuleProcessed:
   case spirv::Opcode::OpSource:
   case spirv::Opcode::OpSourceContinued:
   case spirv::Opcode::OpSourceExtension:
LogicalResult spirv::Deserializer::processOpWithoutGrammarAttr(
   if (hasResult)
     opState.addTypes(resultTypes);
   opState.addAttributes(attributes);
   Operation *op = opBuilder.createOperation(opState);
   if (hasResult)
     valueMap[valueID] = op->getResult(0);
 
   if (op->hasTrait<OpTrait::IsTerminator>())
-    (void)clearDebugLine();
+    clearDebugLine();
 
   return success();
 }
 
 LogicalResult spirv::Deserializer::processUndef(ArrayRef<uint32_t> operands) {
   if (operands.size() != 2) {
     return emitError(unknownLoc, "OpUndef instruction must have two operands");
   }

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

private:
   LogicalResult processConstantNull(ArrayRef<uint32_t> operands);
 
   //===--------------------------------------------------------------------===//
   // Debug
   //===--------------------------------------------------------------------===//
 
   /// Discontinues any source-level location information that might be active
   /// from a previous OpLine instruction.
-  LogicalResult clearDebugLine();
+  void clearDebugLine();
 
   /// Creates a FileLineColLoc with the OpLine location information.
   Location createFileLineColLoc(OpBuilder opBuilder);
 
   /// Processes a SPIR-V OpLine instruction with the given `operands`.
   LogicalResult processDebugLine(ArrayRef<uint32_t> operands);
 
   /// Processes a SPIR-V OpString instruction with the given `operands`.

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

LogicalResult spirv::Deserializer::processBranch(ArrayRef<uint32_t> operands) {
 
   auto *target = getOrCreateBlock(operands[0]);
   auto loc = createFileLineColLoc(opBuilder);
   // The preceding instruction for the OpBranch instruction could be an
   // OpLoopMerge or an OpSelectionMerge instruction, in this case they will have
   // the same OpLine information.
   opBuilder.create<spirv::BranchOp>(loc, target);
 
-  (void)clearDebugLine();
+  clearDebugLine();
   return success();
 }
 
 LogicalResult
 spirv::Deserializer::processBranchConditional(ArrayRef<uint32_t> operands) {
   if (!curBlock) {
     return emitError(unknownLoc,
                      "OpBranchConditional must appear inside a block");
spirv::Deserializer::processBranchConditional(ArrayRef<uint32_t> operands) {
   // an OpSelectionMerge instruction, in this case they will have the same
   // OpLine information.
   auto loc = createFileLineColLoc(opBuilder);
   opBuilder.create<spirv::BranchConditionalOp>(
       loc, condition, trueBlock,
       /*trueArguments=*/ArrayRef<Value>(), falseBlock,
       /*falseArguments=*/ArrayRef<Value>(), weights);
 
-  (void)clearDebugLine();
+  clearDebugLine();
   return success();
 }
 
 LogicalResult spirv::Deserializer::processLabel(ArrayRef<uint32_t> operands) {
   if (!curFunction) {
     return emitError(unknownLoc, "OpLabel must appear inside a function");
   }
 
spirv::Deserializer::processDebugLine(ArrayRef<uint32_t> operands) {
   // following: the next end of block, the next OpLine instruction, or the next
   // OpNoLine instruction."
   if (operands.size() != 3)
     return emitError(unknownLoc, "OpLine must have 3 operands");
   debugLine = DebugLine(operands[0], operands[1], operands[2]);
   return success();
 }
 
-LogicalResult spirv::Deserializer::clearDebugLine() {
-  debugLine = llvm::None;
-  return success();
-}
+void spirv::Deserializer::clearDebugLine() { debugLine = llvm::None; }
 
 LogicalResult
 spirv::Deserializer::processDebugString(ArrayRef<uint32_t> operands) {
   if (operands.size() < 2)
     return emitError(unknownLoc, "OpString needs at least 2 operands");
 
   if (!debugInfoMap.lookup(operands[0]).empty())
     return emitError(unknownLoc,

mlir/lib/Target/SPIRV/SPIRVBinaryUtils.cpp

 }
 
 /// Returns the word-count-prefixed opcode for an SPIR-V instruction.
 uint32_t spirv::getPrefixedOpcode(uint32_t wordCount, spirv::Opcode opcode) {
   assert(((wordCount >> 16) == 0) && "word count out of range!");
   return (wordCount << 16) | static_cast<uint32_t>(opcode);
 }
 
-LogicalResult spirv::encodeStringLiteralInto(SmallVectorImpl<uint32_t> &binary,
-                                             StringRef literal) {
+void spirv::encodeStringLiteralInto(SmallVectorImpl<uint32_t> &binary,
   // We need to encode the literal and the null termination.
   auto encodingSize = literal.size() / 4 + 1;
   auto bufferStartSize = binary.size();
   binary.resize(bufferStartSize + encodingSize, 0);
   std::memcpy(binary.data() + bufferStartSize, literal.data(), literal.size());
-  return success();
 }

mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp

 }
 
 LogicalResult Serializer::processSpecConstantOp(spirv::SpecConstantOp op) {
   if (auto resultID = prepareConstantScalar(op.getLoc(), op.default_value(),
                                             /*isSpec=*/true)) {
     // Emit the OpDecorate instruction for SpecId.
     if (auto specID = op->getAttrOfType<IntegerAttr>("spec_id")) {
       auto val = static_cast<uint32_t>(specID.getInt());
-      (void)emitDecoration(resultID, spirv::Decoration::SpecId, {val});
+      if (failed(emitDecoration(resultID, spirv::Decoration::SpecId, {val})))
+        return failure();
     }
 
     specConstIDMap[op.sym_name()] = resultID;
     return processName(resultID, op.sym_name());
   }
   return failure();
 }
 
for (auto index : llvm::seq<uint32_t>(0, constituents.size())) {
     if (!constituentID) {
       return op.emitError("unknown result <id> for specialization constant ")
              << constituentName;
     }
 
     operands.push_back(constituentID);
   }
 
-  (void)encodeInstructionInto(typesGlobalValues,
-                              spirv::Opcode::OpSpecConstantComposite, operands);
+  encodeInstructionInto(typesGlobalValues,
   specConstIDMap[op.sym_name()] = resultID;
 
   return processName(resultID, op.sym_name());
 }
 
 LogicalResult
 Serializer::processSpecConstantOperationOp(spirv::SpecConstantOperationOp op) {
   uint32_t typeID = 0;
Serializer::processSpecConstantOperationOp(spirv::SpecConstantOperationOp op) {
 
   // Append operands to the enclosed op to the list of operands.
   for (Value operand : enclosedOp.getOperands()) {
     uint32_t id = getValueID(operand);
     assert(id && "use before def!");
     operands.push_back(id);
   }
 
-  (void)encodeInstructionInto(typesGlobalValues,
-                              spirv::Opcode::OpSpecConstantOp, operands);
+  encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpSpecConstantOp,
+                        operands);
   valueIDMap[op.getResult()] = resultID;
 
   return success();
 }
 
 LogicalResult Serializer::processUndefOp(spirv::UndefOp op) {
   auto undefType = op.getType();
   auto &id = undefValIDMap[undefType];
   if (!id) {
     id = getNextID();
     uint32_t typeID = 0;
-    if (failed(processType(op.getLoc(), undefType, typeID)) ||
-        failed(encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpUndef,
-                                     {typeID, id}))) {
+    if (failed(processType(op.getLoc(), undefType, typeID)))
       return failure();
-    }
+    encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpUndef,
+                          {typeID, id});
   }
   valueIDMap[op.getResult()] = id;
   return success();
 }
 
 LogicalResult Serializer::processFuncOp(spirv::FuncOp op) {
   LLVM_DEBUG(llvm::dbgs() << "-- start function '" << op.getName() << "' --\n");
   assert(functionHeader.empty() && functionBody.empty());
 
   uint32_t fnTypeID = 0;
   // Generate type of the function.
-  (void)processType(op.getLoc(), op.getType(), fnTypeID);
+  if (failed(processType(op.getLoc(), op.getType(), fnTypeID)))
+    return failure();
 
   // Add the function definition.
   SmallVector<uint32_t, 4> operands;
   uint32_t resTypeID = 0;
   auto resultTypes = op.getType().getResults();
   if (resultTypes.size() > 1) {
     return op.emitError("cannot serialize function with multiple return types");
   }
   if (failed(processType(op.getLoc(),
                          (resultTypes.empty() ? getVoidType() : resultTypes[0]),
                          resTypeID))) {
     return failure();
   }
   operands.push_back(resTypeID);
   auto funcID = getOrCreateFunctionID(op.getName());
   operands.push_back(funcID);
   operands.push_back(static_cast<uint32_t>(op.function_control()));
   operands.push_back(fnTypeID);
-  (void)encodeInstructionInto(functionHeader, spirv::Opcode::OpFunction,
-                              operands);
+  encodeInstructionInto(functionHeader, spirv::Opcode::OpFunction, operands);
 
   // Add function name.
   if (failed(processName(funcID, op.getName()))) {
     return failure();
   }
 
   // Declare the parameters.
   for (auto arg : op.getArguments()) {
     uint32_t argTypeID = 0;
     if (failed(processType(op.getLoc(), arg.getType(), argTypeID))) {
       return failure();
     }
     auto argValueID = getNextID();
     valueIDMap[arg] = argValueID;
-    (void)encodeInstructionInto(functionHeader,
-                                spirv::Opcode::OpFunctionParameter,
-                                {argTypeID, argValueID});
+    encodeInstructionInto(functionHeader, spirv::Opcode::OpFunctionParameter,
   }
 
   // Process the body.
   if (op.isExternal()) {
     return op.emitError("external function is unhandled");
   }
 
   // Some instructions (e.g., OpVariable) in a function must be in the first
   // block in the function. These instructions will be put in functionHeader.
   // Thus, we put the label in functionHeader first, and omit it from the first
   // block.
-  (void)encodeInstructionInto(functionHeader, spirv::Opcode::OpLabel,
-                              {getOrCreateBlockID(&op.front())});
-  (void)processBlock(&op.front(), /*omitLabel=*/true);
+  encodeInstructionInto(functionHeader, spirv::Opcode::OpLabel,
+  if (failed(processBlock(&op.front(), /*omitLabel=*/true)))
+    return failure();
   if (failed(visitInPrettyBlockOrder(
           &op.front(), [&](Block *block) { return processBlock(block); },
           /*skipHeader=*/true))) {
     return failure();
   }
 
   // There might be OpPhi instructions who have value references needing to fix.
-  for (auto deferredValue : deferredPhiValues) {
+  for (const auto &deferredValue : deferredPhiValues) {
     Value value = deferredValue.first;
     uint32_t id = getValueID(value);
     LLVM_DEBUG(llvm::dbgs() << "[phi] fix reference of value " << value
                             << " to id = " << id << '\n');
     assert(id && "OpPhi references undefined value!");
     for (size_t offset : deferredValue.second)
       functionBody[offset] = id;
   }
   deferredPhiValues.clear();
 
   LLVM_DEBUG(llvm::dbgs() << "-- completed function '" << op.getName()
                           << "' --\n");
   // Insert OpFunctionEnd.
-  if (failed(encodeInstructionInto(functionBody, spirv::Opcode::OpFunctionEnd,
-                                   {}))) {
-    return failure();
-  }
+  encodeInstructionInto(functionBody, spirv::Opcode::OpFunctionEnd, {});
 
   functions.append(functionHeader.begin(), functionHeader.end());
   functions.append(functionBody.begin(), functionBody.end());
   functionHeader.clear();
   functionBody.clear();
 
   return success();
 }
LogicalResult Serializer::processVariableOp(spirv::VariableOp op) {
   elidedAttrs.push_back(spirv::attributeName<spirv::StorageClass>());
   for (auto arg : op.getODSOperands(0)) {
     auto argID = getValueID(arg);
     if (!argID) {
       return emitError(op.getLoc(), "operand 0 has a use before def");
     }
     operands.push_back(argID);
   }
-  (void)emitDebugLine(functionHeader, op.getLoc());
-  (void)encodeInstructionInto(functionHeader, spirv::Opcode::OpVariable,
-                              operands);
+  if (failed(emitDebugLine(functionHeader, op.getLoc())))
+    return failure();
+  encodeInstructionInto(functionHeader, spirv::Opcode::OpVariable, operands);
   for (auto attr : op->getAttrs()) {
     if (llvm::any_of(elidedAttrs, [&](StringRef elided) {
           return attr.getName() == elided;
         })) {
       continue;
     }
     if (failed(processDecoration(op.getLoc(), resultID, attr))) {
       return failure();
if (auto initializer = varOp.initializer()) {
     if (!initializerID) {
       return emitError(varOp.getLoc(),
                        "invalid usage of undefined variable as initializer");
     }
     operands.push_back(initializerID);
     elidedAttrs.push_back("initializer");
   }
 
-  (void)emitDebugLine(typesGlobalValues, varOp.getLoc());
-  if (failed(encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpVariable,
-                                   operands))) {
-    elidedAttrs.push_back("initializer");
+  if (failed(emitDebugLine(typesGlobalValues, varOp.getLoc())))
     return failure();
-  }
+  encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpVariable, operands);
+  elidedAttrs.push_back("initializer");
 
   // Encode decorations.
   for (auto attr : varOp->getAttrs()) {
     if (llvm::any_of(elidedAttrs, [&](StringRef elided) {
           return attr.getName() == elided;
         })) {
       continue;
     }
LogicalResult Serializer::processSelectionOp(spirv::SelectionOp selectionOp) {
   auto *mergeBlock = selectionOp.getMergeBlock();
   auto mergeID = getBlockID(mergeBlock);
   auto loc = selectionOp.getLoc();
 
   // Emit the selection header block, which dominates all other blocks, first.
   // We need to emit an OpSelectionMerge instruction before the selection header
   // block's terminator.
   auto emitSelectionMerge = [&]() {
-    (void)emitDebugLine(functionBody, loc);
+    if (failed(emitDebugLine(functionBody, loc)))
+      return failure();
     lastProcessedWasMergeInst = true;
-    (void)encodeInstructionInto(
+    encodeInstructionInto(
         functionBody, spirv::Opcode::OpSelectionMerge,
         {mergeID, static_cast<uint32_t>(selectionOp.selection_control())});
+    return success();
   };
   // For structured selection, we cannot have blocks in the selection construct
   // branching to the selection header block. Entering the selection (and
   // reaching the selection header) must be from the block containing the
   // spv.mlir.selection op. If there are ops ahead of the spv.mlir.selection op
   // in the block, we can "merge" them into the selection header. So here we
   // don't need to emit a separate block; just continue with the existing block.
   if (failed(processBlock(headerBlock, /*omitLabel=*/true, emitSelectionMerge)))
     return failure();
 
   // Process all blocks with a depth-first visitor starting from the header
   // block. The selection header block and merge block are skipped by this
   // visitor.
   if (failed(visitInPrettyBlockOrder(
           headerBlock, [&](Block *block) { return processBlock(block); },
           /*skipHeader=*/true, /*skipBlocks=*/{mergeBlock})))
     return failure();
 
   // There is nothing to do for the merge block in the selection, which just
   // contains a spv.mlir.merge op, itself. But we need to have an OpLabel
   // instruction to start a new SPIR-V block for ops following this SelectionOp.
   // The block should use the <id> for the merge block.
-  return encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {mergeID});
+  encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {mergeID});
+  return success();
 }
 
 LogicalResult Serializer::processLoopOp(spirv::LoopOp loopOp) {
   // Assign <id>s to all blocks so that branches inside the LoopOp can resolve
   // properly. We don't need to assign for the entry block, which is just for
   // satisfying MLIR region's structural requirement.
   auto &body = loopOp.body();
   for (Block &block :
        llvm::make_range(std::next(body.begin(), 1), body.end())) {
     getOrCreateBlockID(&block);
   }
   auto *headerBlock = loopOp.getHeaderBlock();
   auto *continueBlock = loopOp.getContinueBlock();
   auto *mergeBlock = loopOp.getMergeBlock();
   auto headerID = getBlockID(headerBlock);
   auto continueID = getBlockID(continueBlock);
   auto mergeID = getBlockID(mergeBlock);
   auto loc = loopOp.getLoc();
 
   // This LoopOp is in some MLIR block with preceding and following ops. In the
   // binary format, it should reside in separate SPIR-V blocks from its
   // preceding and following ops. So we need to emit unconditional branches to
   // jump to this LoopOp's SPIR-V blocks and jumping back to the normal flow
   // afterwards.
-  (void)encodeInstructionInto(functionBody, spirv::Opcode::OpBranch,
-                              {headerID});
+  encodeInstructionInto(functionBody, spirv::Opcode::OpBranch, {headerID});
 
   // LoopOp's entry block is just there for satisfying MLIR's structural
   // requirements so we omit it and start serialization from the loop header
   // block.
 
   // Emit the loop header block, which dominates all other blocks, first. We
   // need to emit an OpLoopMerge instruction before the loop header block's
   // terminator.
   auto emitLoopMerge = [&]() {
-    (void)emitDebugLine(functionBody, loc);
+    if (failed(emitDebugLine(functionBody, loc)))
+      return failure();
     lastProcessedWasMergeInst = true;
-    (void)encodeInstructionInto(
+    encodeInstructionInto(
         functionBody, spirv::Opcode::OpLoopMerge,
         {mergeID, continueID, static_cast<uint32_t>(loopOp.loop_control())});
+    return success();
   };
   if (failed(processBlock(headerBlock, /*omitLabel=*/false, emitLoopMerge)))
     return failure();
 
   // Process all blocks with a depth-first visitor starting from the header
   // block. The loop header block, loop continue block, and loop merge block are
   // skipped by this visitor and handled later in this function.
   if (failed(visitInPrettyBlockOrder(
           headerBlock, [&](Block *block) { return processBlock(block); },
           /*skipHeader=*/true, /*skipBlocks=*/{continueBlock, mergeBlock})))
     return failure();
 
   // We have handled all other blocks. Now get to the loop continue block.
   if (failed(processBlock(continueBlock)))
     return failure();
 
   // There is nothing to do for the merge block in the loop, which just contains
   // a spv.mlir.merge op, itself. But we need to have an OpLabel instruction to
   // start a new SPIR-V block for ops following this LoopOp. The block should
   // use the <id> for the merge block.
-  return encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {mergeID});
+  encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {mergeID});
+  return success();
 }
 
 LogicalResult Serializer::processBranchConditionalOp(
     spirv::BranchConditionalOp condBranchOp) {
   auto conditionID = getValueID(condBranchOp.condition());
   auto trueLabelID = getOrCreateBlockID(condBranchOp.getTrueBlock());
   auto falseLabelID = getOrCreateBlockID(condBranchOp.getFalseBlock());
   SmallVector<uint32_t, 5> arguments{conditionID, trueLabelID, falseLabelID};
 
   if (auto weights = condBranchOp.branch_weights()) {
     for (auto val : weights->getValue())
       arguments.push_back(val.cast<IntegerAttr>().getInt());
   }
 
-  (void)emitDebugLine(functionBody, condBranchOp.getLoc());
-  return encodeInstructionInto(functionBody, spirv::Opcode::OpBranchConditional,
-                               arguments);
+  if (failed(emitDebugLine(functionBody, condBranchOp.getLoc())))
+    return failure();
+  encodeInstructionInto(functionBody, spirv::Opcode::OpBranchConditional,
+  return success();
 }
 
 LogicalResult Serializer::processBranchOp(spirv::BranchOp branchOp) {
-  (void)emitDebugLine(functionBody, branchOp.getLoc());
-  return encodeInstructionInto(functionBody, spirv::Opcode::OpBranch,
-                               {getOrCreateBlockID(branchOp.getTarget())});
+  if (failed(emitDebugLine(functionBody, branchOp.getLoc())))
+    return failure();
+  encodeInstructionInto(functionBody, spirv::Opcode::OpBranch,
+  return success();
 }
 
 LogicalResult Serializer::processAddressOfOp(spirv::AddressOfOp addressOfOp) {
   auto varName = addressOfOp.variable();
   auto variableID = getVariableID(varName);
   if (!variableID) {
     return addressOfOp.emitError("unknown result <id> for variable ")
            << varName;
Serializer::processOp<spirv::EntryPointOp>(spirv::EntryPointOp op) {
   if (!funcID) {
     return op.emitError("missing <id> for function ")
            << op.fn()
            << "; function needs to be defined before spv.EntryPoint is "
               "serialized";
   }
   operands.push_back(funcID);
   // Add the name of the function.
-  (void)spirv::encodeStringLiteralInto(operands, op.fn());
+  spirv::encodeStringLiteralInto(operands, op.fn());
 
   // Add the interface values.
   if (auto interface = op.interface()) {
     for (auto var : interface.getValue()) {
       auto id = getVariableID(var.cast<FlatSymbolRefAttr>().getValue());
       if (!id) {
         return op.emitError("referencing undefined global variable."
                             "spv.EntryPoint is at the end of spv.module. All "
                             "referenced variables should already be defined");
       }
       operands.push_back(id);
     }
   }
-  return encodeInstructionInto(entryPoints, spirv::Opcode::OpEntryPoint,
-                               operands);
+  encodeInstructionInto(entryPoints, spirv::Opcode::OpEntryPoint, operands);
+  return success();
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::ControlBarrierOp>(spirv::ControlBarrierOp op) {
   StringRef argNames[] = {"execution_scope", "memory_scope",
                           "memory_semantics"};
   SmallVector<uint32_t, 3> operands;
 
   for (auto argName : argNames) {
     auto argIntAttr = op->getAttrOfType<IntegerAttr>(argName);
     auto operand = prepareConstantInt(op.getLoc(), argIntAttr);
     if (!operand) {
       return failure();
     }
     operands.push_back(operand);
   }
 
-  return encodeInstructionInto(functionBody, spirv::Opcode::OpControlBarrier,
-                               operands);
+  encodeInstructionInto(functionBody, spirv::Opcode::OpControlBarrier,
+  return success();
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::ExecutionModeOp>(spirv::ExecutionModeOp op) {
   SmallVector<uint32_t, 4> operands;
   // Add the function <id>.
   auto funcID = getFunctionID(op.fn());
Serializer::processOp<spirv::ExecutionModeOp>(spirv::ExecutionModeOp op) {
   // Serialize values if any.
   auto values = op.values();
   if (values) {
     for (auto &intVal : values.getValue()) {
       operands.push_back(static_cast<uint32_t>(
           intVal.cast<IntegerAttr>().getValue().getZExtValue()));
     }
   }
-  return encodeInstructionInto(executionModes, spirv::Opcode::OpExecutionMode,
-                               operands);
+  encodeInstructionInto(executionModes, spirv::Opcode::OpExecutionMode,
+  return success();
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::MemoryBarrierOp>(spirv::MemoryBarrierOp op) {
   StringRef argNames[] = {"memory_scope", "memory_semantics"};
   SmallVector<uint32_t, 2> operands;
 
   for (auto argName : argNames) {
     auto argIntAttr = op->getAttrOfType<IntegerAttr>(argName);
     auto operand = prepareConstantInt(op.getLoc(), argIntAttr);
     if (!operand) {
       return failure();
     }
     operands.push_back(operand);
   }
 
-  return encodeInstructionInto(functionBody, spirv::Opcode::OpMemoryBarrier,
-                               operands);
+  encodeInstructionInto(functionBody, spirv::Opcode::OpMemoryBarrier, operands);
+  return success();
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::FunctionCallOp>(spirv::FunctionCallOp op) {
   auto funcName = op.callee();
   uint32_t resTypeID = 0;
 
for (auto value : op.arguments()) {
     auto valueID = getValueID(value);
     assert(valueID && "cannot find a value for spv.FunctionCall");
     operands.push_back(valueID);
   }
 
   if (!resultTy.isa<NoneType>())
     valueIDMap[op.getResult(0)] = funcCallID;
 
-  return encodeInstructionInto(functionBody, spirv::Opcode::OpFunctionCall,
-                               operands);
+  encodeInstructionInto(functionBody, spirv::Opcode::OpFunctionCall, operands);
+  return success();
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::CopyMemoryOp>(spirv::CopyMemoryOp op) {
   SmallVector<uint32_t, 4> operands;
   SmallVector<StringRef, 2> elidedAttrs;
 
Serializer::processOp<spirv::CopyMemoryOp>(spirv::CopyMemoryOp op) {
   elidedAttrs.push_back("source_memory_access");
 
   if (auto attr = op->getAttr("source_alignment")) {
     operands.push_back(static_cast<uint32_t>(
         attr.cast<IntegerAttr>().getValue().getZExtValue()));
   }
 
   elidedAttrs.push_back("source_alignment");
-  (void)emitDebugLine(functionBody, op.getLoc());
-  (void)encodeInstructionInto(functionBody, spirv::Opcode::OpCopyMemory,
-                              operands);
+  if (failed(emitDebugLine(functionBody, op.getLoc())))
+    return failure();
+  encodeInstructionInto(functionBody, spirv::Opcode::OpCopyMemory, operands);
 
   return success();
 }
 
 // Pull in auto-generated Serializer::dispatchToAutogenSerialization() and
 // various Serializer::processOp<...>() specializations.
 #define GET_SERIALIZATION_FNS
 #include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
 
 } // namespace spirv
 } // namespace mlir

mlir/lib/Target/SPIRV/Serialization/Serializer.h

 #include "mlir/Target/SPIRV/Serialization.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 namespace spirv {
 
-LogicalResult encodeInstructionInto(SmallVectorImpl<uint32_t> &binary,
-                                    spirv::Opcode op,
-                                    ArrayRef<uint32_t> operands);
+void encodeInstructionInto(SmallVectorImpl<uint32_t> &binary, spirv::Opcode op,
 
 /// A SPIR-V module serializer.
 ///
 /// A SPIR-V binary module is a single linear stream of instructions; each
 /// instruction is composed of 32-bit words with the layout:
 ///
 ///   | <word-count>|<opcode> |  <operand>   |  <operand>   | ... |
 ///   | <------ word -------> | <-- word --> | <-- word --> | ... |
private:
 
   /// Processes the given `block` and emits SPIR-V instructions for all ops
   /// inside. Does not emit OpLabel for this block if `omitLabel` is true.
   /// `actionBeforeTerminator` is a callback that will be invoked before
   /// handling the terminator op. It can be used to inject the Op*Merge
   /// instruction if this is a SPIR-V selection/loop header block.
   LogicalResult
   processBlock(Block *block, bool omitLabel = false,
-               function_ref<void()> actionBeforeTerminator = nullptr);
+               function_ref<LogicalResult()> actionBeforeTerminator = nullptr);
 
   /// Emits OpPhi instructions for the given block if it has block arguments.
   LogicalResult emitPhiForBlockArguments(Block *block);
 
   LogicalResult processSelectionOp(spirv::SelectionOp selectionOp);
 
   LogicalResult processLoopOp(spirv::LoopOp loopOp);
 

mlir/lib/Target/SPIRV/Serialization/Serializer.cpp

static Block *getPhiIncomingBlock(Block *block) {
   return block;
 }
 
 namespace mlir {
 namespace spirv {
 
 /// Encodes an SPIR-V instruction with the given `opcode` and `operands` into
 /// the given `binary` vector.
-LogicalResult encodeInstructionInto(SmallVectorImpl<uint32_t> &binary,
-                                    spirv::Opcode op,
-                                    ArrayRef<uint32_t> operands) {
+void encodeInstructionInto(SmallVectorImpl<uint32_t> &binary, spirv::Opcode op,
   uint32_t wordCount = 1 + operands.size();
   binary.push_back(spirv::getPrefixedOpcode(wordCount, op));
   binary.append(operands.begin(), operands.end());
-  return success();
 }
 
 Serializer::Serializer(spirv::ModuleOp module,
                        const SerializationOptions &options)
     : module(module), mlirBuilder(module.getContext()), options(options) {}
 
 LogicalResult Serializer::serialize() {
   LLVM_DEBUG(llvm::dbgs() << "+++ starting serialization +++\n");
if (!funcID) {
     funcID = getNextID();
     funcIDMap[fnName] = funcID;
   }
   return funcID;
 }
 
 void Serializer::processCapability() {
   for (auto cap : module.vce_triple()->getCapabilities())
-    (void)encodeInstructionInto(capabilities, spirv::Opcode::OpCapability,
-                                {static_cast<uint32_t>(cap)});
+    encodeInstructionInto(capabilities, spirv::Opcode::OpCapability,
 }
 
 void Serializer::processDebugInfo() {
   if (!options.emitDebugInfo)
     return;
   auto fileLoc = module.getLoc().dyn_cast<FileLineColLoc>();
   auto fileName = fileLoc ? fileLoc.getFilename().strref() : "<unknown>";
   fileID = getNextID();
   SmallVector<uint32_t, 16> operands;
   operands.push_back(fileID);
-  (void)spirv::encodeStringLiteralInto(operands, fileName);
-  (void)encodeInstructionInto(debug, spirv::Opcode::OpString, operands);
+  spirv::encodeStringLiteralInto(operands, fileName);
+  encodeInstructionInto(debug, spirv::Opcode::OpString, operands);
   // TODO: Encode more debug instructions.
 }
 
 void Serializer::processExtension() {
   llvm::SmallVector<uint32_t, 16> extName;
   for (spirv::Extension ext : module.vce_triple()->getExtensions()) {
     extName.clear();
-    (void)spirv::encodeStringLiteralInto(extName,
-                                         spirv::stringifyExtension(ext));
-    (void)encodeInstructionInto(extensions, spirv::Opcode::OpExtension,
-                                extName);
+    spirv::encodeStringLiteralInto(extName, spirv::stringifyExtension(ext));
+    encodeInstructionInto(extensions, spirv::Opcode::OpExtension, extName);
   }
 }
 
 void Serializer::processMemoryModel() {
   uint32_t mm = module->getAttrOfType<IntegerAttr>("memory_model").getInt();
   uint32_t am = module->getAttrOfType<IntegerAttr>("addressing_model").getInt();
 
-  (void)encodeInstructionInto(memoryModel, spirv::Opcode::OpMemoryModel,
-                              {am, mm});
+  encodeInstructionInto(memoryModel, spirv::Opcode::OpMemoryModel, {am, mm});
 }
 
 LogicalResult Serializer::processDecoration(Location loc, uint32_t resultID,
                                             NamedAttribute attr) {
   auto attrName = attr.getName().strref();
   auto decorationName = llvm::convertToCamelFromSnakeCase(attrName, true);
   auto decoration = spirv::symbolizeDecoration(decorationName);
   if (!decoration) {

 
 LogicalResult Serializer::processName(uint32_t resultID, StringRef name) {
   assert(!name.empty() && "unexpected empty string for OpName");
   if (!options.emitSymbolName)
     return success();
 
   SmallVector<uint32_t, 4> nameOperands;
   nameOperands.push_back(resultID);
-  if (failed(spirv::encodeStringLiteralInto(nameOperands, name)))
-    return failure();
-  return encodeInstructionInto(names, spirv::Opcode::OpName, nameOperands);
+  spirv::encodeStringLiteralInto(nameOperands, name);
+  encodeInstructionInto(names, spirv::Opcode::OpName, nameOperands);
+  return success();
 }
 
 template <>
 LogicalResult Serializer::processTypeDecoration<spirv::ArrayType>(
     Location loc, spirv::ArrayType type, uint32_t resultID) {
   if (unsigned stride = type.getArrayStride()) {
     // OpDecorate %arrayTypeSSA ArrayStride strideLiteral
     return emitDecoration(resultID, spirv::Decoration::ArrayStride, {stride});
LogicalResult Serializer::processMemberDecoration(
     uint32_t structID,
     const spirv::StructType::MemberDecorationInfo &memberDecoration) {
   SmallVector<uint32_t, 4> args(
       {structID, memberDecoration.memberIndex,
        static_cast<uint32_t>(memberDecoration.decoration)});
   if (memberDecoration.hasValue) {
     args.push_back(memberDecoration.decorationValue);
   }
-  return encodeInstructionInto(decorations, spirv::Opcode::OpMemberDecorate,
-                               args);
+  encodeInstructionInto(decorations, spirv::Opcode::OpMemberDecorate, args);
+  return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Type
 //===----------------------------------------------------------------------===//
 
 // According to the SPIR-V spec "Validation Rules for Shader Capabilities":
 // "Composite objects in the StorageBuffer, PhysicalStorageBuffer, Uniform, and
if ((type.isa<FunctionType>() &&
                                      operands))) ||
       succeeded(prepareBasicType(loc, type, typeID, typeEnum, operands,
                                  deferSerialization, serializationCtx))) {
     if (deferSerialization)
       return success();
 
     typeIDMap[type] = typeID;
 
-    if (failed(encodeInstructionInto(typesGlobalValues, typeEnum, operands)))
-      return failure();
+    encodeInstructionInto(typesGlobalValues, typeEnum, operands);
 
     if (recursiveStructInfos.count(type) != 0) {
       // This recursive struct type is emitted already, now the OpTypePointer
       // instructions referring to recursive references are emitted as well.
       for (auto &ptrInfo : recursiveStructInfos[type]) {
         // TODO: This might not work if more than 1 recursive reference is
         // present in the struct.
         SmallVector<uint32_t, 4> ptrOperands;
         ptrOperands.push_back(ptrInfo.pointerTypeID);
         ptrOperands.push_back(static_cast<uint32_t>(ptrInfo.storageClass));
         ptrOperands.push_back(typeIDMap[type]);
 
-        if (failed(encodeInstructionInto(
-                typesGlobalValues, spirv::Opcode::OpTypePointer, ptrOperands)))
-          return failure();
+        encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpTypePointer,
+                              ptrOperands);
       }
 
       recursiveStructInfos[type].clear();
     }
 
     return success();
   }
 
if (pointeeStruct && pointeeStruct.isIdentified() &&
       //
       // 1. Prepare an OpTypeForwardPointer with resultID and the ptr storage
       // class as operands.
       SmallVector<uint32_t, 2> forwardPtrOperands;
       forwardPtrOperands.push_back(resultID);
       forwardPtrOperands.push_back(
           static_cast<uint32_t>(ptrType.getStorageClass()));
 
-      (void)encodeInstructionInto(typesGlobalValues,
-                                  spirv::Opcode::OpTypeForwardPointer,
-                                  forwardPtrOperands);
+      encodeInstructionInto(typesGlobalValues,
 
       // 2. Find the pointee (enclosing) struct.
       auto structType = spirv::StructType::getIdentified(
           module.getContext(), pointeeStruct.getIdentifier());
 
       if (!structType)
         return failure();
 
if (failed(
       return failure();
     }
     operands.push_back(imageTypeID);
     return success();
   }
 
   if (auto structType = type.dyn_cast<spirv::StructType>()) {
     if (structType.isIdentified()) {
-      (void)processName(resultID, structType.getIdentifier());
+      if (failed(processName(resultID, structType.getIdentifier())))
+        return failure();
       serializationCtx.insert(structType.getIdentifier());
     }
 
     bool hasOffset = structType.hasOffset();
     for (auto elementIndex :
          llvm::seq<uint32_t>(0, structType.getNumElements())) {
       uint32_t elementTypeID = 0;
       if (failed(processTypeImpl(loc, structType.getElementType(elementIndex),
uint32_t Serializer::prepareArrayConstant(Location loc, Type constType,
   for (Attribute elementAttr : attr) {
     if (auto elementID = prepareConstant(loc, elementType, elementAttr)) {
       operands.push_back(elementID);
     } else {
       return 0;
     }
   }
   spirv::Opcode opcode = spirv::Opcode::OpConstantComposite;
-  (void)encodeInstructionInto(typesGlobalValues, opcode, operands);
+  encodeInstructionInto(typesGlobalValues, opcode, operands);
 
   return resultID;
 }
 
 // TODO: Turn the below function into iterative function, instead of
 // recursive function.
 uint32_t
 Serializer::prepareDenseElementsConstant(Location loc, Type constType,
for (int i = 0; i < shapedType.getDimSize(dim); ++i) {
     if (auto elementID = prepareDenseElementsConstant(
             loc, elementType, valueAttr, dim + 1, index)) {
       operands.push_back(elementID);
     } else {
       return 0;
     }
   }
   spirv::Opcode opcode = spirv::Opcode::OpConstantComposite;
-  (void)encodeInstructionInto(typesGlobalValues, opcode, operands);
+  encodeInstructionInto(typesGlobalValues, opcode, operands);
 
   return resultID;
 }
 
 uint32_t Serializer::prepareConstantScalar(Location loc, Attribute valueAttr,
                                            bool isSpec) {
   if (auto floatAttr = valueAttr.dyn_cast<FloatAttr>()) {
     return prepareConstantFp(loc, floatAttr, isSpec);
uint32_t Serializer::prepareConstantBool(Location loc, BoolAttr boolAttr,
   }
 
   auto resultID = getNextID();
   auto opcode = boolAttr.getValue()
                     ? (isSpec ? spirv::Opcode::OpSpecConstantTrue
                               : spirv::Opcode::OpConstantTrue)
                     : (isSpec ? spirv::Opcode::OpSpecConstantFalse
                               : spirv::Opcode::OpConstantFalse);
-  (void)encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID});
+  encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID});
 
   if (!isSpec) {
     constIDMap[boolAttr] = resultID;
   }
   return resultID;
 }
 
 uint32_t Serializer::prepareConstantInt(Location loc, IntegerAttr intAttr,
uint32_t Serializer::prepareConstantInt(Location loc, IntegerAttr intAttr,
   case 16:
   case 8: {
     uint32_t word = 0;
     if (isSigned) {
       word = static_cast<int32_t>(value.getSExtValue());
     } else {
       word = static_cast<uint32_t>(value.getZExtValue());
     }
-    (void)encodeInstructionInto(typesGlobalValues, opcode,
-                                {typeID, resultID, word});
+    encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
   } break;
     // According to SPIR-V spec: "When the type's bit width is larger than one
     // word, the literal’s low-order words appear first."
   case 64: {
     struct DoubleWord {
       uint32_t word1;
       uint32_t word2;
     } words;
     if (isSigned) {
       words = llvm::bit_cast<DoubleWord>(value.getSExtValue());
     } else {
       words = llvm::bit_cast<DoubleWord>(value.getZExtValue());
     }
-    (void)encodeInstructionInto(typesGlobalValues, opcode,
-                                {typeID, resultID, words.word1, words.word2});
+    encodeInstructionInto(typesGlobalValues, opcode,
   } break;
   default: {
     std::string valueStr;
     llvm::raw_string_ostream rss(valueStr);
     value.print(rss, /*isSigned=*/false);
 
     emitError(loc, "cannot serialize ")
         << bitwidth << "-bit integer literal: " << rss.str();
uint32_t Serializer::prepareConstantFp(Location loc, FloatAttr floatAttr,
   APFloat value = floatAttr.getValue();
   APInt intValue = value.bitcastToAPInt();
 
   auto opcode =
       isSpec ? spirv::Opcode::OpSpecConstant : spirv::Opcode::OpConstant;
 
   if (&value.getSemantics() == &APFloat::IEEEsingle()) {
     uint32_t word = llvm::bit_cast<uint32_t>(value.convertToFloat());
-    (void)encodeInstructionInto(typesGlobalValues, opcode,
-                                {typeID, resultID, word});
+    encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
   } else if (&value.getSemantics() == &APFloat::IEEEdouble()) {
     struct DoubleWord {
       uint32_t word1;
       uint32_t word2;
     } words = llvm::bit_cast<DoubleWord>(value.convertToDouble());
-    (void)encodeInstructionInto(typesGlobalValues, opcode,
-                                {typeID, resultID, words.word1, words.word2});
+    encodeInstructionInto(typesGlobalValues, opcode,
   } else if (&value.getSemantics() == &APFloat::IEEEhalf()) {
     uint32_t word =
         static_cast<uint32_t>(value.bitcastToAPInt().getZExtValue());
-    (void)encodeInstructionInto(typesGlobalValues, opcode,
-                                {typeID, resultID, word});
+    encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
   } else {
     std::string valueStr;
     llvm::raw_string_ostream rss(valueStr);
     value.print(rss);
 
     emitError(loc, "cannot serialize ")
         << floatAttr.getType() << "-typed float literal: " << rss.str();
     return 0;

 uint32_t Serializer::getOrCreateBlockID(Block *block) {
   if (uint32_t id = getBlockID(block))
     return id;
   return blockIDMap[block] = getNextID();
 }
 
 LogicalResult
 Serializer::processBlock(Block *block, bool omitLabel,
-                         function_ref<void()> actionBeforeTerminator) {
+                         function_ref<LogicalResult()> actionBeforeTerminator) {
   LLVM_DEBUG(llvm::dbgs() << "processing block " << block << ":\n");
   LLVM_DEBUG(block->print(llvm::dbgs()));
   LLVM_DEBUG(llvm::dbgs() << '\n');
   if (!omitLabel) {
     uint32_t blockID = getOrCreateBlockID(block);
     LLVM_DEBUG(llvm::dbgs()
                << "[block] " << block << " (id = " << blockID << ")\n");
 
     // Emit OpLabel for this block.
-    (void)encodeInstructionInto(functionBody, spirv::Opcode::OpLabel,
-                                {blockID});
+    encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {blockID});
   }
 
   // Emit OpPhi instructions for block arguments, if any.
   if (failed(emitPhiForBlockArguments(block)))
     return failure();
 
   // Process each op in this block except the terminator.
   for (auto &op : llvm::make_range(block->begin(), std::prev(block->end()))) {
     if (failed(processOperation(&op)))
       return failure();
   }
 
   // Process the terminator.
   if (actionBeforeTerminator)
-    actionBeforeTerminator();
+    if (failed(actionBeforeTerminator()))
+      return failure();
   if (failed(processOperation(&block->back())))
     return failure();
 
   return success();
 }
 
 LogicalResult Serializer::emitPhiForBlockArguments(Block *block) {
   // Nothing to do if this block has no arguments or it's the entry block, which
for (auto predIndex : llvm::seq<unsigned>(0, predecessors.size())) {
       } else {
         LLVM_DEBUG(llvm::dbgs() << "(id = " << valueId << ")\n");
       }
       phiArgs.push_back(valueId);
       // ... and a parent block <id>.
       phiArgs.push_back(predBlockId);
     }
 
-    (void)encodeInstructionInto(functionBody, spirv::Opcode::OpPhi, phiArgs);
+    encodeInstructionInto(functionBody, spirv::Opcode::OpPhi, phiArgs);
     valueIDMap[arg] = phiID;
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Operation
 //===----------------------------------------------------------------------===//
 
 LogicalResult Serializer::encodeExtensionInstruction(
     Operation *op, StringRef extensionSetName, uint32_t extensionOpcode,
     ArrayRef<uint32_t> operands) {
   // Check if the extension has been imported.
   auto &setID = extendedInstSetIDMap[extensionSetName];
   if (!setID) {
     setID = getNextID();
     SmallVector<uint32_t, 16> importOperands;
     importOperands.push_back(setID);
-    if (failed(
-            spirv::encodeStringLiteralInto(importOperands, extensionSetName)) ||
-        failed(encodeInstructionInto(
-            extendedSets, spirv::Opcode::OpExtInstImport, importOperands))) {
-      return failure();
-    }
+    spirv::encodeStringLiteralInto(importOperands, extensionSetName);
+    encodeInstructionInto(extendedSets, spirv::Opcode::OpExtInstImport,
+                          importOperands);
   }
 
   // The first two operands are the result type <id> and result <id>. The set
   // <id> and the opcode need to be insert after this.
   if (operands.size() < 2) {
     return op->emitError("extended instructions must have a result encoding");
   }
   SmallVector<uint32_t, 8> extInstOperands;
   extInstOperands.reserve(operands.size() + 2);
   extInstOperands.append(operands.begin(), std::next(operands.begin(), 2));
   extInstOperands.push_back(setID);
   extInstOperands.push_back(extensionOpcode);
   extInstOperands.append(std::next(operands.begin(), 2), operands.end());
-  return encodeInstructionInto(functionBody, spirv::Opcode::OpExtInst,
-                               extInstOperands);
+  encodeInstructionInto(functionBody, spirv::Opcode::OpExtInst,
+  return success();
 }
 
 LogicalResult Serializer::processOperation(Operation *opInst) {
   LLVM_DEBUG(llvm::dbgs() << "[op] '" << opInst->getName() << "'\n");
 
   // First dispatch the ops that do not directly mirror an instruction from
   // the SPIR-V spec.
   return TypeSwitch<Operation *, LogicalResult>(opInst)
if (op->getNumResults() != 0) {
     resultID = getNextID();
     operands.push_back(resultID);
     valueIDMap[op->getResult(0)] = resultID;
   };
 
   for (Value operand : op->getOperands())
     operands.push_back(getValueID(operand));
 
-  (void)emitDebugLine(functionBody, loc);
+  if (failed(emitDebugLine(functionBody, loc)))
+    return failure();
 
   if (extInstSet.empty()) {
-    (void)encodeInstructionInto(functionBody,
-                                static_cast<spirv::Opcode>(opcode), operands);
+    encodeInstructionInto(functionBody, static_cast<spirv::Opcode>(opcode),
+                          operands);
   } else {
-    (void)encodeExtensionInstruction(op, extInstSet, opcode, operands);
+    if (failed(encodeExtensionInstruction(op, extInstSet, opcode, operands)))
+      return failure();
   }
 
   if (op->getNumResults() != 0) {
     for (auto attr : op->getAttrs()) {
       if (failed(processDecoration(loc, resultID, attr)))
         return failure();
     }
   }
LogicalResult Serializer::emitDebugLine(SmallVectorImpl<uint32_t> &binary,
 
   if (lastProcessedWasMergeInst) {
     lastProcessedWasMergeInst = false;
     return success();
   }
 
   auto fileLoc = loc.dyn_cast<FileLineColLoc>();
   if (fileLoc)
-    (void)encodeInstructionInto(
-        binary, spirv::Opcode::OpLine,
+    encodeInstructionInto(binary, spirv::Opcode::OpLine,
                           {fileID, fileLoc.getLine(), fileLoc.getColumn()});
   return success();
 }
 } // namespace spirv
 } // namespace mlir