inlineInput.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
bool	findBitstreamSyncSequence (std::ifstream &fin, Endianness e)
bool	findBitstreamSyncWord (std::ifstream &fin, Endianness e)
void	parseBITheader (std::ifstream &fin, Endianness e)
Endianness	parseBitstreamEndianness (std::ifstream &fin)
uint32_t	parseBitstreamIDCODE (std::ifstream &fin, Endianness e)
void	readBitstreamBIN (std::ifstream &fin)
void	readBitstreamBIT (std::ifstream &fin)
void	readBitstreamMain (std::ifstream &fin, Endianness bitstreamFileEndianness)
void	readBitstreamRBD (std::ifstream &fin)
void	readBitstreamRBDMain (std::ifstream &fin, Endianness bitstreamFileEndianness)

Function Documentation

findBitstreamSyncSequence()

bool findBitstreamSyncSequence	(	std::ifstream &	fin,
		Endianness	e
	)

Reads a bitstream header until and including the sync sequence.

• fin input file stream. Moves the stream pointer to after the SYNC command and in a word-aligned position with the following instructions.

Definition at line 154 of file inlineInput.h.

{
    //Follow some 0xFF's and the bus width detection c0nstant "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x44\x00\x22\x11\xBB\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
    //However we don't care about reading those
    for( ; ; ){
        if(!fin.good())
            return false;
        int wordOld4 = FileIO::read32(fin, e);
        int wordOld3 = FileIO::read32(fin, e);
        int wordOld2 = FileIO::read32(fin, e);
        int wordOld1 = FileIO::read32(fin, e);
        int word = FileIO::read32(fin, e);
        if(wordOld4 == 0x000000BB && wordOld3 == 0x11220044 && wordOld2 == 0xFFFFFFFF && wordOld1 == 0xFFFFFFFF && word == XCAP_getSyncInstruction()){
            return true;
        } else
            fin.seekg(-19, std::ios::cur);
    }
    return false; //not going to be reached.
}

References FileIO::read32(), and XCAP_getSyncInstruction().

Referenced by XilinxSeries7::disassemblerToAsm(), XilinxUltraScale::disassemblerToAsm(), XilinxUltraScalePlus::disassemblerToAsm(), parseBitstreamIDCODE(), and readBitstreamMain().

Here is the call graph for this function:

Here is the caller graph for this function:

findBitstreamSyncWord()

bool findBitstreamSyncWord	(	std::ifstream &	fin,
		Endianness	e
	)

Reads a bitstream header until and including the sync command.

• fin input file stream. Moves the stream pointer to after the SYNC command and in a word-aligned position with the following instructions.

Definition at line 131 of file inlineInput.h.

{
    //Follow some 0xFF's and the bus width detection c0nstant "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x44\x00\x22\x11\xBB\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
    //However we don't care about reading those
    for( ; ; ){
        if(!fin.good())
            return false;
        int word = FileIO::read32(fin, e);
        if(word == XCAP_getSyncInstruction()){
            return true;
        } else
            fin.seekg(-3, std::ios::cur);
    }
    return false; //not going to be reached.
}

References FileIO::read32(), and XCAP_getSyncInstruction().

Referenced by XilinxSeries7::disassemblerToAsm(), XilinxUltraScale::disassemblerToAsm(), XilinxUltraScalePlus::disassemblerToAsm(), and readBitstreamMain().

Here is the call graph for this function:

Here is the caller graph for this function:

parseBITheader()

void parseBITheader ( std::ifstream &  fin, Endianness  e  )

inline

Reads and parses .BIT header until and including the sync command. Updates "designName", "partName", "fileDate", "fileTime".

• fin input file stream, which is left at the position following the located sync command.

Definition at line 24 of file inlineInput.h.

{
    //.bit header c0nstant:
    int headerConstTextLength = FileIO::read16(fin, e);
    std::string headerConstText = FileIO::readString(fin, headerConstTextLength, e);
    int headerConstText2Length = FileIO::read16(fin, e);
    std::string headerConstText2 = FileIO::readString(fin, headerConstText2Length, e);
    if((!((9 == headerConstTextLength) && ("\x0F\xF0\x0F\xF0\x0F\xF0\x0F\xF0" == headerConstText) && (1 == headerConstText2Length) && ("a" == headerConstText2))))
        warn(".bit c0nstant header differs from expected.");
    //.bit header vars:
    int headerDesignNameLength = FileIO::read16(fin, e);
    designName = FileIO::readString(fin, headerDesignNameLength, e);
    log("Name of design: " + designName);
    for(int headerDone = 0 ; !headerDone ; ){
        int key = FileIO::readNative8(fin);
        switch(key){
            case 'b': {
                int headerAttrLength = FileIO::read16(fin, e);
                partName = FileIO::readString(fin, headerAttrLength, e);
                log("FPGA part: " + partName);
                break;
            }
            case 'c': {
                int headerAttrLength = FileIO::read16(fin, e);
                fileDate = FileIO::readString(fin, headerAttrLength, e);
                log("Date: " + fileDate);
                break;
            }
            case 'd': {
                int headerAttrLength = FileIO::read16(fin, e);
                fileTime = FileIO::readString(fin, headerAttrLength, e);
                log("Time: " + fileTime);
                break;
            }
            case 'e': {
                headerDone = 1;//last attribute in a .bit header
                int reportedRemainingFileLength = FileIO::read32(fin, e);
                int tmpPos = (int)fin.tellg();
                fin.seekg (0, fin.end);
                int fileSize = (int)fin.tellg();
                fin.seekg (tmpPos, fin.beg);
                if(fileSize != (tmpPos + reportedRemainingFileLength))
                    warn(".bit header contained inaccurate file length field.");
                break;
            }
            default: {
                warn(".bit header contained unknown file field type.");
            }
        }
    }
}

References FileIO::read16(), FileIO::read32(), FileIO::readNative8(), and FileIO::readString().

Referenced by XilinxSeries7::disassemblerBitToAsm(), XilinxUltraScale::disassemblerBitToAsm(), XilinxUltraScalePlus::disassemblerBitToAsm(), and readBitstreamBIT().

Here is the call graph for this function:

Here is the caller graph for this function:

parseBitstreamEndianness()

Endianness parseBitstreamEndianness ( std::ifstream &  fin )

inline

Reads a bitstream header until and including the sync command and returns the file's endianess.

• fin input file stream. Gets fixed back to the original value before leaving this function!

Definition at line 83 of file inlineInput.h.

{
    std::streamoff fileOffset = fin.tellg();
    //Optional bitstream header
    
    //Follow some 0xFF's and the bus width detection c0nstant "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x44\x00\x22\x11\xBB\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
    //However we don't care about reading those
    Endianness returnVal;
    //Find sync
    for(int syncDetectionDone = 0 ; !syncDetectionDone ; ){
        if(!fin.good())
            throw std::runtime_error("Was unable to find input bitstream's SYNC command.");
        int wordOld4 = FileIO::read32(fin, Endianness::NATIVE);
        int wordOld3 = FileIO::read32(fin, Endianness::NATIVE);
        int wordOld2 = FileIO::read32(fin, Endianness::NATIVE);
        int wordOld1 = FileIO::read32(fin, Endianness::NATIVE);
        int word = FileIO::read32(fin, Endianness::NATIVE);
        if(wordOld4 == 0x000000BB && wordOld3 == 0x11220044 && wordOld2 == 0xFFFFFFFF && wordOld1 == 0xFFFFFFFF && word == XCAP_getSyncInstruction()){
            returnVal = Endianness::NATIVE;
            syncDetectionDone++;
        } else if(wordOld4 == (Endian::NativeToBigEndian32(0x000000BB)) && wordOld3 == (Endian::NativeToBigEndian32(0x11220044)) && wordOld2 == 0xFFFFFFFF && wordOld1 == 0xFFFFFFFF && word == (Endian::NativeToBigEndian32(XCAP_getSyncInstruction()))){
            returnVal = Endianness::BE;
            syncDetectionDone++;
        } else if(wordOld4 == (Endian::NativeToLittleEndian32(0x000000BB)) && wordOld3 == (Endian::NativeToLittleEndian32(0x11220044)) && wordOld2 == 0xFFFFFFFF && wordOld1 == 0xFFFFFFFF && word == (Endian::NativeToLittleEndian32(XCAP_getSyncInstruction()))){
            returnVal = Endianness::LE;
            syncDetectionDone++;
        } else if(wordOld4 == (Endian::NativeToBigEndian32(0x000000BB)) && wordOld3 == (Endian::NativeToBigEndian32(0x11220044)) && wordOld2 == 0xFFFFFFFF && wordOld1 == 0xFFFFFFFF && word == (Endian::NativeToBigEndian32(XCAP_getSyncInstruction()))){
            returnVal = Endianness::BE_BS;
            syncDetectionDone++;
        } else if(wordOld4 == Endian::BitSwap32((Endian::NativeToLittleEndian32(0x000000BB))) && wordOld3 == Endian::BitSwap32((Endian::NativeToLittleEndian32(0x11220044))) && wordOld2 == 0xFFFFFFFF && wordOld1 == 0xFFFFFFFF && word == Endian::BitSwap32((Endian::NativeToLittleEndian32(XCAP_getSyncInstruction())))){
            returnVal = Endianness::LE_BS;
            syncDetectionDone++;
        } else
            fin.seekg(-19, std::ios::cur);
    }
    log("Detected file endianess: " + Endian::to_string(returnVal));
    
    fin.seekg(fileOffset, fin.beg);
    return returnVal;
}

References BE, BE_BS, Endian::BitSwap32(), LE, LE_BS, NATIVE, Endian::NativeToBigEndian32(), Endian::NativeToLittleEndian32(), FileIO::read32(), Endian::to_string(), and XCAP_getSyncInstruction().

Referenced by XilinxSeries7::disassemblerBinToAsm(), XilinxUltraScale::disassemblerBinToAsm(), XilinxUltraScalePlus::disassemblerBinToAsm(), XilinxSeries7::disassemblerBitToAsm(), XilinxUltraScale::disassemblerBitToAsm(), XilinxUltraScalePlus::disassemblerBitToAsm(), readBitstreamBIN(), and readBitstreamBIT().

Here is the call graph for this function:

Here is the caller graph for this function:

parseBitstreamIDCODE()

uint32_t parseBitstreamIDCODE ( std::ifstream &  fin, Endianness  e  )

inline

Reads a bitstream until and including the first IDCODE command and returns the first SLRs IDCODE.

• fin input file stream. Gets fixed back to the original value before leaving this function!

Definition at line 181 of file inlineInput.h.

{
    std::streamoff fileOffset = fin.tellg();
    //Optional bitstream header
    findBitstreamSyncSequence(fin, e);
    uint32_t returnVal;
    //Find sync
    for(int syncDetectionDone = 0 ; !syncDetectionDone ; ){
        if(!fin.good())
            throw std::runtime_error("Was unable to find input bitstream's IDCODE command.");
        int word = FileIO::read32(fin, e);
        if(XCAP_IDCODEInstruction() == word){
            returnVal = FileIO::read32(fin, e);
            syncDetectionDone++;
        } else
            fin.seekg(-3, std::ios::cur);
    }
    
    fin.seekg(fileOffset, fin.beg);
    return returnVal;
}

References findBitstreamSyncSequence(), FileIO::read32(), and XCAP_IDCODEInstruction().

Referenced by XilinxSeries7::disassemblerBinToAsm(), XilinxUltraScale::disassemblerBinToAsm(), XilinxUltraScalePlus::disassemblerBinToAsm(), and readBitstreamBIN().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitstreamBIN()

void readBitstreamBIN ( std::ifstream &  fin )

inline

Definition at line 346 of file inlineInput.h.

{
    Endianness bitstreamFileEndianness = parseBitstreamEndianness(fin);
    
    uint32_t idcode = parseBitstreamIDCODE(fin, bitstreamFileEndianness);
    setDeviceByIDCODEOrThrow(idcode);
    ensureInitializedBitstreamArrays();//initialize bitstream arrays before writing
    
    readBitstreamMain(fin, bitstreamFileEndianness);
}

References parseBitstreamEndianness(), parseBitstreamIDCODE(), and readBitstreamMain().

Referenced by XilinxSeries7::readBitstream(), XilinxUltraScale::readBitstream(), and XilinxUltraScalePlus::readBitstream().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitstreamBIT()

void readBitstreamBIT ( std::ifstream &  fin )

inline

Definition at line 334 of file inlineInput.h.

{
    Endianness bitstreamFileEndianness = parseBitstreamEndianness(fin);
    
    parseBITheader(fin, bitstreamFileEndianness);
    setDeviceByPartNameOrThrow();
    ensureInitializedBitstreamArrays();//initialize bitstream arrays before writing
    
    readBitstreamMain(fin, bitstreamFileEndianness);
}

References parseBITheader(), parseBitstreamEndianness(), and readBitstreamMain().

Referenced by XilinxSeries7::readBitstream(), XilinxUltraScale::readBitstream(), and XilinxUltraScalePlus::readBitstream().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitstreamMain()

void readBitstreamMain ( std::ifstream &  fin, Endianness  bitstreamFileEndianness  )

inline

Definition at line 203 of file inlineInput.h.

{
    int slr = 0;
    XCAP::Register regAddr = XCAP::Register::UNDEFINED;
    int wordCount = 0;
    char shadowFrame[WORDS_PER_FRAME*4];
    bool shadowFrameValid = false;
    int b = 7, r = 0, c = 0, m = 0;
    bool aligned = false;
    bool synched = false;
    
    if(bitstreamHasValidData){
        ensureSelectedEndianness(bitstreamFileEndianness);
    }
    loadedBitstreamEndianness = bitstreamFileEndianness;
    //Parse bitstream
    for( ; ; ){
        if(!synched){
            if(!aligned){//if not aligned, we search for the whole sync sequence, otherwise, just the sync word
                if(findBitstreamSyncSequence(fin, loadedBitstreamEndianness)){
                    synched = true;
                    aligned = true;
                } else {
                    break;// done with the bitstream
                }
            } else {
                if(findBitstreamSyncWord(fin, loadedBitstreamEndianness)){
                    synched = true;
                } else {
                    break;// done with the bitstream
                }
            }
        } else {
            uint32_t instruction = FileIO::read32(fin, loadedBitstreamEndianness);
            if(!fin.good()){
                break; // done with the bitstream
            } else {
                int instructionType = XCAP_getInstructionType(instruction);
                XCAP::Operation instructionOPCODE = XCAP_getInstructionOperation(instruction);
                int instructionPayload = XCAP_getInstructionPayload(instruction);
                if(instructionType == 1) {
                    regAddr = XCAP_getInstructionRegister(instruction);
                    wordCount = XCAP_getInstructionWordCount(instruction);
                } else if(instructionType == 2) {
                    wordCount = instructionPayload;
                } else {
                    throw std::runtime_error("Bitstream has invalid instruction (" + std::to_string(instruction) + " @ " + std::to_string(fin.tellg()) + ") (invalid type).");
                }
                if(regAddr == XCAP::Register::MAGIC1){
                    slr++;
                    wordCount = 0;
                    shadowFrameValid = false;
                    synched = false;    //TODO: do this recursively and not rely on large continous blocks of MAGIC1 command
                    aligned = false;
                }
                if(instructionOPCODE == XCAP::Operation::WRITE){ //Write register
                    for( ; wordCount > 0 ; ){
                        if(regAddr == XCAP::Register::FAR){
                            uint32_t farValue = FileIO::read32(fin, loadedBitstreamEndianness);
                            wordCount--;
                            XCAP_parseFAR(farValue, slr, b, r, c, m);
                            /*
                            if(shadowFrameValid){
                                if(b == BLOCKTYPE_LOGIC){
                                    memcpy(&bitstreamCLB[r][c][m*WORDS_PER_FRAME], &shadowFrame, WORDS_PER_FRAME*4);
                                } else if(b == BLOCKTYPE_BLOCKRAM) {
                                    memcpy(&bitstreamBRAM[r][c][m*WORDS_PER_FRAME], &shadowFrame, WORDS_PER_FRAME*4);
                                }
                                XCAP_IncrementFAR(slr, b, r, c, m);
                                shadowFrameValid = false;
                            }
                            */
                        } else if(regAddr == XCAP::Register::FDRI){
                            if(wordCount % WORDS_PER_FRAME != 0)
                                throw std::runtime_error("FDRI write of a partial frame was detected, which is currently not supported.");
                            if(shadowFrameValid){
                                throwingAssert(b, <, BLOCKTYPE_MAX);
                                throwingAssertPrintVar_1(r, >=, SLRinfo[slr].fromRow, slr);
                                throwingAssertPrintVar_1(r, <=, SLRinfo[slr].toRow, slr);
                                throwingAssertPrintVar_1(c, <, numberOfCols[r], r);
                                if(b == BLOCKTYPE_LOGIC){
                                    throwingAssertPrintVar_3(m, <, LUT_numberOfFramesForResourceLetter[(uint8_t)resourceString[r][c]], r, c, (int)resourceString[r][c]);
                                    memcpy(&bitstreamCLB[r][c][m*WORDS_PER_FRAME], &shadowFrame, WORDS_PER_FRAME*4);
                                } else if(b == BLOCKTYPE_BLOCKRAM) {
                                    throwingAssert(m, <, FRAMES_PER_BRAM_CONTENT_COLUMN);
                                    memcpy(&bitstreamBRAM[r][c][m*WORDS_PER_FRAME], &shadowFrame, WORDS_PER_FRAME*4);
                                } else {
                                    warn("Unknown BlockType(" + std::to_string(b) + ") written while reading bitstream file.");
                                }
                                XCAP_IncrementFAR(slr, b, r, c, m);
                            }
                            int forwardShadowReg = (wordCount/WORDS_PER_FRAME) - 1;//skip shadow reg for certain number of frames
                            if(forwardShadowReg > 0){
                                if(b == BLOCKTYPE_LOGIC){ // CLB
                                    fin.read((char*)&bitstreamCLB[r][c][m*WORDS_PER_FRAME], forwardShadowReg * WORDS_PER_FRAME * 4);
                                } else if(b == BLOCKTYPE_BLOCKRAM){
                                    fin.read((char*)&bitstreamBRAM[r][c][m*WORDS_PER_FRAME], forwardShadowReg * WORDS_PER_FRAME * 4);
                                } else {
                                    fin.ignore(forwardShadowReg * WORDS_PER_FRAME * 4);
                                    warn("Unknown BlockType(" + std::to_string(b) + ") written while reading bitstream file.");
                                }
                                for(int i = 0 ; i < forwardShadowReg ; i++){
                                    XCAP_IncrementFAR(slr, b, r, c, m);
                                }
                            }
                            wordCount -= forwardShadowReg * WORDS_PER_FRAME;
                            shadowFrameValid = true;
                            fin.read((char*)&shadowFrame, WORDS_PER_FRAME*4);
                            wordCount -= WORDS_PER_FRAME;
                        } else if(regAddr == XCAP::Register::CMD){
                            XCAP::Command command = static_cast<XCAP::Command>(FileIO::read32(fin, loadedBitstreamEndianness));
                            wordCount--;
                            if(command == XCAP::Command::WCFG){
                                shadowFrameValid = false;
                            }
                            if(command == XCAP::Command::DESYNC){
                                synched = false;//but aligned remains true
                                shadowFrameValid = false;
                            }
                        } else {
                            uint32_t scrap = FileIO::read32(fin, loadedBitstreamEndianness);
                            wordCount--;
                        }
                    }//Write register count for loop
                }//Write register instruction
            }// not end of file
        }
    }// for loop parsing the rest of the bitstream
    bitstreamHasValidData = true;
}

References XCAP::CMD, XCAP::DESYNC, ensureSelectedEndianness(), XCAP::FAR, XCAP::FDRI, findBitstreamSyncSequence(), findBitstreamSyncWord(), XCAP::MAGIC1, FileIO::read32(), throwingAssert, throwingAssertPrintVar_1, throwingAssertPrintVar_3, Endian::to_string(), XCAP::UNDEFINED, XCAP::WCFG, XCAP::WRITE, XCAP_getInstructionOperation(), XCAP_getInstructionPayload(), XCAP_getInstructionRegister(), XCAP_getInstructionType(), XCAP_getInstructionWordCount(), XCAP_IncrementFAR(), and XCAP_parseFAR().

Referenced by readBitstreamBIN(), and readBitstreamBIT().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitstreamRBD()

void readBitstreamRBD ( std::ifstream &  fin )

inline

Definition at line 379 of file inlineInput.h.

{
    Endianness bitstreamFileEndianness = Endianness::BE;
    
    ensureInitializedBitstreamArrays();//initialize bitstream arrays before writing
    
    readBitstreamRBDMain(fin, bitstreamFileEndianness);
}

References BE, and readBitstreamRBDMain().

Referenced by XilinxSeries7::readBitstream().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitstreamRBDMain()

void readBitstreamRBDMain ( std::ifstream &  fin, Endianness  bitstreamFileEndianness  )

inline

Definition at line 357 of file inlineInput.h.

{
    //int slr = 0;
    XCAP::Register regAddr = XCAP::Register::UNDEFINED;
    if(bitstreamHasValidData){
        ensureSelectedEndianness(bitstreamFileEndianness);
    }
    loadedBitstreamEndianness = bitstreamFileEndianness;
    //Parse RBD
    std::string str;
    for(int i = 0 ; i < WORDS_PER_FRAME ; i++)//dump first frame.
        std::getline(fin, str);
    uint32_t* fromPtr = bitstreamBegin;
    uint32_t* toPtr = bitstreamEnd;
    for(uint32_t* bitstreamLoc = fromPtr ; bitstreamLoc < toPtr ; bitstreamLoc++){
        std::getline(fin, str);
        uint32_t val = (uint32_t)(std::stoll(str, nullptr, 2) & 0xFFFFFFFF);
        bitstreamLoc[0] = Endian::NativeToAnyEndianness32(val, loadedBitstreamEndianness);
    }
    bitstreamHasValidData = true;
}

References ensureSelectedEndianness(), Endian::NativeToAnyEndianness32(), and XCAP::UNDEFINED.

Referenced by readBitstreamRBD().

Here is the call graph for this function:

Here is the caller graph for this function: