refactor

Author: trdthg

src/machine/instruction.cpp

@@ -765,6 +765,59 @@ Instruction &Instruction::operator=(const Instruction &c) {
     return *this;
 }
 
+int32_t extend(uint32_t value, uint32_t used_bits) {
+    return value | ~((value & (1 << (used_bits - 1))) - 1);
+}
+
+QString field_to_string(int32_t field, const ArgumentDesc* arg_desc, Address inst_addr, bool symbolic_registers_enabled) {
+    QString res = "";
+    if (arg_desc->min < 0) {
+        field = extend(field, [&]() {
+            int sum = (int)arg_desc->arg.shift;
+            for (auto chunk : arg_desc->arg) {
+                sum += chunk.count;
+            }
+            return sum;
+        }());
+    }
+    switch (arg_desc->kind) {
+    case 'g': {
+        if (symbolic_registers_enabled) {
+            res += QString(Rv_regnames[field]);
+        } else {
+            res += "x" + QString::number(field);
+        }
+        break;
+    }
+    case 'p':
+    case 'a': {
+        field += (int32_t)inst_addr.get_raw();
+        res.append(str::asHex(field));
+        break;
+    }
+    case 'o':
+    case 'n': {
+        if (arg_desc->min < 0) {
+            res += QString::number((int32_t)field, 10);
+        } else {
+            res.append(str::asHex(uint32_t(field)));
+        }
+        break;
+    }
+    case 'E': {
+        if (symbolic_registers_enabled) {
+            try {
+                res += CSR::REGISTERS[CSR::REGISTER_MAP.at(CSR::Address(field))].name;
+            } catch (std::out_of_range &e) { res.append(str::asHex(field)); }
+        } else {
+            res.append(str::asHex(field));
+        }
+        break;
+    }
+    }
+    return res;
+}
+
 QString Instruction::to_str(Address inst_addr) const {
     const InstructionMap &im = InstructionMapFind(dt);
     // TODO there are exception where some fields are zero and such so we should
@@ -787,50 +840,7 @@ QString Instruction::to_str(Address inst_addr) const {
                 continue;
             }
             auto field = (int32_t)arg_desc->arg.decode(this->dt);
-            if (arg_desc->min < 0) {
-                field = extend(field, [&]() {
-                    int sum = (int)arg_desc->arg.shift;
-                    for (auto chunk : arg_desc->arg) {
-                        sum += chunk.count;
-                    }
-                    return sum;
-                }());
-            }
-            switch (arg_desc->kind) {
-            case 'g': {
-                if (symbolic_registers_enabled) {
-                    res += QString(Rv_regnames[field]);
-                } else {
-                    res += "x" + QString::number(field);
-                }
-                break;
-            }
-            case 'p':
-            case 'a': {
-                field += (int32_t)inst_addr.get_raw();
-                res.append(str::asHex(field));
-                break;
-            }
-            case 'o':
-            case 'n': {
-                if (arg_desc->min < 0) {
-                    res += QString::number((int32_t)field, 10);
-                } else {
-                    res.append(str::asHex(uint32_t(field)));
-                }
-                break;
-            }
-            case 'E': {
-                if (symbolic_registers_enabled) {
-                    try {
-                        res += CSR::REGISTERS[CSR::REGISTER_MAP.at(CSR::Address(field))].name;
-                    } catch (std::out_of_range &e) { res.append(str::asHex(field)); }
-                } else {
-                    res.append(str::asHex(field));
-                }
-                break;
-            }
-            }
+            res += field_to_string(field, arg_desc, inst_addr, symbolic_registers_enabled);
         }
     }
     return res;
@@ -1312,6 +1322,17 @@ uint32_t Instruction::parse_field(
         if (effective_mod != Modifier::NONE) {
             val = modify_pseudoinst_imm(effective_mod, val);
         } else if (!adesc->is_value_in_field_range(val)) {
+            if (adesc->min < 0) {
+                printf("val(-): %ld\n", val);
+                printf("val(-): 0x%lx\n", val);
+                // return val.as_i64() <= max && val.as_i64() >= min;
+
+                printf("val(-) <= max(%ld): %d\n", adesc->max, (int64_t)val <= adesc->max);
+                printf("val(-) >= min(%ld): %d\n", adesc->min, (int64_t)val >= adesc->min);
+
+            } else {
+                printf("val(+): 0x%lx\n", val);
+            }
             throw ParseError("argument range exceed");
         }