[rocjitsu] Return scalar builder failures as results

emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/builders/instruction_builder.cpp

@@ -74,47 +74,76 @@ enum class ScalarSop2Op {
   return std::nullopt;
 }
 
+void report_unsupported_pc_delta_builder(const util::DiagnosticEmitter *error) {
+  if (error != nullptr)
+    error->emit() << "Unimplemented instruction: scalar PC delta builder for target architecture";
+}
+
 /// @brief Build an encoded scalar `s_add_u32` instruction.
 ///
 /// @details Used only for final static-PC recovery fixup emission, after the
 /// recovery pass has proven that the old address-recovery region can be
 /// overwritten. The operands are already scalar operand encoding values.
 [[nodiscard]] std::optional<uint32_t> build_s_add_u32(rj_code_arch_t arch, uint16_t sdst,
-                                                      uint16_t ssrc0, uint16_t ssrc1) {
+                                                      uint16_t ssrc0, uint16_t ssrc1,
+                                                      const util::DiagnosticEmitter *error) {
   auto opcode = scalar_sop2_opcode(arch, ScalarSop2Op::AddU32);
-  if (!opcode)
+  if (!opcode) {
+    report_unsupported_pc_delta_builder(error);
+    return std::nullopt;
+  }
+  util::FailureOr<uint32_t> word = build_sop2_encoding(arch, *opcode, sdst, ssrc0, ssrc1, error);
+  if (word.failed())
     return std::nullopt;
-  return build_sop2_encoding(arch, *opcode, sdst, ssrc0, ssrc1);
+  return word.value();
 }
 
 /// @brief Build an encoded scalar `s_sub_u32` instruction.
 /// @copydetails build_s_add_u32
 [[nodiscard]] std::optional<uint32_t> build_s_sub_u32(rj_code_arch_t arch, uint16_t sdst,
-                                                      uint16_t ssrc0, uint16_t ssrc1) {
+                                                      uint16_t ssrc0, uint16_t ssrc1,
+                                                      const util::DiagnosticEmitter *error) {
   auto opcode = scalar_sop2_opcode(arch, ScalarSop2Op::SubU32);
-  if (!opcode)
+  if (!opcode) {
+    report_unsupported_pc_delta_builder(error);
     return std::nullopt;
-  return build_sop2_encoding(arch, *opcode, sdst, ssrc0, ssrc1);
+  }
+  util::FailureOr<uint32_t> word = build_sop2_encoding(arch, *opcode, sdst, ssrc0, ssrc1, error);
+  if (word.failed())
+    return std::nullopt;
+  return word.value();
 }
 
 /// @brief Build an encoded scalar `s_addc_u32` instruction.
 /// @copydetails build_s_add_u32
 [[nodiscard]] std::optional<uint32_t> build_s_addc_u32(rj_code_arch_t arch, uint16_t sdst,
-                                                       uint16_t ssrc0, uint16_t ssrc1) {
+                                                       uint16_t ssrc0, uint16_t ssrc1,
+                                                       const util::DiagnosticEmitter *error) {
   auto opcode = scalar_sop2_opcode(arch, ScalarSop2Op::AddcU32);
-  if (!opcode)
+  if (!opcode) {
+    report_unsupported_pc_delta_builder(error);
+    return std::nullopt;
+  }
+  util::FailureOr<uint32_t> word = build_sop2_encoding(arch, *opcode, sdst, ssrc0, ssrc1, error);
+  if (word.failed())
     return std::nullopt;
-  return build_sop2_encoding(arch, *opcode, sdst, ssrc0, ssrc1);
+  return word.value();
 }
 
 /// @brief Build an encoded scalar `s_subb_u32` instruction.
 /// @copydetails build_s_add_u32
 [[nodiscard]] std::optional<uint32_t> build_s_subb_u32(rj_code_arch_t arch, uint16_t sdst,
-                                                       uint16_t ssrc0, uint16_t ssrc1) {
+                                                       uint16_t ssrc0, uint16_t ssrc1,
+                                                       const util::DiagnosticEmitter *error) {
   auto opcode = scalar_sop2_opcode(arch, ScalarSop2Op::SubbU32);
-  if (!opcode)
+  if (!opcode) {
+    report_unsupported_pc_delta_builder(error);
+    return std::nullopt;
+  }
+  util::FailureOr<uint32_t> word = build_sop2_encoding(arch, *opcode, sdst, ssrc0, ssrc1, error);
+  if (word.failed())
     return std::nullopt;
-  return build_sop2_encoding(arch, *opcode, sdst, ssrc0, ssrc1);
+  return word.value();
 }
 
 } // namespace
@@ -143,7 +172,8 @@ bool patch_pcrel_branch_offset(const Instruction &inst, std::span<uint32_t> word
 }
 
 bool append_pc_delta_builder(std::vector<uint32_t> &words, rj_code_arch_t arch, uint16_t pc_sreg,
-                             int64_t delta, bool prefer_literal64) {
+                             int64_t delta, bool prefer_literal64,
+                             const util::DiagnosticEmitter *error) {
   constexpr uint16_t kLiteralOperand = 255;
   constexpr uint16_t kLiteral64Operand = 254;
   constexpr uint16_t kInlineInt0 = 128;
@@ -157,10 +187,16 @@ bool append_pc_delta_builder(std::vector<uint32_t> &words, rj_code_arch_t arch,
     const bool use_literal32 =
         !prefer_literal64 && delta >= 0 && raw_delta <= std::numeric_limits<uint32_t>::max();
     auto opcode = scalar_sop2_opcode(arch, ScalarSop2Op::AddNcU64);
-    if (!opcode)
+    if (!opcode) {
+      report_unsupported_pc_delta_builder(error);
       return false;
-    words.push_back(build_sop2_encoding(arch, *opcode, pc_sreg, pc_sreg,
-                                        use_literal32 ? kLiteralOperand : kLiteral64Operand));
+    }
+    util::FailureOr<uint32_t> word =
+        build_sop2_encoding(arch, *opcode, pc_sreg, pc_sreg,
+                            use_literal32 ? kLiteralOperand : kLiteral64Operand, error);
+    if (word.failed())
+      return false;
+    words.push_back(word.value());
     words.push_back(static_cast<uint32_t>(raw_delta));
     if (!use_literal32)
       words.push_back(static_cast<uint32_t>(raw_delta >> 32));
@@ -179,17 +215,25 @@ bool append_pc_delta_builder(std::vector<uint32_t> &words, rj_code_arch_t arch,
   // uses a literal; the high half uses inline zero when possible to keep the
   // replacement smaller than the original builder sequence.
   if (negative) {
-    auto sub = build_s_sub_u32(arch, pc_sreg, pc_sreg, kLiteralOperand);
-    auto subb = build_s_subb_u32(arch, pc_hi, pc_hi, hi == 0 ? kInlineInt0 : kLiteralOperand);
-    if (!sub || !subb)
+    const std::optional<uint32_t> sub =
+        build_s_sub_u32(arch, pc_sreg, pc_sreg, kLiteralOperand, error);
+    if (!sub)
+      return false;
+    const std::optional<uint32_t> subb =
+        build_s_subb_u32(arch, pc_hi, pc_hi, hi == 0 ? kInlineInt0 : kLiteralOperand, error);
+    if (!subb)
       return false;
     words.push_back(*sub);
     words.push_back(lo);
     words.push_back(*subb);
   } else {
-    auto add = build_s_add_u32(arch, pc_sreg, pc_sreg, kLiteralOperand);
-    auto addc = build_s_addc_u32(arch, pc_hi, pc_hi, hi == 0 ? kInlineInt0 : kLiteralOperand);
-    if (!add || !addc)
+    const std::optional<uint32_t> add =
+        build_s_add_u32(arch, pc_sreg, pc_sreg, kLiteralOperand, error);
+    if (!add)
+      return false;
+    const std::optional<uint32_t> addc =
+        build_s_addc_u32(arch, pc_hi, pc_hi, hi == 0 ? kInlineInt0 : kLiteralOperand, error);
+    if (!addc)
       return false;
     words.push_back(*add);
     words.push_back(lo);