mirror of
https://github.com/gbdev/rgbds.git
synced 2025-11-20 10:12:06 +00:00
Replace RGBASM non-null pointers with references
This commit is contained in:
Rangi42
Sylvie
385
src/asm/rpn.cpp
385
src/asm/rpn.cpp
@@ -22,56 +22,56 @@
|
||||
#include "opmath.hpp"
|
||||
|
||||
// Init a RPN expression
|
||||
static void initExpression(Expression *expr)
|
||||
static void initExpression(Expression &expr)
|
||||
{
|
||||
expr->reason = nullptr;
|
||||
expr->isKnown = true;
|
||||
expr->isSymbol = false;
|
||||
expr->rpn = nullptr;
|
||||
expr->rpnPatchSize = 0;
|
||||
expr.reason = nullptr;
|
||||
expr.isKnown = true;
|
||||
expr.isSymbol = false;
|
||||
expr.rpn = nullptr;
|
||||
expr.rpnPatchSize = 0;
|
||||
}
|
||||
|
||||
// Makes an expression "not known", also setting its error message
|
||||
template<typename... Ts>
|
||||
static void makeUnknown(Expression *expr, Ts ...parts)
|
||||
static void makeUnknown(Expression &expr, Ts ...parts)
|
||||
{
|
||||
expr->isKnown = false;
|
||||
expr->reason = new std::string();
|
||||
if (!expr->reason)
|
||||
expr.isKnown = false;
|
||||
expr.reason = new std::string();
|
||||
if (!expr.reason)
|
||||
fatalerror("Failed to allocate RPN error string: %s\n", strerror(errno));
|
||||
(expr->reason->append(parts), ...);
|
||||
(expr.reason->append(parts), ...);
|
||||
}
|
||||
|
||||
static uint8_t *reserveSpace(Expression *expr, uint32_t size)
|
||||
static uint8_t *reserveSpace(Expression &expr, uint32_t size)
|
||||
{
|
||||
if (!expr->rpn) {
|
||||
expr->rpn = new(std::nothrow) std::vector<uint8_t>();
|
||||
if (!expr->rpn)
|
||||
if (!expr.rpn) {
|
||||
expr.rpn = new(std::nothrow) std::vector<uint8_t>();
|
||||
if (!expr.rpn)
|
||||
fatalerror("Failed to allocate RPN expression: %s\n", strerror(errno));
|
||||
}
|
||||
|
||||
size_t curSize = expr->rpn->size();
|
||||
size_t curSize = expr.rpn->size();
|
||||
|
||||
expr->rpn->resize(curSize + size);
|
||||
return &(*expr->rpn)[curSize];
|
||||
expr.rpn->resize(curSize + size);
|
||||
return &(*expr.rpn)[curSize];
|
||||
}
|
||||
|
||||
// Free the RPN expression
|
||||
void rpn_Free(Expression *expr)
|
||||
void rpn_Free(Expression &expr)
|
||||
{
|
||||
delete expr->rpn;
|
||||
delete expr->reason;
|
||||
delete expr.rpn;
|
||||
delete expr.reason;
|
||||
initExpression(expr);
|
||||
}
|
||||
|
||||
// Add symbols, constants and operators to expression
|
||||
void rpn_Number(Expression *expr, uint32_t i)
|
||||
void rpn_Number(Expression &expr, uint32_t val)
|
||||
{
|
||||
initExpression(expr);
|
||||
expr->val = i;
|
||||
expr.val = val;
|
||||
}
|
||||
|
||||
void rpn_Symbol(Expression *expr, char const *symName)
|
||||
void rpn_Symbol(Expression &expr, char const *symName)
|
||||
{
|
||||
Symbol *sym = sym_FindScopedSymbol(symName);
|
||||
|
||||
@@ -80,14 +80,14 @@ void rpn_Symbol(Expression *expr, char const *symName)
|
||||
rpn_Number(expr, 0);
|
||||
} else if (!sym || !sym->isConstant()) {
|
||||
initExpression(expr);
|
||||
expr->isSymbol = true;
|
||||
expr.isSymbol = true;
|
||||
|
||||
if (sym_IsPC(sym))
|
||||
makeUnknown(expr, "PC is not constant at assembly time");
|
||||
else
|
||||
makeUnknown(expr, "'", symName, "' is not constant at assembly time");
|
||||
sym = sym_Ref(symName);
|
||||
expr->rpnPatchSize += 5; // 1-byte opcode + 4-byte symbol ID
|
||||
expr.rpnPatchSize += 5; // 1-byte opcode + 4-byte symbol ID
|
||||
|
||||
size_t nameLen = strlen(sym->name) + 1; // Don't forget NUL!
|
||||
uint8_t *ptr = reserveSpace(expr, nameLen + 1);
|
||||
@@ -98,29 +98,29 @@ void rpn_Symbol(Expression *expr, char const *symName)
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_BankSelf(Expression *expr)
|
||||
static void bankSelf(Expression &expr)
|
||||
{
|
||||
initExpression(expr);
|
||||
|
||||
if (!currentSection) {
|
||||
error("PC has no bank outside a section\n");
|
||||
expr->val = 1;
|
||||
expr.val = 1;
|
||||
} else if (currentSection->bank == (uint32_t)-1) {
|
||||
makeUnknown(expr, "Current section's bank is not known");
|
||||
expr->rpnPatchSize++;
|
||||
expr.rpnPatchSize++;
|
||||
*reserveSpace(expr, 1) = RPN_BANK_SELF;
|
||||
} else {
|
||||
expr->val = currentSection->bank;
|
||||
expr.val = currentSection->bank;
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_BankSymbol(Expression *expr, char const *symName)
|
||||
void rpn_BankSymbol(Expression &expr, char const *symName)
|
||||
{
|
||||
Symbol const *sym = sym_FindScopedSymbol(symName);
|
||||
|
||||
// The @ symbol is treated differently.
|
||||
if (sym_IsPC(sym)) {
|
||||
rpn_BankSelf(expr);
|
||||
bankSelf(expr);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -133,10 +133,10 @@ void rpn_BankSymbol(Expression *expr, char const *symName)
|
||||
|
||||
if (sym->getSection() && sym->getSection()->bank != (uint32_t)-1) {
|
||||
// Symbol's section is known and bank is fixed
|
||||
expr->val = sym->getSection()->bank;
|
||||
expr.val = sym->getSection()->bank;
|
||||
} else {
|
||||
makeUnknown(expr, "\"", symName, "\"'s bank is not known");
|
||||
expr->rpnPatchSize += 5; // opcode + 4-byte sect ID
|
||||
expr.rpnPatchSize += 5; // opcode + 4-byte sect ID
|
||||
|
||||
size_t nameLen = strlen(sym->name) + 1; // Room for NUL!
|
||||
uint8_t *ptr = reserveSpace(expr, nameLen + 1);
|
||||
@@ -147,130 +147,130 @@ void rpn_BankSymbol(Expression *expr, char const *symName)
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_BankSection(Expression *expr, char const *sectionName)
|
||||
void rpn_BankSection(Expression &expr, char const *sectionName)
|
||||
{
|
||||
initExpression(expr);
|
||||
|
||||
Section *section = sect_FindSectionByName(sectionName);
|
||||
|
||||
if (section && section->bank != (uint32_t)-1) {
|
||||
expr->val = section->bank;
|
||||
expr.val = section->bank;
|
||||
} else {
|
||||
makeUnknown(expr, "Section \"", sectionName, "\"'s bank is not known");
|
||||
|
||||
size_t nameLen = strlen(sectionName) + 1; // Room for NUL!
|
||||
uint8_t *ptr = reserveSpace(expr, nameLen + 1);
|
||||
|
||||
expr->rpnPatchSize += nameLen + 1;
|
||||
expr.rpnPatchSize += nameLen + 1;
|
||||
*ptr++ = RPN_BANK_SECT;
|
||||
memcpy(ptr, sectionName, nameLen);
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_SizeOfSection(Expression *expr, char const *sectionName)
|
||||
void rpn_SizeOfSection(Expression &expr, char const *sectionName)
|
||||
{
|
||||
initExpression(expr);
|
||||
|
||||
Section *section = sect_FindSectionByName(sectionName);
|
||||
|
||||
if (section && section->isSizeKnown()) {
|
||||
expr->val = section->size;
|
||||
expr.val = section->size;
|
||||
} else {
|
||||
makeUnknown(expr, "Section \"", sectionName, "\"'s size is not known");
|
||||
|
||||
size_t nameLen = strlen(sectionName) + 1; // Room for NUL!
|
||||
uint8_t *ptr = reserveSpace(expr, nameLen + 1);
|
||||
|
||||
expr->rpnPatchSize += nameLen + 1;
|
||||
expr.rpnPatchSize += nameLen + 1;
|
||||
*ptr++ = RPN_SIZEOF_SECT;
|
||||
memcpy(ptr, sectionName, nameLen);
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_StartOfSection(Expression *expr, char const *sectionName)
|
||||
void rpn_StartOfSection(Expression &expr, char const *sectionName)
|
||||
{
|
||||
initExpression(expr);
|
||||
|
||||
Section *section = sect_FindSectionByName(sectionName);
|
||||
|
||||
if (section && section->org != (uint32_t)-1) {
|
||||
expr->val = section->org;
|
||||
expr.val = section->org;
|
||||
} else {
|
||||
makeUnknown(expr, "Section \"", sectionName, "\"'s start is not known");
|
||||
|
||||
size_t nameLen = strlen(sectionName) + 1; // Room for NUL!
|
||||
uint8_t *ptr = reserveSpace(expr, nameLen + 1);
|
||||
|
||||
expr->rpnPatchSize += nameLen + 1;
|
||||
expr.rpnPatchSize += nameLen + 1;
|
||||
*ptr++ = RPN_STARTOF_SECT;
|
||||
memcpy(ptr, sectionName, nameLen);
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_SizeOfSectionType(Expression *expr, enum SectionType type)
|
||||
void rpn_SizeOfSectionType(Expression &expr, enum SectionType type)
|
||||
{
|
||||
initExpression(expr);
|
||||
makeUnknown(expr, "Section type's size is not known");
|
||||
|
||||
uint8_t *ptr = reserveSpace(expr, 2);
|
||||
|
||||
expr->rpnPatchSize += 2;
|
||||
expr.rpnPatchSize += 2;
|
||||
*ptr++ = RPN_SIZEOF_SECTTYPE;
|
||||
*ptr++ = type;
|
||||
}
|
||||
|
||||
void rpn_StartOfSectionType(Expression *expr, enum SectionType type)
|
||||
void rpn_StartOfSectionType(Expression &expr, enum SectionType type)
|
||||
{
|
||||
initExpression(expr);
|
||||
makeUnknown(expr, "Section type's start is not known");
|
||||
|
||||
uint8_t *ptr = reserveSpace(expr, 2);
|
||||
|
||||
expr->rpnPatchSize += 2;
|
||||
expr.rpnPatchSize += 2;
|
||||
*ptr++ = RPN_STARTOF_SECTTYPE;
|
||||
*ptr++ = type;
|
||||
}
|
||||
|
||||
void rpn_CheckHRAM(Expression *expr, const Expression *src)
|
||||
void rpn_CheckHRAM(Expression &expr, const Expression &src)
|
||||
{
|
||||
*expr = *src;
|
||||
expr->isSymbol = false;
|
||||
expr = src;
|
||||
expr.isSymbol = false;
|
||||
|
||||
if (!expr->isKnown) {
|
||||
expr->rpnPatchSize++;
|
||||
if (!expr.isKnown) {
|
||||
expr.rpnPatchSize++;
|
||||
*reserveSpace(expr, 1) = RPN_HRAM;
|
||||
} else if (expr->val >= 0xFF00 && expr->val <= 0xFFFF) {
|
||||
} else if (expr.val >= 0xFF00 && expr.val <= 0xFFFF) {
|
||||
// That range is valid, but only keep the lower byte
|
||||
expr->val &= 0xFF;
|
||||
} else if (expr->val < 0 || expr->val > 0xFF) {
|
||||
error("Source address $%" PRIx32 " not between $FF00 to $FFFF\n", expr->val);
|
||||
expr.val &= 0xFF;
|
||||
} else if (expr.val < 0 || expr.val > 0xFF) {
|
||||
error("Source address $%" PRIx32 " not between $FF00 to $FFFF\n", expr.val);
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_CheckRST(Expression *expr, const Expression *src)
|
||||
void rpn_CheckRST(Expression &expr, const Expression &src)
|
||||
{
|
||||
*expr = *src;
|
||||
expr = src;
|
||||
|
||||
if (expr->isKnown) {
|
||||
if (expr.isKnown) {
|
||||
// A valid RST address must be masked with 0x38
|
||||
if (expr->val & ~0x38)
|
||||
error("Invalid address $%" PRIx32 " for RST\n", expr->val);
|
||||
if (expr.val & ~0x38)
|
||||
error("Invalid address $%" PRIx32 " for RST\n", expr.val);
|
||||
// The target is in the "0x38" bits, all other bits are set
|
||||
expr->val |= 0xC7;
|
||||
expr.val |= 0xC7;
|
||||
} else {
|
||||
expr->rpnPatchSize++;
|
||||
expr.rpnPatchSize++;
|
||||
*reserveSpace(expr, 1) = RPN_RST;
|
||||
}
|
||||
}
|
||||
|
||||
// Checks that an RPN expression's value fits within N bits (signed or unsigned)
|
||||
void rpn_CheckNBit(Expression const *expr, uint8_t n)
|
||||
void rpn_CheckNBit(Expression const &expr, uint8_t n)
|
||||
{
|
||||
assert(n != 0); // That doesn't make sense
|
||||
assert(n < CHAR_BIT * sizeof(int)); // Otherwise `1 << n` is UB
|
||||
|
||||
if (expr->isKnown) {
|
||||
int32_t val = expr->val;
|
||||
if (expr.isKnown) {
|
||||
int32_t val = expr.val;
|
||||
|
||||
if (val < -(1 << n) || val >= 1 << n)
|
||||
warning(WARNING_TRUNCATION_1, "Expression must be %u-bit\n", n);
|
||||
@@ -288,15 +288,15 @@ int32_t Expression::getConstVal() const
|
||||
return val;
|
||||
}
|
||||
|
||||
void rpn_LOGNOT(Expression *expr, const Expression *src)
|
||||
void rpn_LOGNOT(Expression &expr, const Expression &src)
|
||||
{
|
||||
*expr = *src;
|
||||
expr->isSymbol = false;
|
||||
expr = src;
|
||||
expr.isSymbol = false;
|
||||
|
||||
if (expr->isKnown) {
|
||||
expr->val = !expr->val;
|
||||
if (expr.isKnown) {
|
||||
expr.val = !expr.val;
|
||||
} else {
|
||||
expr->rpnPatchSize++;
|
||||
expr.rpnPatchSize++;
|
||||
*reserveSpace(expr, 1) = RPN_LOGNOT;
|
||||
}
|
||||
}
|
||||
@@ -328,164 +328,165 @@ bool Expression::isDiffConstant(Symbol const *sym) const
|
||||
*
|
||||
* @return The constant result if it can be computed, or -1 otherwise.
|
||||
*/
|
||||
static int32_t tryConstMask(Expression const *lhs, Expression const *rhs)
|
||||
static int32_t tryConstMask(Expression const &lhs, Expression const &rhs)
|
||||
{
|
||||
Symbol const *sym = lhs->symbolOf();
|
||||
Expression const *expr = rhs;
|
||||
Symbol const *lhsSymbol = lhs.symbolOf();
|
||||
Symbol const *rhsSymbol = lhsSymbol ? nullptr : rhs.symbolOf();
|
||||
bool lhsIsSymbol = lhsSymbol && lhsSymbol->getSection();
|
||||
bool rhsIsSymbol = rhsSymbol && rhsSymbol->getSection();
|
||||
|
||||
if (!sym || !sym->getSection()) {
|
||||
// If the lhs isn't a symbol, try again the other way around
|
||||
sym = rhs->symbolOf();
|
||||
expr = lhs;
|
||||
|
||||
if (!sym || !sym->getSection())
|
||||
return -1;
|
||||
}
|
||||
assert(sym->isNumeric());
|
||||
|
||||
if (!expr->isKnown)
|
||||
if (!lhsIsSymbol && !rhsIsSymbol)
|
||||
return -1;
|
||||
// We can now safely use `expr->val`
|
||||
Section const *sect = sym->getSection();
|
||||
int32_t unknownBits = (1 << 16) - (1 << sect->align); // The max alignment is 16
|
||||
|
||||
// If the lhs isn't a symbol, try again the other way around
|
||||
Symbol const &sym = lhsIsSymbol ? *lhsSymbol : *rhsSymbol;
|
||||
Expression const &expr = lhsIsSymbol ? rhs : lhs; // Opposite side of `sym`
|
||||
|
||||
assert(sym.isNumeric());
|
||||
|
||||
if (!expr.isKnown)
|
||||
return -1;
|
||||
// We can now safely use `expr.val`
|
||||
Section const § = *sym.getSection();
|
||||
int32_t unknownBits = (1 << 16) - (1 << sect.align); // The max alignment is 16
|
||||
|
||||
// The mask must ignore all unknown bits
|
||||
if ((expr->val & unknownBits) != 0)
|
||||
if ((expr.val & unknownBits) != 0)
|
||||
return -1;
|
||||
|
||||
// `sym->getValue()` attempts to add the section's address, but that's "-1"
|
||||
// `sym.getValue()` attempts to add the section's address, but that's "-1"
|
||||
// because the section is floating (otherwise we wouldn't be here)
|
||||
assert(sect->org == (uint32_t)-1);
|
||||
int32_t symbolOfs = sym->getValue() + 1;
|
||||
assert(sect.org == (uint32_t)-1);
|
||||
int32_t symbolOfs = sym.getValue() + 1;
|
||||
|
||||
return (symbolOfs + sect->alignOfs) & ~unknownBits;
|
||||
return (symbolOfs + sect.alignOfs) & ~unknownBits;
|
||||
}
|
||||
|
||||
void rpn_BinaryOp(enum RPNCommand op, Expression *expr, const Expression *src1, const Expression *src2)
|
||||
void rpn_BinaryOp(enum RPNCommand op, Expression &expr, const Expression &src1, const Expression &src2)
|
||||
{
|
||||
expr->isSymbol = false;
|
||||
expr.isSymbol = false;
|
||||
int32_t constMaskVal;
|
||||
|
||||
// First, check if the expression is known
|
||||
expr->isKnown = src1->isKnown && src2->isKnown;
|
||||
if (expr->isKnown) {
|
||||
expr.isKnown = src1.isKnown && src2.isKnown;
|
||||
if (expr.isKnown) {
|
||||
initExpression(expr); // Init the expression to something sane
|
||||
|
||||
// If both expressions are known, just compute the value
|
||||
uint32_t uleft = src1->val, uright = src2->val;
|
||||
uint32_t uleft = src1.val, uright = src2.val;
|
||||
|
||||
switch (op) {
|
||||
case RPN_LOGOR:
|
||||
expr->val = src1->val || src2->val;
|
||||
expr.val = src1.val || src2.val;
|
||||
break;
|
||||
case RPN_LOGAND:
|
||||
expr->val = src1->val && src2->val;
|
||||
expr.val = src1.val && src2.val;
|
||||
break;
|
||||
case RPN_LOGEQ:
|
||||
expr->val = src1->val == src2->val;
|
||||
expr.val = src1.val == src2.val;
|
||||
break;
|
||||
case RPN_LOGGT:
|
||||
expr->val = src1->val > src2->val;
|
||||
expr.val = src1.val > src2.val;
|
||||
break;
|
||||
case RPN_LOGLT:
|
||||
expr->val = src1->val < src2->val;
|
||||
expr.val = src1.val < src2.val;
|
||||
break;
|
||||
case RPN_LOGGE:
|
||||
expr->val = src1->val >= src2->val;
|
||||
expr.val = src1.val >= src2.val;
|
||||
break;
|
||||
case RPN_LOGLE:
|
||||
expr->val = src1->val <= src2->val;
|
||||
expr.val = src1.val <= src2.val;
|
||||
break;
|
||||
case RPN_LOGNE:
|
||||
expr->val = src1->val != src2->val;
|
||||
expr.val = src1.val != src2.val;
|
||||
break;
|
||||
case RPN_ADD:
|
||||
expr->val = uleft + uright;
|
||||
expr.val = uleft + uright;
|
||||
break;
|
||||
case RPN_SUB:
|
||||
expr->val = uleft - uright;
|
||||
expr.val = uleft - uright;
|
||||
break;
|
||||
case RPN_XOR:
|
||||
expr->val = src1->val ^ src2->val;
|
||||
expr.val = src1.val ^ src2.val;
|
||||
break;
|
||||
case RPN_OR:
|
||||
expr->val = src1->val | src2->val;
|
||||
expr.val = src1.val | src2.val;
|
||||
break;
|
||||
case RPN_AND:
|
||||
expr->val = src1->val & src2->val;
|
||||
expr.val = src1.val & src2.val;
|
||||
break;
|
||||
case RPN_SHL:
|
||||
if (src2->val < 0)
|
||||
if (src2.val < 0)
|
||||
warning(WARNING_SHIFT_AMOUNT,
|
||||
"Shifting left by negative amount %" PRId32 "\n",
|
||||
src2->val);
|
||||
src2.val);
|
||||
|
||||
if (src2->val >= 32)
|
||||
if (src2.val >= 32)
|
||||
warning(WARNING_SHIFT_AMOUNT,
|
||||
"Shifting left by large amount %" PRId32 "\n", src2->val);
|
||||
"Shifting left by large amount %" PRId32 "\n", src2.val);
|
||||
|
||||
expr->val = op_shift_left(src1->val, src2->val);
|
||||
expr.val = op_shift_left(src1.val, src2.val);
|
||||
break;
|
||||
case RPN_SHR:
|
||||
if (src1->val < 0)
|
||||
if (src1.val < 0)
|
||||
warning(WARNING_SHIFT,
|
||||
"Shifting right negative value %" PRId32 "\n", src1->val);
|
||||
"Shifting right negative value %" PRId32 "\n", src1.val);
|
||||
|
||||
if (src2->val < 0)
|
||||
if (src2.val < 0)
|
||||
warning(WARNING_SHIFT_AMOUNT,
|
||||
"Shifting right by negative amount %" PRId32 "\n",
|
||||
src2->val);
|
||||
src2.val);
|
||||
|
||||
if (src2->val >= 32)
|
||||
if (src2.val >= 32)
|
||||
warning(WARNING_SHIFT_AMOUNT,
|
||||
"Shifting right by large amount %" PRId32 "\n",
|
||||
src2->val);
|
||||
src2.val);
|
||||
|
||||
expr->val = op_shift_right(src1->val, src2->val);
|
||||
expr.val = op_shift_right(src1.val, src2.val);
|
||||
break;
|
||||
case RPN_USHR:
|
||||
if (src2->val < 0)
|
||||
if (src2.val < 0)
|
||||
warning(WARNING_SHIFT_AMOUNT,
|
||||
"Shifting right by negative amount %" PRId32 "\n",
|
||||
src2->val);
|
||||
src2.val);
|
||||
|
||||
if (src2->val >= 32)
|
||||
if (src2.val >= 32)
|
||||
warning(WARNING_SHIFT_AMOUNT,
|
||||
"Shifting right by large amount %" PRId32 "\n",
|
||||
src2->val);
|
||||
src2.val);
|
||||
|
||||
expr->val = op_shift_right_unsigned(src1->val, src2->val);
|
||||
expr.val = op_shift_right_unsigned(src1.val, src2.val);
|
||||
break;
|
||||
case RPN_MUL:
|
||||
expr->val = uleft * uright;
|
||||
expr.val = uleft * uright;
|
||||
break;
|
||||
case RPN_DIV:
|
||||
if (src2->val == 0)
|
||||
if (src2.val == 0)
|
||||
fatalerror("Division by zero\n");
|
||||
|
||||
if (src1->val == INT32_MIN && src2->val == -1) {
|
||||
if (src1.val == INT32_MIN && src2.val == -1) {
|
||||
warning(WARNING_DIV,
|
||||
"Division of %" PRId32 " by -1 yields %" PRId32 "\n",
|
||||
INT32_MIN, INT32_MIN);
|
||||
expr->val = INT32_MIN;
|
||||
expr.val = INT32_MIN;
|
||||
} else {
|
||||
expr->val = op_divide(src1->val, src2->val);
|
||||
expr.val = op_divide(src1.val, src2.val);
|
||||
}
|
||||
break;
|
||||
case RPN_MOD:
|
||||
if (src2->val == 0)
|
||||
if (src2.val == 0)
|
||||
fatalerror("Modulo by zero\n");
|
||||
|
||||
if (src1->val == INT32_MIN && src2->val == -1)
|
||||
expr->val = 0;
|
||||
if (src1.val == INT32_MIN && src2.val == -1)
|
||||
expr.val = 0;
|
||||
else
|
||||
expr->val = op_modulo(src1->val, src2->val);
|
||||
expr.val = op_modulo(src1.val, src2.val);
|
||||
break;
|
||||
case RPN_EXP:
|
||||
if (src2->val < 0)
|
||||
if (src2.val < 0)
|
||||
fatalerror("Exponentiation by negative power\n");
|
||||
|
||||
expr->val = op_exponent(src1->val, src2->val);
|
||||
expr.val = op_exponent(src1.val, src2.val);
|
||||
break;
|
||||
|
||||
case RPN_NEG:
|
||||
@@ -505,36 +506,36 @@ void rpn_BinaryOp(enum RPNCommand op, Expression *expr, const Expression *src1,
|
||||
fatalerror("%d is not a binary operator\n", op);
|
||||
}
|
||||
|
||||
} else if (op == RPN_SUB && src1->isDiffConstant(src2->symbolOf())) {
|
||||
Symbol const *symbol1 = src1->symbolOf();
|
||||
Symbol const *symbol2 = src2->symbolOf();
|
||||
} else if (op == RPN_SUB && src1.isDiffConstant(src2.symbolOf())) {
|
||||
Symbol const &symbol1 = *src1.symbolOf();
|
||||
Symbol const &symbol2 = *src2.symbolOf();
|
||||
|
||||
expr->val = symbol1->getValue() - symbol2->getValue();
|
||||
expr->isKnown = true;
|
||||
expr.val = symbol1.getValue() - symbol2.getValue();
|
||||
expr.isKnown = true;
|
||||
} else if (op == RPN_AND && (constMaskVal = tryConstMask(src1, src2)) != -1) {
|
||||
expr->val = constMaskVal;
|
||||
expr->isKnown = true;
|
||||
expr.val = constMaskVal;
|
||||
expr.isKnown = true;
|
||||
} else {
|
||||
// If it's not known, start computing the RPN expression
|
||||
|
||||
// Convert the left-hand expression if it's constant
|
||||
if (src1->isKnown) {
|
||||
uint32_t lval = src1->val;
|
||||
if (src1.isKnown) {
|
||||
uint32_t lval = src1.val;
|
||||
uint8_t bytes[] = {RPN_CONST, (uint8_t)lval, (uint8_t)(lval >> 8),
|
||||
(uint8_t)(lval >> 16), (uint8_t)(lval >> 24)};
|
||||
expr->rpnPatchSize = sizeof(bytes);
|
||||
expr->rpn = nullptr;
|
||||
expr.rpnPatchSize = sizeof(bytes);
|
||||
expr.rpn = nullptr;
|
||||
memcpy(reserveSpace(expr, sizeof(bytes)), bytes, sizeof(bytes));
|
||||
|
||||
// Use the other expression's un-const reason
|
||||
expr->reason = src2->reason;
|
||||
delete src1->reason;
|
||||
expr.reason = src2.reason;
|
||||
delete src1.reason;
|
||||
} else {
|
||||
// Otherwise just reuse its RPN buffer
|
||||
expr->rpnPatchSize = src1->rpnPatchSize;
|
||||
expr->rpn = src1->rpn;
|
||||
expr->reason = src1->reason;
|
||||
delete src2->reason;
|
||||
expr.rpnPatchSize = src1.rpnPatchSize;
|
||||
expr.rpn = src1.rpn;
|
||||
expr.reason = src1.reason;
|
||||
delete src2.reason;
|
||||
}
|
||||
|
||||
// Now, merge the right expression into the left one
|
||||
@@ -543,17 +544,17 @@ void rpn_BinaryOp(enum RPNCommand op, Expression *expr, const Expression *src1,
|
||||
uint32_t patchSize = 0;
|
||||
|
||||
// If the right expression is constant, merge a shim instead
|
||||
uint32_t rval = src2->val;
|
||||
uint32_t rval = src2.val;
|
||||
uint8_t bytes[] = {RPN_CONST, (uint8_t)rval, (uint8_t)(rval >> 8),
|
||||
(uint8_t)(rval >> 16), (uint8_t)(rval >> 24)};
|
||||
if (src2->isKnown) {
|
||||
if (src2.isKnown) {
|
||||
ptr = bytes;
|
||||
len = sizeof(bytes);
|
||||
patchSize = sizeof(bytes);
|
||||
} else {
|
||||
ptr = src2->rpn->data(); // Pointer to the right RPN
|
||||
len = src2->rpn->size(); // Size of the right RPN
|
||||
patchSize = src2->rpnPatchSize;
|
||||
ptr = src2.rpn->data(); // Pointer to the right RPN
|
||||
len = src2.rpn->size(); // Size of the right RPN
|
||||
patchSize = src2.rpnPatchSize;
|
||||
}
|
||||
// Copy the right RPN and append the operator
|
||||
uint8_t *buf = reserveSpace(expr, len + 1);
|
||||
@@ -563,71 +564,71 @@ void rpn_BinaryOp(enum RPNCommand op, Expression *expr, const Expression *src1,
|
||||
memcpy(buf, ptr, len);
|
||||
buf[len] = op;
|
||||
|
||||
delete src2->rpn; // If there was none, this is `delete nullptr`
|
||||
expr->rpnPatchSize += patchSize + 1;
|
||||
delete src2.rpn; // If there was none, this is `delete nullptr`
|
||||
expr.rpnPatchSize += patchSize + 1;
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_HIGH(Expression *expr, const Expression *src)
|
||||
void rpn_HIGH(Expression &expr, const Expression &src)
|
||||
{
|
||||
*expr = *src;
|
||||
expr->isSymbol = false;
|
||||
expr = src;
|
||||
expr.isSymbol = false;
|
||||
|
||||
if (expr->isKnown) {
|
||||
expr->val = (uint32_t)expr->val >> 8 & 0xFF;
|
||||
if (expr.isKnown) {
|
||||
expr.val = (uint32_t)expr.val >> 8 & 0xFF;
|
||||
} else {
|
||||
uint8_t bytes[] = {RPN_CONST, 8, 0, 0, 0, RPN_SHR,
|
||||
RPN_CONST, 0xFF, 0, 0, 0, RPN_AND};
|
||||
expr->rpnPatchSize += sizeof(bytes);
|
||||
expr.rpnPatchSize += sizeof(bytes);
|
||||
memcpy(reserveSpace(expr, sizeof(bytes)), bytes, sizeof(bytes));
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_LOW(Expression *expr, const Expression *src)
|
||||
void rpn_LOW(Expression &expr, const Expression &src)
|
||||
{
|
||||
*expr = *src;
|
||||
expr->isSymbol = false;
|
||||
expr = src;
|
||||
expr.isSymbol = false;
|
||||
|
||||
if (expr->isKnown) {
|
||||
expr->val = expr->val & 0xFF;
|
||||
if (expr.isKnown) {
|
||||
expr.val = expr.val & 0xFF;
|
||||
} else {
|
||||
uint8_t bytes[] = {RPN_CONST, 0xFF, 0, 0, 0, RPN_AND};
|
||||
|
||||
expr->rpnPatchSize += sizeof(bytes);
|
||||
expr.rpnPatchSize += sizeof(bytes);
|
||||
memcpy(reserveSpace(expr, sizeof(bytes)), bytes, sizeof(bytes));
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_ISCONST(Expression *expr, const Expression *src)
|
||||
void rpn_ISCONST(Expression &expr, const Expression &src)
|
||||
{
|
||||
initExpression(expr);
|
||||
expr->val = src->isKnown;
|
||||
expr->isKnown = true;
|
||||
expr->isSymbol = false;
|
||||
expr.val = src.isKnown;
|
||||
expr.isKnown = true;
|
||||
expr.isSymbol = false;
|
||||
}
|
||||
|
||||
void rpn_NEG(Expression *expr, const Expression *src)
|
||||
void rpn_NEG(Expression &expr, const Expression &src)
|
||||
{
|
||||
*expr = *src;
|
||||
expr->isSymbol = false;
|
||||
expr = src;
|
||||
expr.isSymbol = false;
|
||||
|
||||
if (expr->isKnown) {
|
||||
expr->val = -(uint32_t)expr->val;
|
||||
if (expr.isKnown) {
|
||||
expr.val = -(uint32_t)expr.val;
|
||||
} else {
|
||||
expr->rpnPatchSize++;
|
||||
expr.rpnPatchSize++;
|
||||
*reserveSpace(expr, 1) = RPN_NEG;
|
||||
}
|
||||
}
|
||||
|
||||
void rpn_NOT(Expression *expr, const Expression *src)
|
||||
void rpn_NOT(Expression &expr, const Expression &src)
|
||||
{
|
||||
*expr = *src;
|
||||
expr->isSymbol = false;
|
||||
expr = src;
|
||||
expr.isSymbol = false;
|
||||
|
||||
if (expr->isKnown) {
|
||||
expr->val = ~expr->val;
|
||||
if (expr.isKnown) {
|
||||
expr.val = ~expr.val;
|
||||
} else {
|
||||
expr->rpnPatchSize++;
|
||||
expr.rpnPatchSize++;
|
||||
*reserveSpace(expr, 1) = RPN_NOT;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user