Changeset 3562 in CLRX


Ignore:
Timestamp:
Dec 25, 2017, 12:53:51 PM (9 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Asm: Add resolveLoHiRelocExpression method and use in resolveRelocation methods (code remove obsolete code duplications).

Location:
CLRadeonExtender/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdasm/AsmFormats.h

    r3560 r3562  
    131131    /// constructor
    132132    explicit AsmFormatHandler(Assembler& assembler);
     133   
     134    // resolve LO32BIT/HI32BIT relocations (partially, helper)
     135    bool resolveLoHiRelocExpression(const AsmExpression* expr, RelocType& relType,
     136                    cxuint& relSectionId, uint64_t& relValue);
    133137public:
    134138    virtual ~AsmFormatHandler();
  • CLRadeonExtender/trunk/amdasm/AsmAmdCL2Format.cpp

    r3428 r3562  
    21432143                 cxuint& outSectionId)
    21442144{
     2145    RelocType relType = RELTYPE_LOW_32BIT;
     2146    cxuint relSectionId = 0;
     2147    uint64_t relValue = 0;
    21452148    const AsmExprTarget& target = expr->getTarget();
    21462149    const AsmExprTargetType tgtType = target.type;
    2147     if ((tgtType!=ASMXTGT_DATA32 &&
    2148         !assembler.isaAssembler->relocationIsFit(32, tgtType)))
     2150    if (!resolveLoHiRelocExpression(expr, relType, relSectionId, relValue))
     2151        return false;
     2152   
     2153    // relocation only for rodata, data and bss section
     2154    if (relSectionId!=rodataSection && relSectionId!=dataSection &&
     2155        relSectionId!=bssSection)
    21492156    {
    21502157        assembler.printError(expr->getSourcePos(),
    2151                         "Can't resolve expression for non 32-bit integer");
     2158                    "Section of this expression must be a global data, rwdata or bss");
    21522159        return false;
    21532160    }
    2154     if (target.sectionId==ASMSECT_ABS ||
    2155         assembler.sections[target.sectionId].type!=AsmSectionType::CODE)
    2156     {
    2157         assembler.printError(expr->getSourcePos(), "Can't resolve expression outside "
    2158                 "code section");
    2159         return false;
    2160     }
    2161     const Array<AsmExprOp>& ops = expr->getOps();
    2162    
    2163     size_t relOpStart = 0;
    2164     size_t relOpEnd = ops.size();
    2165     RelocType relType = RELTYPE_LOW_32BIT;
    2166     // checking what is expression
    2167     // get () OP () - operator between two parts
    2168     AsmExprOp lastOp = ops.back();
    2169     if (lastOp==AsmExprOp::BIT_AND || lastOp==AsmExprOp::MODULO ||
    2170         lastOp==AsmExprOp::SIGNED_MODULO || lastOp==AsmExprOp::DIVISION ||
    2171         lastOp==AsmExprOp::SIGNED_DIVISION || lastOp==AsmExprOp::SHIFT_RIGHT)
    2172     {
    2173         // check low or high relocation
    2174         relOpStart = 0;
    2175         relOpEnd = expr->toTop(ops.size()-2);
    2176         /// evaluate second argument
    2177         cxuint tmpSectionId;
    2178         uint64_t secondArg;
    2179         if (!expr->evaluate(assembler, relOpEnd, ops.size()-1, secondArg, tmpSectionId))
    2180             return false;
    2181         if (tmpSectionId!=ASMSECT_ABS)
    2182         {
    2183             // must be absolute
    2184             assembler.printError(expr->getSourcePos(),
    2185                         "Second argument for relocation operand must be absolute");
    2186             return false;
    2187         }
    2188         bool good = true;
    2189         switch (lastOp)
    2190         {
    2191             case AsmExprOp::BIT_AND:
    2192                 // handle (x&0xffffffff)
    2193                 relType = RELTYPE_LOW_32BIT;
    2194                 good = ((secondArg & 0xffffffffULL) == 0xffffffffULL);
    2195                 break;
    2196             case AsmExprOp::MODULO:
    2197             case AsmExprOp::SIGNED_MODULO:
    2198                 // handle (x%0x100000000)
    2199                 relType = RELTYPE_LOW_32BIT;
    2200                 good = ((secondArg>>32)!=0 && (secondArg & 0xffffffffULL) == 0);
    2201                 break;
    2202             case AsmExprOp::DIVISION:
    2203             case AsmExprOp::SIGNED_DIVISION:
    2204                 // handle (x/0x100000000)
    2205                 relType = RELTYPE_HIGH_32BIT;
    2206                 good = (secondArg == 0x100000000ULL);
    2207                 break;
    2208             case AsmExprOp::SHIFT_RIGHT:
    2209                 // handle (x>>32)
    2210                 relType = RELTYPE_HIGH_32BIT;
    2211                 good = (secondArg == 32);
    2212                 break;
    2213             default:
    2214                 break;
    2215         }
    2216         if (!good)
    2217         {
    2218             assembler.printError(expr->getSourcePos(),
    2219                         "Can't resolve relocation for this expression");
    2220             return false;
    2221         }
    2222     }
    2223     //
    2224     cxuint relSectionId = 0;
    2225     uint64_t relValue = 0;
    2226     if (expr->evaluate(assembler, relOpStart, relOpEnd, relValue, relSectionId))
    2227     {
    2228         // relocation only for rodata, data and bss section
    2229         if (relSectionId!=rodataSection && relSectionId!=dataSection &&
    2230             relSectionId!=bssSection)
    2231         {
    2232             assembler.printError(expr->getSourcePos(),
    2233                      "Section of this expression must be a global data, rwdata or bss");
    2234             return false;
    2235         }
    2236         outSectionId = ASMSECT_ABS;   // for filling values in code
    2237         outValue = 0x55555555U; // for filling values in code
    2238         size_t extraOffset = (tgtType!=ASMXTGT_DATA32) ? 4 : 0;
    2239         AsmRelocation reloc = { target.sectionId, target.offset+extraOffset, relType };
    2240         // set up relocation (relSectionId, addend)
    2241         reloc.relSectionId = relSectionId;
    2242         reloc.addend = relValue;
    2243         assembler.relocations.push_back(reloc);
    2244         return true;
    2245     }
    2246     return false;
     2161    outSectionId = ASMSECT_ABS;   // for filling values in code
     2162    outValue = 0x55555555U; // for filling values in code
     2163    size_t extraOffset = (tgtType!=ASMXTGT_DATA32) ? 4 : 0;
     2164    AsmRelocation reloc = { target.sectionId, target.offset+extraOffset, relType };
     2165    // set up relocation (relSectionId, addend)
     2166    reloc.relSectionId = relSectionId;
     2167    reloc.addend = relValue;
     2168    assembler.relocations.push_back(reloc);
     2169    return true;
    22472170}
    22482171
  • CLRadeonExtender/trunk/amdasm/AsmFormats.cpp

    r3425 r3562  
    7878}
    7979
     80bool AsmFormatHandler::resolveLoHiRelocExpression(const AsmExpression* expr,
     81                RelocType& relType, cxuint& relSectionId, uint64_t& relValue)
     82{
     83    const AsmExprTarget& target = expr->getTarget();
     84    const AsmExprTargetType tgtType = target.type;
     85    if ((tgtType!=ASMXTGT_DATA32 &&
     86        !assembler.isaAssembler->relocationIsFit(32, tgtType)))
     87    {
     88        assembler.printError(expr->getSourcePos(),
     89                        "Can't resolve expression for non 32-bit integer");
     90        return false;
     91    }
     92    if (target.sectionId==ASMSECT_ABS ||
     93        assembler.sections[target.sectionId].type!=AsmSectionType::CODE)
     94    {
     95        assembler.printError(expr->getSourcePos(), "Can't resolve expression outside "
     96                "code section");
     97        return false;
     98    }
     99    const Array<AsmExprOp>& ops = expr->getOps();
     100   
     101    size_t relOpStart = 0;
     102    size_t relOpEnd = ops.size();
     103    relType = RELTYPE_LOW_32BIT;
     104    // checking what is expression
     105    // get () OP () - operator between two parts
     106    AsmExprOp lastOp = ops.back();
     107    if (lastOp==AsmExprOp::BIT_AND || lastOp==AsmExprOp::MODULO ||
     108        lastOp==AsmExprOp::SIGNED_MODULO || lastOp==AsmExprOp::DIVISION ||
     109        lastOp==AsmExprOp::SIGNED_DIVISION || lastOp==AsmExprOp::SHIFT_RIGHT)
     110    {
     111        // check low or high relocation
     112        relOpStart = 0;
     113        relOpEnd = expr->toTop(ops.size()-2);
     114        /// evaluate second argument
     115        cxuint tmpSectionId;
     116        uint64_t secondArg;
     117        if (!expr->evaluate(assembler, relOpEnd, ops.size()-1, secondArg, tmpSectionId))
     118            return false;
     119        if (tmpSectionId!=ASMSECT_ABS)
     120        {
     121            // must be absolute
     122            assembler.printError(expr->getSourcePos(),
     123                        "Second argument for relocation operand must be absolute");
     124            return false;
     125        }
     126        bool good = true;
     127        switch (lastOp)
     128        {
     129            case AsmExprOp::BIT_AND:
     130                // handle (x&0xffffffff)
     131                relType = RELTYPE_LOW_32BIT;
     132                good = ((secondArg & 0xffffffffULL) == 0xffffffffULL);
     133                break;
     134            case AsmExprOp::MODULO:
     135            case AsmExprOp::SIGNED_MODULO:
     136                // handle (x%0x100000000)
     137                relType = RELTYPE_LOW_32BIT;
     138                good = ((secondArg>>32)!=0 && (secondArg & 0xffffffffULL) == 0);
     139                break;
     140            case AsmExprOp::DIVISION:
     141            case AsmExprOp::SIGNED_DIVISION:
     142                // handle (x/0x100000000)
     143                relType = RELTYPE_HIGH_32BIT;
     144                good = (secondArg == 0x100000000ULL);
     145                break;
     146            case AsmExprOp::SHIFT_RIGHT:
     147                // handle (x>>32)
     148                relType = RELTYPE_HIGH_32BIT;
     149                good = (secondArg == 32);
     150                break;
     151            default:
     152                break;
     153        }
     154        if (!good)
     155        {
     156            assembler.printError(expr->getSourcePos(),
     157                        "Can't resolve relocation for this expression");
     158            return false;
     159        }
     160    }
     161   
     162    relSectionId = 0;
     163    relValue = 0;
     164    //
     165    return expr->evaluate(assembler, relOpStart, relOpEnd, relValue, relSectionId);
     166}
     167
    80168/* raw code handler */
    81169
  • CLRadeonExtender/trunk/amdasm/AsmGalliumFormat.cpp

    r3560 r3562  
    16991699                    cxuint& outSectionId)
    17001700{
     1701    RelocType relType = RELTYPE_LOW_32BIT;
     1702    cxuint relSectionId = 0;
     1703    uint64_t relValue = 0;
    17011704    const AsmExprTarget& target = expr->getTarget();
    17021705    const AsmExprTargetType tgtType = target.type;
    1703     if ((tgtType!=ASMXTGT_DATA32 &&
    1704         !assembler.isaAssembler->relocationIsFit(32, tgtType)))
     1706    if (!resolveLoHiRelocExpression(expr, relType, relSectionId, relValue))
     1707        return false;
     1708   
     1709    // relocation only for rodata, data and bss section
     1710    if (relSectionId!=scratchSection)
    17051711    {
    17061712        assembler.printError(expr->getSourcePos(),
    1707                         "Can't resolve expression for non 32-bit integer");
     1713                    "Section of this expression must be a scratch");
    17081714        return false;
    17091715    }
    1710     if (target.sectionId==ASMSECT_ABS ||
    1711         assembler.sections[target.sectionId].type!=AsmSectionType::CODE)
    1712     {
    1713         assembler.printError(expr->getSourcePos(), "Can't resolve expression outside "
    1714                 "code section");
     1716    if (relValue != 0)
     1717    {
     1718        assembler.printError(expr->getSourcePos(),
     1719                    "Expression must point to start of section");
    17151720        return false;
    17161721    }
    1717     const Array<AsmExprOp>& ops = expr->getOps();
    1718    
    1719     size_t relOpStart = 0;
    1720     size_t relOpEnd = ops.size();
    1721     RelocType relType = RELTYPE_LOW_32BIT;
    1722     // checking what is expression
    1723     // get () OP () - operator between two parts
    1724     AsmExprOp lastOp = ops.back();
    1725     if (lastOp==AsmExprOp::BIT_AND || lastOp==AsmExprOp::MODULO ||
    1726         lastOp==AsmExprOp::SIGNED_MODULO || lastOp==AsmExprOp::DIVISION ||
    1727         lastOp==AsmExprOp::SIGNED_DIVISION || lastOp==AsmExprOp::SHIFT_RIGHT)
    1728     {
    1729         // check low or high relocation
    1730         relOpStart = 0;
    1731         relOpEnd = expr->toTop(ops.size()-2);
    1732         /// evaluate second argument
    1733         cxuint tmpSectionId;
    1734         uint64_t secondArg;
    1735         if (!expr->evaluate(assembler, relOpEnd, ops.size()-1, secondArg, tmpSectionId))
    1736             return false;
    1737         if (tmpSectionId!=ASMSECT_ABS)
    1738         {
    1739             // must be absolute
    1740             assembler.printError(expr->getSourcePos(),
    1741                         "Second argument for relocation operand must be absolute");
    1742             return false;
    1743         }
    1744         bool good = true;
    1745         switch (lastOp)
    1746         {
    1747             case AsmExprOp::BIT_AND:
    1748                 // handle (x&0xffffffff)
    1749                 relType = RELTYPE_LOW_32BIT;
    1750                 good = ((secondArg & 0xffffffffULL) == 0xffffffffULL);
    1751                 break;
    1752             case AsmExprOp::MODULO:
    1753             case AsmExprOp::SIGNED_MODULO:
    1754                 // handle (x%0x100000000)
    1755                 relType = RELTYPE_LOW_32BIT;
    1756                 good = ((secondArg>>32)!=0 && (secondArg & 0xffffffffULL) == 0);
    1757                 break;
    1758             case AsmExprOp::DIVISION:
    1759             case AsmExprOp::SIGNED_DIVISION:
    1760                 // handle (x/0x100000000)
    1761                 relType = RELTYPE_HIGH_32BIT;
    1762                 good = (secondArg == 0x100000000ULL);
    1763                 break;
    1764             case AsmExprOp::SHIFT_RIGHT:
    1765                 // handle (x>>32)
    1766                 relType = RELTYPE_HIGH_32BIT;
    1767                 good = (secondArg == 32);
    1768                 break;
    1769             default:
    1770                 break;
    1771         }
    1772         if (!good)
    1773         {
    1774             assembler.printError(expr->getSourcePos(),
    1775                         "Can't resolve relocation for this expression");
    1776             return false;
    1777         }
    1778     }
    1779     //
    1780     cxuint relSectionId = 0;
    1781     uint64_t relValue = 0;
    1782     if (expr->evaluate(assembler, relOpStart, relOpEnd, relValue, relSectionId))
    1783     {
    1784         // relocation only for rodata, data and bss section
    1785         if (relSectionId!=scratchSection)
    1786         {
    1787             assembler.printError(expr->getSourcePos(),
    1788                      "Section of this expression must be a scratch");
    1789             return false;
    1790         }
    1791         if (relValue != 0)
    1792         {
    1793             assembler.printError(expr->getSourcePos(),
    1794                      "Expression must point to start of section");
    1795             return false;
    1796         }
    1797         outSectionId = ASMSECT_ABS;   // for filling values in code
    1798         outValue = 4U; // for filling values in code
    1799         size_t extraOffset = (tgtType!=ASMXTGT_DATA32) ? 4 : 0;
    1800         AsmRelocation reloc = { target.sectionId, target.offset+extraOffset, relType };
    1801         // set up relocation (relSectionId, addend)
    1802         reloc.relSectionId = relSectionId;
    1803         reloc.addend = 0;
    1804         assembler.relocations.push_back(reloc);
    1805         return true;
    1806     }
    1807     return false;
     1722    outSectionId = ASMSECT_ABS;   // for filling values in code
     1723    outValue = 4U; // for filling values in code
     1724    size_t extraOffset = (tgtType!=ASMXTGT_DATA32) ? 4 : 0;
     1725    AsmRelocation reloc = { target.sectionId, target.offset+extraOffset, relType };
     1726    // set up relocation (relSectionId, addend)
     1727    reloc.relSectionId = relSectionId;
     1728    reloc.addend = 0;
     1729    assembler.relocations.push_back(reloc);
     1730    return true;;
    18081731}
    18091732
Note: See TracChangeset for help on using the changeset viewer.