Subversion Repositories NedoOS

/*

  SjASMPlus Z80 Cross Compiler - modified - RELOCATE extension

  Copyright (c) 2006 Sjoerd Mastijn (original SW)
  Copyright (c) 2020 Peter Ped Helcmanovsky (RELOCATE extension)

  This software is provided 'as-is', without any express or implied warranty.
  In no event will the authors be held liable for any damages arising from the
  use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it freely,
  subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not claim
         that you wrote the original software. If you use this software in a product,
         an acknowledgment in the product documentation would be appreciated but is
         not required.

  2. Altered source versions must be plainly marked as such, and must not be
         misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

// relocate.cpp

#include "sjdefs.h"

// local implementation stuff (shouldn't be visible through the header)
namespace Relocation {
        // when some part of opcode needs relocation, add its offset to the relocation table
        static void addOffsetToRelocate(const aint offset);

        static void refreshMaxTableCount();

        // local implementation specific data
        static constexpr aint ALTERNATIVE_OFFSET_WORD = +0x0272;        // must have at least one bit set in low three due to how some tests are written
        static constexpr aint ALTERNATIVE_OFFSET_HIGH = +0x0300;
        static TextFilePos startPos;                            // sourcefile position of last correct RELOCATE_START
        static size_t maxTableCount = 0;                        // maximum count of relocation data
        static std::vector<word> offsets;                       // offsets collected during current pass
        static std::vector<word> offsetsPrevious;       // offsets from pass2 (to be exported if pass3 is incomplete)
        static bool warnAboutContentChange = false;     // if any change in content between passes should be reported

        // public API variables
        aint alternative_offset = 0;    // offset to add to label value when evaluating alternatives
        EType type = OFF;                               // type of relocation block when inside
        bool areLabelsOffset = false;   // when the Labels should return the alternative value
        bool isResultAffected = false;  // when one of previous expression results was affected by it
        EType deltaType = OFF;                  // when isResultAffected && difference was precisely "+offset" or "+(offset>>8)"
}

// when some part of opcode needs relocation, add its offset to the relocation table
static void Relocation::addOffsetToRelocate(const aint offset) {
        // if table was already emitted from previous pass copy, warn about value discrepancies
        if (warnAboutContentChange) {
                const size_t newIndex = offsets.size();
                if (offsetsPrevious.size() <= newIndex || offsetsPrevious[newIndex] != offset) {
                        Warning("Relocation table seems internally inconsistent", "table content differs in last pass");
                        warnAboutContentChange = false;
                }
        }
        // add new offset to the relocation table
        offsets.push_back(offset);
}

void Relocation::resolveRelocationAffected(const aint opcodeRelOffset, EType minType) {
        if (type < minType) return;
        if (!isResultAffected) return;
        isResultAffected = false;                               // mark as processed
        if (minType <= deltaType) {
                if (INT_MAX == opcodeRelOffset) return;
                const aint address = (DISP_INSIDE_RELOCATE == PseudoORG) ? adrdisp : CurAddress;
                addOffsetToRelocate(address + opcodeRelOffset + type - deltaType);
                return;
        }
        // difference is not fixable by simple "+offset" relocator or in current mode
        WarningById(deltaType ? W_REL_UNSTABLE : W_REL_DIVERTS);
}

bool Relocation::checkAndWarn(bool doError) {
        // if nothing is affected by relocation, do nothing here
        if (!Relocation::isResultAffected) return false;
        // some result did set the "affected" flag, warn about it
        Relocation::isResultAffected = false;
        if (doError) {
                Error("Relocation makes one of the expressions unstable, use non-relocatable values only");
        } else {
                WarningById(W_REL_UNSTABLE);
        }
        return true;
}

// directives implementation

static void Relocation::refreshMaxTableCount() {
        if (maxTableCount < offsets.size()) {
                maxTableCount = offsets.size();
        }
        // add the relocate_count and relocate_size symbols only when RELOCATE feature was used
        if (type || maxTableCount) {
                isResultAffected = false;
                deltaType = OFF;
                LabelTable.Insert("relocate_count", maxTableCount, LABEL_IS_DEFL);
                LabelTable.Insert("relocate_size", maxTableCount * 2, LABEL_IS_DEFL);
        }
}

void Relocation::dirRELOCATE_START() {
        bool isHigh = !SkipBlanks(lp) && cmphstr(lp, "high");
        if (type) {
                sourcePosStack.push_back(startPos);
                Error("Relocation block already started here");
                sourcePosStack.pop_back();
                return;
        }
        const aint new_offset = isHigh ? ALTERNATIVE_OFFSET_HIGH : ALTERNATIVE_OFFSET_WORD;
        if (alternative_offset && alternative_offset != new_offset) {
                Error("HIGH mode can't be mixed with regular mode");
                return;
        }
        alternative_offset = new_offset;
        type = isHigh ? HIGH : REGULAR;
        assert(!sourcePosStack.empty());
        startPos = sourcePosStack.back();
        refreshMaxTableCount();
}

void Relocation::dirRELOCATE_END() {
        if (!type) {
                Error("Relocation block start for this end is missing");
                return;
        }
        if (DISP_INSIDE_RELOCATE == PseudoORG) {
                Error("End the current DISP block first");
                return;
        }
        type = OFF;
        refreshMaxTableCount();
}

void Relocation::dirRELOCATE_TABLE() {
        aint subtract_offset = 0;
        if (!SkipBlanks(lp)) {  // should be either empty remaining of line, or <subtract_offset>
                if (!ParseExpressionNoSyntaxError(lp, subtract_offset)) {
                        Error("[RELOCATE_TABLE] Syntax error in <subtract_offset>", bp, SUPPRESS);
                        return;
                }
        }
        refreshMaxTableCount();
        // dump the table into machine code output
        for (size_t offsetIndex = 0; offsetIndex < maxTableCount; ++offsetIndex) {
                // select offset from current pass table if possible, but use "offsetsPrevious" as backup
                const auto offset = (offsetIndex < offsets.size()) ? offsets[offsetIndex] : offsetsPrevious[offsetIndex];
                EmitWord(offset - subtract_offset);
        }
        warnAboutContentChange = (LASTPASS == pass);    // set in last pass to check consistency
}

void Relocation::InitPass() {
        // check if the relocation block is still open (missing RELOCATION_END in source)
        if (type) {
                sourcePosStack.push_back(startPos);
                Error("Missing end of relocation block started here");
                sourcePosStack.pop_back();
        }
        // keep copy of final offsets table from previous pass
        offsetsPrevious = offsets;
        // set the final count as the new maximum count (doesn't matter if it is smaller/bigger than old)
        maxTableCount = offsets.size();
        // clear the table for next pass and init the state
        offsets.clear();
        type = OFF;
}

//eof relocate.cpp