[WIP] ASM_NOFLOAT

tgtakaoka · Jul 2, 2024 · 3783771 · 3783771
1 parent 54a3473
commit 3783771
Show file tree

Hide file tree

Showing 15 changed files with 190 additions and 20 deletions.
diff --git a/src/asm_base.cpp b/src/asm_base.cpp
@@ -114,8 +114,10 @@ Error Assembler::processPseudo(StrScanner &scan, Insn &insn) {
 uint16_t Assembler::parseExpr16(StrScanner &expr, ErrorAt &error, char delim) const {
     auto p = expr;
     const auto value = _parser.eval(p, error, _symtab, delim);
+#ifndef ASM_NOFLOAT
     if (value.isFloat())
         error.setErrorIf(expr, INTEGER_REQUIRED);
+#endif
     if (value.overflowUint16())
         error.setErrorIf(expr, OVERFLOW_RANGE);
     expr = p;
@@ -124,8 +126,10 @@ uint16_t Assembler::parseExpr16(StrScanner &expr, ErrorAt &error, char delim) co
 
 uint32_t Assembler::parseExpr32(StrScanner &expr, ErrorAt &error, char delim) const {
     const auto value = _parser.eval(expr, error, _symtab, delim);
+#ifndef ASM_NOFLOAT
     if (value.isFloat())
         error.setErrorIf(expr, INTEGER_REQUIRED);
+#endif
     return value.getUnsigned();
 }
 
@@ -410,6 +414,7 @@ Error Assembler::defineDataConstant(StrScanner &scan, Insn &insn, uint8_t dataTy
                     big ? insn.emitUint32Be(v) : insn.emitUint32Le(v);
                     break;
                 }
+#ifndef ASM_NOFLOAT
                 /* Fall-through */
             case DATA_FLOAT32:
                 big ? insn.emitFloat32Be(val.getFloat()) : insn.emitFloat32Le(val.getFloat());
@@ -445,6 +450,7 @@ Error Assembler::defineDataConstant(StrScanner &scan, Insn &insn, uint8_t dataTy
             case DATA_PACKED_BCD96:
                 if (big)  // MC68881
                     generatePackedBcd96Be(val.getFloat(), insn, insn.length());
+#endif
                 break;
             case DATA_ALIGN2:
                 break;

diff --git a/src/asm_base.h b/src/asm_base.h
@@ -75,13 +75,15 @@ struct Assembler : private ValueParser::Locator {
         DATA_WORD,
         DATA_WORD_NO_STRING,
         DATA_LONG,
-        DATA_FLOAT32,
         DATA_FLOAT32_LONG,
+#ifndef ASM_NOFLOAT
+        DATA_FLOAT32,
         DATA_FLOAT64,
         DATA_FLOAT64_QUAD,
         DATA_FLOAT80_BCD,
         DATA_FLOAT96,
         DATA_PACKED_BCD96,
+#endif
         DATA_ALIGN2 = 0x80,
     };
     Error defineDataConstant(StrScanner &scan, Insn &insn, uint8_t dataType);

diff --git a/src/asm_i8086.cpp b/src/asm_i8086.cpp
@@ -45,9 +45,13 @@ constexpr char TEXT_RESW[] PROGMEM = "resw";
 constexpr Pseudo PSEUDOS[] PROGMEM = {
     {TEXT_DB,   &Assembler::defineDataConstant, Assembler::DATA_BYTE},
     {TEXT_DD,   &Assembler::defineDataConstant, Assembler::DATA_FLOAT32_LONG},
+#ifndef ASM_NOFLOAT
     {TEXT_DQ,   &Assembler::defineDataConstant, Assembler::DATA_FLOAT64_QUAD},
+#endif
     {TEXT_DS,   &Assembler::allocateSpaces,     Assembler::DATA_BYTE},
+#ifndef ASM_NOFLOAT
     {TEXT_DT,   &Assembler::defineDataConstant, Assembler::DATA_FLOAT80_BCD},
+#endif
     {TEXT_DW,   &Assembler::defineDataConstant, Assembler::DATA_WORD},
     {TEXT_RESB, &Assembler::allocateSpaces,     Assembler::DATA_BYTE},
     {TEXT_RESD, &Assembler::allocateSpaces,     Assembler::DATA_LONG},
@@ -85,10 +89,12 @@ void AsmI8086::reset() {
 Error AsmI8086::setFpu(StrScanner &scan) {
     auto p = scan;
     p.iexpect('i');
-    if (scan.expectTrue() || p.iequals_P(TEXT_FPU_8087)) {
-        setFpuType(FPU_I8087);
-    } else if (scan.expectFalse() || scan.iequals_P(TEXT_none)) {
+    if (scan.expectFalse() || scan.iequals_P(TEXT_none)) {
         setFpuType(FPU_NONE);
+#ifndef ASM_NOFLOAT
+    } else if (scan.expectTrue() || p.iequals_P(TEXT_FPU_8087)) {
+        setFpuType(FPU_I8087);
+#endif
     } else {
         return UNKNOWN_OPERAND;
     }

diff --git a/src/asm_mc68000.cpp b/src/asm_mc68000.cpp
@@ -65,12 +65,18 @@ constexpr Pseudo PSEUDOS[] PROGMEM = {
     {TEXT_dALIGN, &Assembler::alignOrigin},
     {TEXT_DC,     &Assembler::defineDataConstant, Assembler::DATA_WORD|Assembler::DATA_ALIGN2},
     {TEXT_DC_B,   &Assembler::defineDataConstant, Assembler::DATA_BYTE},
+#ifndef ASM_NOFLOAT
     {TEXT_DC_D,   &Assembler::defineDataConstant, Assembler::DATA_FLOAT64|Assembler::DATA_ALIGN2},
+#endif
     {TEXT_DC_L,   &Assembler::defineDataConstant, Assembler::DATA_LONG|Assembler::DATA_ALIGN2},
+#ifndef ASM_NOFLOAT
     {TEXT_DC_P,   &Assembler::defineDataConstant, Assembler::DATA_PACKED_BCD96|Assembler::DATA_ALIGN2},
     {TEXT_DC_S,   &Assembler::defineDataConstant, Assembler::DATA_FLOAT32|Assembler::DATA_ALIGN2},
+#endif
     {TEXT_DC_W,   &Assembler::defineDataConstant, Assembler::DATA_WORD|Assembler::DATA_ALIGN2},
+#ifndef ASM_NOFLOAT
     {TEXT_DC_X,   &Assembler::defineDataConstant, Assembler::DATA_FLOAT96|Assembler::DATA_ALIGN2},
+#endif
     {TEXT_DS,     &Assembler::allocateSpaces,     Assembler::DATA_BYTE},
     {TEXT_DS_B,   &Assembler::allocateSpaces,     Assembler::DATA_BYTE},
     {TEXT_DS_L,   &Assembler::allocateSpaces,     Assembler::DATA_LONG|Assembler::DATA_ALIGN2},
@@ -112,10 +118,13 @@ void AsmMc68000::reset() {
 }
 
 Error AsmMc68000::setFpu(StrScanner &scan) {
-    if (scan.expectTrue() || scan.iequals_P(TEXT_FPU_68881) || scan.iequals_P(TEXT_FPU_MC68881)) {
-        setFpuType(FPU_MC68881);
-    } else if (scan.expectFalse() || scan.iequals_P(TEXT_none)) {
+    if (scan.expectFalse() || scan.iequals_P(TEXT_none)) {
         setFpuType(FPU_NONE);
+#ifndef ASM_NOFLOAT
+    } else if (scan.expectTrue() || scan.iequals_P(TEXT_FPU_68881) ||
+               scan.iequals_P(TEXT_FPU_MC68881)) {
+        setFpuType(FPU_MC68881);
+#endif
     } else {
         return UNKNOWN_OPERAND;
     }
@@ -298,6 +307,7 @@ void AsmMc68000::encodeImmediate(AsmInsn &insn, const Operand &op, OprSize size)
             insn.setErrorIf(op, OVERFLOW_RANGE);
         insn.emitOperand16(static_cast<uint8_t>(val32));
         break;
+#ifndef ASM_NOFLOAT
     case SZ_SNGL:
         insn.emitFloat32(op.getFloat(), insn.operandPos());
         break;
@@ -311,6 +321,7 @@ void AsmMc68000::encodeImmediate(AsmInsn &insn, const Operand &op, OprSize size)
         generatePackedBcd96Be(op.getFloat(), insn.getInsn(), insn.operandPos());
         break;
     }
+#endif
     default:
         break;
     }

diff --git a/src/asm_ns32000.cpp b/src/asm_ns32000.cpp
@@ -56,8 +56,10 @@ constexpr Pseudo PSEUDOS[] PROGMEM = {
     {TEXT_dBLKW,   &Assembler::allocateSpaces,     Assembler::DATA_WORD},
     {TEXT_dBYTE,   &Assembler::defineDataConstant, Assembler::DATA_BYTE},
     {TEXT_dDOUBLE, &Assembler::defineDataConstant, Assembler::DATA_LONG},
+#ifndef ASM_NOFLOAT
     {TEXT_dFLOAT,  &Assembler::defineDataConstant, Assembler::DATA_FLOAT32},
     {TEXT_dLONG,   &Assembler::defineDataConstant, Assembler::DATA_FLOAT64},
+#endif
     {TEXT_dORG,    &Assembler::defineOrigin},
     {TEXT_dSPACE,  &Assembler::allocateSpaces,     Assembler::DATA_BYTE},
     {TEXT_dWORD,   &Assembler::defineDataConstant, Assembler::DATA_WORD},
@@ -116,10 +118,12 @@ void AsmNs32000::reset() {
 }
 
 Error AsmNs32000::setFpu(StrScanner &scan) {
-    if (scan.iequals_P(TEXT_FPU_NS32081)) {
-        setFpuType(FPU_NS32081);
-    } else if (scan.iequals_P(TEXT_none)) {
+    if (scan.iequals_P(TEXT_none)) {
         setFpuType(FPU_NONE);
+#ifndef ASM_NOFLOAT
+    } else if (scan.iequals_P(TEXT_FPU_NS32081)) {
+        setFpuType(FPU_NS32081);
+#endif
     } else {
         return UNKNOWN_OPERAND;
     }
@@ -512,12 +516,14 @@ void AsmNs32000::emitImmediate(AsmInsn &insn, AddrMode mode, const Operand &op)
     const auto size = insn.size();
     if (size == SZ_BYTE || mode == M_GENC) {
         insn.emitOperand8(op.val32);
+#ifndef ASM_NOFLOAT
     } else if (mode == M_FENR) {
         if (size == SZ_OCTA) {
             insn.emitOpFloat64(op.getFloat());
         } else {
             insn.emitOpFloat32(op.getFloat());
         }
+#endif
     } else if (size == SZ_WORD) {
         insn.emitOperand16(op.val32);
     } else if (size == SZ_QUAD) {

diff --git a/src/insn_mc68000.h b/src/insn_mc68000.h
@@ -48,7 +48,9 @@ struct Operand final : ErrorAt {
         : mode(M_NONE), reg(REG_UNDEF), indexReg(REG_UNDEF), indexSize(ISZ_NONE), value(), list() {}
     Config::uintptr_t offset(const AsmInsn &insn) const;
     uint32_t getUint32() const { return value.getUnsigned(); }
+#ifndef ASM_NOFLOAT
     double getFloat() const { return value.getFloat(); }
+#endif
 };
 
 struct AsmInsn final : AsmInsnImpl<Config>, EntryInsn {

diff --git a/src/insn_ns32000.h b/src/insn_ns32000.h
@@ -67,7 +67,9 @@ struct Operand final : ErrorAt {
           index(REG_UNDEF),
           size(SZ_NONE) {}
     uint32_t getUint32() const { return value.getUnsigned(); }
+#ifndef ASM_NOFLOAT
     double getFloat() const { return value.getFloat(); }
+#endif
 };
 
 struct AsmInsn final : public AsmInsnImpl<Config>, EntryInsn {

diff --git a/src/value.cpp b/src/value.cpp
@@ -61,11 +61,17 @@ Error Value::parseNumber(StrScanner &scan, Radix radix, uint32_t &value) {
     return strToNumber<uint32_t, UINT32_MAX>(scan, radix, value);
 }
 
+#ifndef ASM_NOFLOAT
 Error Value::parseNumber(StrScanner &scan, Radix radix, uint64_t &value) {
     return strToNumber<uint64_t, UINT64_MAX>(scan, radix, value);
 }
+#endif
 
 Error Value::parseNumber(StrScanner &scan, Radix radix) {
+#ifdef ASM_NOFLOAT
+    _type = V_UINT32;
+    return parseNumber(scan, radix, _uint32);
+#else
     const auto save = scan;
     auto type = V_UINT32;
     auto error = parseNumber(scan, radix, _uint32);
@@ -79,8 +85,10 @@ Error Value::parseNumber(StrScanner &scan, Radix radix) {
         return OK;
     }
     return NOT_AN_EXPECTED;
+#endif
 }
 
+#ifndef ASM_NOFLOAT
 int64_t Value::getInt64() const {
     if (isSigned())
         return getSigned();
@@ -96,15 +104,20 @@ double Value::getFloat() const {
         return static_cast<double>(_uint64);
     return _float64;
 }
+#endif
 
 bool Value::isZero() const {
     if (isUndefined())
         return false;
+#ifdef ASM_NOFLOAT
+    return getUnsigned() == 0;
+#else
     if (isInt32())
         return getUnsigned() == 0;
     if (isInt64())
         return getInt64() == 0;
     return _float64 == 0;
+#endif
 }
 
 bool Value::negateOverflow() const {
@@ -142,13 +155,17 @@ Value Value::operator-() const {
         const auto u32 = getUnsigned();
         if (u32 <= static_cast<uint32_t>(INT32_MIN)) {
             v.setSigned(-static_cast<int32_t>(u32));
+#ifndef ASM_NOFLOAT
         } else {
             v.setInt64(-static_cast<int64_t>(u32));
+#endif
         }
+#ifndef ASM_NOFLOAT
     } else if (isInt64()) {
         v.setInt64(-getInt64());
     } else {
         v.setFloat(-getFloat());
+#endif
     }
     return v;
 }
@@ -161,10 +178,12 @@ Value Value::operator+(const Value &rhs) const {
         } else {
             v.setUnsigned(getUnsigned() + rhs.getUnsigned());
         }
+#ifndef ASM_NOFLOAT
     } else if (isInt64() && rhs.isInt64()) {
         v.setInt64(getInt64() + rhs.getInt64());
     } else {
         v.setFloat(getFloat() + rhs.getFloat());
+#endif
     }
     return v;
 }
@@ -179,10 +198,12 @@ Value Value::operator-(const Value &rhs) const {
         } else {
             v.setUnsigned(getUnsigned() - rhs.getUnsigned());
         }
+#ifndef ASM_NOFLOAT
     } else if (isInt64() && rhs.isInt64()) {
         v.setInt64(getInt64() - rhs.getInt64());
     } else {
         v.setFloat(getFloat() - rhs.getFloat());
+#endif
     }
     return v;
 }
@@ -195,10 +216,12 @@ Value Value::operator*(const Value &rhs) const {
         } else {
             v.setUnsigned(getUnsigned() * rhs.getUnsigned());
         }
+#ifndef ASM_NOFLOAT
     } else if (isInt64() && rhs.isInt64()) {
         v.setInt64(getInt64() * rhs.getInt64());
     } else {
         v.setFloat(getFloat() * rhs.getFloat());
+#endif
     }
     return v;
 }
@@ -213,10 +236,12 @@ Value Value::operator/(const Value &rhs) const {
         } else {
             v.setUnsigned(getUnsigned() / rhs.getUnsigned());
         }
+#ifndef ASM_NOFLOAT
     } else if (isInt64() && rhs.isInt64()) {
         v.setInt64(getInt64() / rhs.getInt64());
     } else {
         v.setFloat(getFloat() / rhs.getFloat());
+#endif
     }
     return v;
 }
@@ -231,10 +256,12 @@ Value Value::operator%(const Value &rhs) const {
         } else {
             v.setUnsigned(getUnsigned() % rhs.getUnsigned());
         }
+#ifndef ASM_NOFLOAT
     } else if (isInt64() && rhs.isInt64()) {
         v.setInt64(getInt64() % rhs.getInt64());
     } else {
         v.setFloat(fmod(getFloat(), rhs.getFloat()));
+#endif
     }
     return v;
 }
@@ -283,8 +310,10 @@ Value Value::exponential(const Value &rhs) const {
         } else {
             v.setUnsigned(power<uint32_t>(getUnsigned(), rhs.getUnsigned()));
         }
+#ifndef ASM_NOFLOAT
     } else {
         v.setFloat(pow(getFloat(), rhs.getFloat()));
+#endif
     }
     return v;
 }