Subversion Repositories fpga-cf

options {

 STATIC = false;

}

PARSER_BEGIN(LL_Virtex5)

/*

@LICENSE@

*/

package edu.byu.cc.plieber.fpgaenet.debug.llparse;

import java.lang.*;

import java.util.*;

/**

 * The Xilinx Logical Allocation file (.ll file) parser for Virtex2

 * FPGAs. The parser fills two Hashtable objects with the

 * readback bitstream information for state elements in the Virtex5

 * design.  One Hashtable is filled with RAM bitstream

 * information keyed on physical location (block name) while the

 * second holds the bitstream information for flip-flops keyed on

 * physical location (block name).  The grammar is not published but

 * was developed from looking at the file format.

 *

 * @author Paul Graham

 * @author Peter Lieber */

public class LL_Virtex5 {

  /**

   * A HashTable to allow quick access to {@link

   * RAMGroup} objects based on block name and RAM type. The

   * RAMGroup objects contain {@link RAMRBEntry} objects

   * which hold the actual bitstream offsets.  */

  Hashtable RAMGroupHash;

  /**

   * A Hashtable of {@link LatchRBEntry} objects to allow

   * quick access based on block name and latch type.  The

   * LatchRBEntry is used for flip-flops and stores

   * bitstream offset information. */

  Hashtable NetHashBlock;

  /** The number of nets associated with latches in the .ll file */

  int netCount;

  /** The number of RAM entries in the .ll file */

  int ramCount;

  /**

   * Indicates whether the LL file provides absolute offsets. First

   * needed with the Xilinx 4.1 ISE tools*/

  boolean absOffsets;

  /**

   * Instances and initializes the parser and parses the input from

   * System.in

   *

   * @param args Command line arguments (ignored by the method)

   * */

  public static void main(String args[]) throws ParseException {

    LL_Virtex5 parser = new LL_Virtex5(System.in);

    parser.initTables();

    parser.parseLL();

  }

  /**

   * Initializes the Hashtables and counts.  */

  public void initTables() {

    RAMGroupHash = new Hashtable();

    NetHashBlock = new Hashtable();

    netCount = 0;

    ramCount = 0;

    absOffsets = false;

  }

  /**

   * Returns a reference to the RAMGroupHash, which holds

   * a {@link RAMGroup} object for each RAM in the .ll file keyed on

   * the location of the RAM and the RAM type (F, G, M, or B).

   *

   * @return Reference to RAMGroupHash */

  public Hashtable getRAMGroupHash() {

    return RAMGroupHash;

  }

  /**

   * Returning a reference to the NetHashBlock, which

   * holds a {@link LatchRBEntry} for each flip-flop in the .ll file

   * keyed on the location and the latch type (XQ, YQ, etc.)

   *

   * @return Reference to NetHashBlock */

  public Hashtable getNetHashBlock() {

    return NetHashBlock;

  }

  /**

   * Returns true if the LL file provides absolute offsets and false

   * otherwise.  Absolute readback bitstream offsets started appearing

   * in the Xilinx ISE 4.1i series of tools.

   *

   * @return true if absolute offsets are provide,

   * false otherwise.  */

  public boolean hasAbsoluteOffsets() {

    return absOffsets;

  }

}

PARSER_END(LL_Virtex5)

SKIP :

{

  " "

|

  "\t"

|

  ";" : IN_LINE_COMMENT

}

 SKIP:

{

    "\n" : DEFAULT

}

 MORE:

{

    < ~[] >

}

TOKEN :

{

  < NUM: ( ["0"-"9"] )+ >

|

  < HEXNUM: "0x" ( ["0"-"9","a"-"f","A"-"F"] )+ >

|

  < EQUAL: "=" >

|

  < TYPE : "Type" >

|

  < LUT : ["A","B","C","D"] >

|

  < BLOCKRAM : "B" >

|

  < SLICEBLOCK : "SLICE_X" (["0"-"9"])+ "Y" (["0"-"9"])+ >

|

  < BRAMBLOCK : "RAMB36_X" (["0"-"9"])+ "Y" (["0"-"9"])+ >

|

  < GTPBLOCK : "GTP_DUAL_X" (["0"-"9"])+ "Y" (["0"-"9"])+ >

|

  < DCMBLOCK : "DCM_ADV_X" (["0"-"9"])+ "Y" (["0"-"9"])+ >

|

  < PINBLOCK : ["A"-"Z"] (["A"-"Z"])? ["0"-"9"] (["0"-"9"])? >

|

  < AQ : "AQ">

|

  < BQ : "BQ">

|

  < CQ : "CQ">

|

  < DQ : "DQ">

|

  < Q1 : "Q1">

|

  < Q2 : "Q2">

|

  < I : "I">

|

  < O : "O">

|

  < DO : "DO" ["A","B"] ["0"-"9"] (["0"-"9"])? >

|

  < COLON : ":" >

|

  < LANGLE: "<" >

|

  < RANGLE: ">" >

|

  < LBRACKET: "[" >

|

  < RBRACKET: "]" >

|

  < REVISION : "Revision">

|

  < BIT : "Bit" >

|

  < BLOCK : "Block" >

|

  < LATCH : "Latch" >

|

  < RAM : "Ram" >

|

  < ROM : "Rom" >

|

  < NET: "Net" >

|

  < YES: "YES">

|

  < NO: "NO">

|

  < COMPARE: "COMPARE">

|

  < INFO: "Info">

|

  < ID: ["a"-"z","A"-"Z"] (["a"-"z","A"-"Z","_","/","0"-"9","-",".","$"])* >

|

  < NETEXT: ["/","_"](["a"-"z","A"-"Z","_","/","0"-"9","-","."])+ >

}

/**

 * Defines the various flip-flop types and returns the type as

 * a String.

 *

 * @return String for flip-flop type. */

String LatchType() :

{ }

{

 { return token.toString();}

| { return token.toString();}

| { return token.toString();}

| { return token.toString();}

| { return token.toString();}

| { return token.toString();}

| { return token.toString();}

| { return token.toString();}

}

/**

 * Initiates the parsing of an .ll file and prints out

 * statistics about the number of flip-flops (latches) and RAMs it

 * found.*/

void parseLL() :

{ }

{

  Revision() ( BitStreamEntry() | InfoEntry() )* 

{

  System.out.println("Total Block/Latch Entries: "+

                     Integer.toString(NetHashBlock.size())+ " Total Nets:" +

                     Integer.toString(netCount));

  System.out.println("Number of RAMGroup Entries: "+

                     Integer.toString(RAMGroupHash.size())+

                     " Total RAM entries:" + Integer.toString(ramCount));

  System.out.flush();

}

}

/**

 * Parses the revision information for the .ll file.

 */

void Revision() :

{ }

{

      ("\r" | "\n" | "\r\n")

}

/**

 * Parses the entire clause having the type of the flip-flop and

 * returns the flip-flop type as a String.

 *

 * @return Flip-flop type as String. */

String Latch() :

{ String latchtype; }

{

    latchtype=LatchType() {return latchtype;}

}

/**

 * Parses the net names associated with latches and stores a

 * LatchRBEntry object in the NetHashBlock

 * Hashtable.  The method handles both angle brackets ("<>")

 * and square brackets ("[]") for net names.  In some strange

 * circumstances, it was necessary to handle names which extended

 * beyond the array naming construct (in other words, there was still

 * part of the name after the last "]" or ">").  In these cases, the

 * names are considered atomic (not multi-bit), so the index variable

 * is reset to "-1".

 *

 * @param offset The first offset provided by the LL file for this

 *               flip-flop; it is actually a junk bit in the readback

 *               bitstream.

 *

 * @param frame The frame number for this flip-flops readback data

 *              provided by the LL file.

 *

 * @param frameOffset The offset within the frame for this flip-flop's

 *                    readback data provided by the LL file.

 *

 * @param block The block's name and location.

 *

 * @param latchType The type of the flip-flop.

 **/

void NetName(int offset, int frame, int frameOffset, String block, String latchType) :

{

  String netname;

  int index=-1;

  boolean extended=false;

  LatchRBEntry lrbe;

}

{

   { netname = token.toString();}

[(

   { index = Integer.parseInt(token.toString()); }

  [

   { netname = new String(netname+"<"+Integer.toString(index)+">"+token.toString());

     index = -1;

     extended = true;

   } ]

| 

   { index = Integer.parseInt(token.toString());}

 [

   { netname = new String(netname+"["+Integer.toString(index)+"]"+token.toString());

     index = -1;

     extended = true;

   } ]

)]

 {

        if(!block.equals("DUMMY")) {

          lrbe = new LatchRBEntry(offset,frame,frameOffset,block,latchType,netname,index);

          netCount++;

          NetHashBlock.put(block+latchType, lrbe);

        }

 }

}

/**

 * Parses the entire "Net=..." clause.

 *

 * @param offset The first offset provided by the LL file for this

 *               flip-flop; it is actually a junk bit in the readback

 *               bitstream.

 *

 * @param frame The frame number for this flip-flops readback data

 *              provided by the LL file.

 *

 * @param frameOffset The offset within the frame for this flip-flop's

 *                    readback data provided by the LL file.

 *

 * @param block The block's name and location.

 *

 * @param latchType The type of the flip-flop.

 */

void Net(int offset, int frame, int frameOffset, String block, String latchType) :

{ }

{

    NetName(offset,frame,frameOffset,block,latchType)

}

/**

 * Parses the "Ram=..." clauses of the RAM LL entries for lut rams and enters the

 * data into the RAMGroupHash. Since a certain RAM may

 * already have a RAMGroup entry in the

 * RAMGroupHash, the method performs a lookup first to

 * see if the RAM's RAMGroup entry exists.  If the entry

 * exists, the method adds a RAMRBEntry to the

 * RAMGroup which was found.  Otherwise, the method

 * creates a new RAMGroup and adds an

 * RAMRBEntry to it. This method handles both LUT RAMs

 * and BlockRAMs.

 *

 * @param offset The first offset provided by the LL file for this

 *               flip-flop; it is actually a junk bit in the readback

 *               bitstream.

 *

 * @param frame The frame number for this flip-flops readback data

 *              provided by the LL file.

 *

 * @param frameOffset The offset within the frame for this flip-flop's

 *                    readback data provided by the LL file.

 *

 * @param block The block's name and location.  */

void SliceRam(int offset, int frame, int frameOffset, String block) :

{ String lutType;

  int address;

  RAMGroup rg;

  RAMRBEntry rrb;

  String key;

}

{

   {lutType = token.toString();}

  {

    try {

      address = Integer.parseInt(token.toString());

      rrb = new RAMRBEntry(offset,frame,frameOffset,block,lutType,address);

      ramCount++;

      key = new String(block+"."+lutType);

      rg = (RAMGroup)RAMGroupHash.get(key);

      if(rg == null) {

        RAMGroupHash.put(key,new RAMGroup(rrb));

      }

      else {

        rg.addRAMEntry(rrb);

      }

    }

    catch (RAMTypeException rte) {

      System.out.println("Caught Exception: " + rte.toString());

      System.out.println("Wrong RAM Type: Are you using the proper part type? (Virtex5)");

      rte.printStackTrace();

    }

  }

}

/**

 * Parses the "Ram=..." clauses of the RAM LL entries for BRAMs and enters the

 * data into the RAMGroupHash. Since a certain RAM may

 * already have a RAMGroup entry in the

 * RAMGroupHash, the method performs a lookup first to

 * see if the RAM's RAMGroup entry exists.  If the entry

 * exists, the method adds a RAMRBEntry to the

 * RAMGroup which was found.  Otherwise, the method

 * creates a new RAMGroup and adds an

 * RAMRBEntry to it. This method handles both LUT RAMs

 * and BlockRAMs.

 *

 * @param offset The first offset provided by the LL file for this

 *               flip-flop; it is actually a junk bit in the readback

 *               bitstream.

 *

 * @param frame The frame number for this flip-flops readback data

 *              provided by the LL file.

 *

 * @param frameOffset The offset within the frame for this flip-flop's

 *                    readback data provided by the LL file.

 *

 * @param block The block's name and location.  */

void BRam(int offset, int frame, int frameOffset, String block) :

{ String lutType;

  int address;

  RAMGroup rg;

  RAMRBEntry rrb;

  String key;

}

{

   {lutType = token.toString();}

  {

    try {

      String bitAddress = token.toString();

      // We need to skip the PARBIT prefix used for block ram parity bits

      if( bitAddress.charAt(0) == 'P' )

        address = Integer.parseInt(bitAddress.substring(6));

      // We need to skip the BIT prefix used for block ram data bits

      else

        address = Integer.parseInt(bitAddress.substring(3));

      rrb = new RAMRBEntry(offset,frame,frameOffset,block,lutType,address);

      ramCount++;

      key = new String(block+"."+lutType);

      rg = (RAMGroup)RAMGroupHash.get(key);

      if(rg == null) {

        RAMGroupHash.put(key,new RAMGroup(rrb));

      }

      else {

        rg.addRAMEntry(rrb);

      }

    }

    catch (RAMTypeException rte) {

      System.out.println("Caught Exception: " + rte.toString());

      System.out.println("Wrong RAM Type: Are you using the proper part type? (Virtex2, XC4K, etc.)");

      rte.printStackTrace();

    }

  }

}

/**

 * Parses "Rom=..." entries, but doesn't do anything with them.

 */

void Rom() :

{ }

{

}

/**

 * Parses "YES/NO" clauses.

 */

void YesNo():

{ }

{

|

}

/**

 * Parses "COMPARE=..." clauses, which are otherwise ignored.

 */

void Compare() :

{ }

{

    YesNo()

}

/**

 * Parses the "attributes" of a state bit in the readback bitstream,

 * which define whether it belongs to a flip-flop, a RAM, or a ROM and

 * other related information.  This is really the core of the parsing work.

 *

 * @param offset The first offset provided by the LL file for this

 *               flip-flop; it is actually a junk bit in the readback

 *               bitstream.

 *

 * @param frame The frame number for this flip-flops readback data

 *              provided by the LL file.

 *

 * @param frameOffset The offset within the frame for this flip-flop's

 *                    readback data provided by the LL file.

 *

 * @param block The block's name and location.  */

void SliceAttributes(int offset, int frame, int frameOffset, String block) :

{ String latchType;}

{

latchType=Latch() (Net(offset, frame, frameOffset, block, latchType))?  (Compare())?

|

SliceRam(offset,frame,frameOffset,block)  (Compare())?

|

Rom()  (Compare())?

}

/**

 * Parses the "attributes" of a state bit in the readback bitstream,

 * which define whether it belongs to a flip-flop, a RAM, or a ROM and

 * other related information.  This is really the core of the parsing work.

 *

 * @param offset The first offset provided by the LL file for this

 *               flip-flop; it is actually a junk bit in the readback

 *               bitstream.

 *

 * @param frame The frame number for this flip-flops readback data

 *              provided by the LL file.

 *

 * @param frameOffset The offset within the frame for this flip-flop's

 *                    readback data provided by the LL file.

 *

 * @param block The block's name and location.  */

void PinAttributes(int offset, int frame, int frameOffset, String block) :

{ String latchType;}

{

latchType=Latch() (Net(offset, frame, frameOffset, block, latchType))?  (Compare())?

}

/**

 * Parses the "attributes" of a state bit in the readback bitstream,

 * which define whether it belongs to a flip-flop, a RAM, or a ROM and

 * other related information.  This is really the core of the parsing work.

 *

 * @param offset The first offset provided by the LL file for this

 *               flip-flop; it is actually a junk bit in the readback

 *               bitstream.

 *

 * @param frame The frame number for this flip-flops readback data

 *              provided by the LL file.

 *

 * @param frameOffset The offset within the frame for this flip-flop's

 *                    readback data provided by the LL file.

 *

 * @param block The block's name and location.  */

void BramAttributes(int offset, int frame, int frameOffset, String block) :

{ }

{

BRam(offset,frame,frameOffset,block)  (Compare())?

}

/**

 * Parses the information regarding location of the IOB/SLICE/BLOCKRAM

 * and returns the information as a String.

 *

 * @return The Virtex2 block location string (for example, "A21",

 *         "CLB_R8C55", "RAMB4_R7C0").

 **/

String Block(int offset, int frame, int frameOffset) :

{

  String block;

}

{

  (

  {block = token.toString();}

  SliceAttributes(offset,frame,frameOffset,block) ("\r" | "\n" | "\r\n")

|

        {block = token.toString();}

  BramAttributes(offset,frame,frameOffset,block) ("\r" | "\n" | "\r\n")

|

        (  |  )

        {block = token.toString();}

            < ID > ("\r" | "\n" | "\r\n")

|

        {block = token.toString();}

  PinAttributes(offset,frame,frameOffset,block) ("\r" | "\n" | "\r\n")

)
{
   return block;

 }

}

 * element. */

void BitStreamEntry() :

{ int offset,frame,frameOffset;

  String block;

}

{

    {offset = Integer.parseInt(token.toString());}

  ( {frame = Integer.parseInt(token.toString()); }

  | {frame = Integer.decode(token.toString()).intValue(); absOffsets=true;})

   {frameOffset = Integer.parseInt(token.toString()); }

  block = Block(offset, frame, frameOffset)

}

/**

 * file. The information is ignored. */

void InfoValue() :

{ }

{

|

}

/**

 * state elements with readback bitstream locations.  These entries

 * describe some of the bitstream generation options used for the

 * bitstream. */

void InfoEntry() :

{}

{

     InfoValue() ("\r" | "\n" | "\r\n")

}