review(coff): name /bigobj, and drop a constant the DATA rule stopped using

Two things a read-through caught.

`/bigobj` objects are a different container — machine 0 and `0xFFFF` where the
section count would be — and the reader fell through to "unsupported COFF machine
0x0000". True and useless: it blames the reader for a flag the project passed.
Named now, with the two ways out (drop /bigobj, or annotate the surface and need
no generated .def at all).

`kScnMemWrite` was left over from a first version whose DATA rule keyed on
writability. It does not: a `const` in `.rdata` is a variable and consumers read
it as one, so the rule keys on "not executable" instead. The constant was
documenting a decision that is no longer taken.

Author: speak-agent

src/build/coff_exports.cppm

@@ -115,7 +115,6 @@ constexpr std::uint16_t kMachineArm64  = 0xaa64;
 
 constexpr std::uint8_t  kSymClassExternal = 2;    // IMAGE_SYM_CLASS_EXTERNAL
 constexpr std::uint16_t kSymTypeFunction  = 0x20; // DTYPE_FUNCTION << 4
-constexpr std::uint32_t kScnMemWrite      = 0x80000000u; // IMAGE_SCN_MEM_WRITE
 constexpr std::uint32_t kScnMemExecute    = 0x20000000u; // IMAGE_SCN_MEM_EXECUTE
 
 std::uint16_t rd16(std::span<const std::byte> b, std::size_t off) {
@@ -201,6 +200,23 @@ read_exports(std::span<const std::byte> bytes)
         return std::unexpected("not a COFF object: shorter than a file header");
 
     const auto machine = rd16(bytes, 0);
+
+    // `/bigobj` objects are a DIFFERENT container: machine 0 and a `0xFFFF`
+    // where the section count would be, followed by a class GUID and a much
+    // larger header. Named here rather than left to fall out as "unsupported
+    // machine 0x0000", which is true and useless — the reader would be blamed
+    // for a flag the project passed.
+    if (machine == 0 && bytes.size() >= 4 && rd16(bytes, 2) == 0xFFFF) {
+        return std::unexpected(
+            "this is a /bigobj object, whose header layout differs from an "
+            "ordinary COFF one.\n"
+            "  mcpp's export reader does not parse it. Build the shared library "
+            "without /bigobj,\n"
+            "  or mark its public surface with __declspec(dllexport) — an "
+            "annotated library needs\n"
+            "  no generated .def at all.");
+    }
+
     if (!is_supported_machine(machine)) {
         return std::unexpected(std::format(
             "unsupported COFF machine 0x{:04x}. mcpp reads i386, amd64, arm, "

tests/unit/test_coff_exports.cpp

@@ -214,6 +214,21 @@ TEST(CoffExports, RefusesATruncatedSymbolTable) {
     EXPECT_NE(r.error().find("past the end"), std::string::npos);
 }
 
+TEST(CoffExports, NamesBigobjRatherThanCallingItAnUnknownMachine) {
+    // A `/bigobj` object is a different container: machine 0 and 0xFFFF where
+    // the section count would be. Falling through to "unsupported machine
+    // 0x0000" is true and useless — it blames the reader for a flag the project
+    // passed.
+    auto obj = make_obj({ Sym{ .name = "f" } });
+    obj[0] = std::byte{0}; obj[1] = std::byte{0};
+    obj[2] = std::byte{0xFF}; obj[3] = std::byte{0xFF};
+    auto r = read_exports(obj);
+    ASSERT_FALSE(r);
+    EXPECT_NE(r.error().find("bigobj"), std::string::npos);
+    // And it says what to do, or it is a dead end.
+    EXPECT_NE(r.error().find("dllexport"), std::string::npos);
+}
+
 TEST(CoffExports, RefusesSomethingThatIsNotAnObject) {
     std::vector<std::byte> tiny(4, std::byte{0});
     EXPECT_FALSE(read_exports(tiny));