WebAssembly: Never write more than 32-bits for WebAssembly::OPERAND_OFFSET32

[sbc100]

Summary

A bug was found where an offset of -1 would generate an encoding
of max int64 which is invalid in the binary format.

[sbc100]

update test

[sbc100]

remove debugging

[sbc100]

• update test

[dschuff]

LGTM for the encoding... I hope the -1 offset wasn't being generated by the compiler though?

[sbc100]

In D45280#1057520, @dschuff wrote:

LGTM for the encoding... I hope the -1 offset wasn't being generated by the compiler though?

It does come from the compiler:

void _start(void) {
  char *oob = (char *) -1; *oob = 0;
}

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCCodeEmitter.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
+
 using namespace llvm;
 
 #define DEBUG_TYPE "mccodeemitter"
 
 STATISTIC(MCNumEmitted, "Number of MC instructions emitted.");
 STATISTIC(MCNumFixups, "Number of MC fixups created.");
 
 namespace {
MCCodeEmitter *llvm::createWebAssemblyMCCodeEmitter(const MCInstrInfo &MCII) {
   return new WebAssemblyMCCodeEmitter(MCII);
 }
 
 void WebAssemblyMCCodeEmitter::encodeInstruction(
     const MCInst &MI, raw_ostream &OS, SmallVectorImpl<MCFixup> &Fixups,
     const MCSubtargetInfo &STI) const {
   uint64_t Start = OS.tell();
 
+  DEBUG(dbgs() << "encodeInstruction: " << MI << "\n");
   uint64_t Binary = getBinaryCodeForInstr(MI, Fixups, STI);
   if (Binary <= UINT8_MAX) {
     OS << uint8_t(Binary);
   } else {
     assert(Binary <= UINT16_MAX && "Several-byte opcodes not supported yet");
     OS << uint8_t(Binary >> 8)
        << uint8_t(Binary);
   }
for (unsigned i = 0, e = MI.getNumOperands(); i < e; ++i) {
     const MCOperand &MO = MI.getOperand(i);
     if (MO.isReg()) {
       /* nothing to encode */
     } else if (MO.isImm()) {
       if (i < Desc.getNumOperands()) {
         assert(Desc.TSFlags == 0 &&
                "WebAssembly non-variable_ops don't use TSFlags");
         const MCOperandInfo &Info = Desc.OpInfo[i];
+        DEBUG(dbgs() << "Encoding immediate: type=" << int(Info.OperandType) << "\n");
         if (Info.OperandType == WebAssembly::OPERAND_I32IMM) {
           encodeSLEB128(int32_t(MO.getImm()), OS);
+        } else if (Info.OperandType == WebAssembly::OPERAND_OFFSET32) {
+          encodeULEB128(uint32_t(MO.getImm()), OS);
         } else if (Info.OperandType == WebAssembly::OPERAND_I64IMM) {
           encodeSLEB128(int64_t(MO.getImm()), OS);
         } else if (Info.OperandType == WebAssembly::OPERAND_GLOBAL) {
           llvm_unreachable("wasm globals should only be accessed symbolicly");
         } else if (Info.OperandType == WebAssembly::OPERAND_SIGNATURE) {
           OS << uint8_t(MO.getImm());
         } else {
           encodeULEB128(uint64_t(MO.getImm()), OS);

test/CodeGen/WebAssembly/offset.ll

 ; CHECK: i32.const $push0=, 0{{$}}
 ; CHECK: i32.load  $push1=, 42($pop0){{$}}
 define i32 @load_i32_from_numeric_address() {
   %s = inttoptr i32 42 to i32*
   %t = load i32, i32* %s
   ret i32 %t
 }
 
+; When loading from a fixed address, offsets are coerced into u32 range
+
+; CHECK-LABEL: load_i32_from_negative_address
+; CHECK: i32.const $push0=, 0{{$}}
+; CHECK: i32.load  $push1=, 4294967295($pop0){{$}}
+define i32 @load_i32_from_negative_address() {
+  %s = inttoptr i32 -1 to i32*
+  %t = load i32, i32* %s
+  ret i32 %t
+}
+
 ; CHECK-LABEL: load_i32_from_global_address
 ; CHECK: i32.const $push0=, 0{{$}}
 ; CHECK: i32.load  $push1=, gv($pop0){{$}}
 @gv = global i32 0
 define i32 @load_i32_from_global_address() {
   %t = load i32, i32* @gv
   ret i32 %t
 }