Getting the type of variables and their assignment expression details

[yadu-kr]

Hi Mike,

I have a simple SV model as shown below:

module top
  (
   input wire clk, 
   input wire rstn,
   input wire [31:0] in,
   input wire [31:0] key_in,
   output reg [31:0] out
  );

  reg [31:0] key;
  reg [31:0] sum = 0;
  
  assign key = key_in;

  always
  begin
      sum = key + {in[31], 31'b0};
      out[31:8] = sum[31:8];
	  out[7:0] = in[7:0];
  end
endmodule

After adding the syntax tree to a Compilation object and calling the getRoot() function, I'm using the ASTVisitor with the handle() function to traverse the AST and process the nodes. I want to know how I can get the initialization direction of each VariableSymbol (whether input or output). If they are assigned to a value, I also want to get the symbol it is assigned with.

In the case of the code above, I need to get the assigned symbols key_in (for key), key and in (for sum), and sum and in (for out).

My current Visitor class looks like this:

struct Visitor : public ASTVisitor<Visitor, true, true> {
    
    // Visitor class 

    template<typename T>
    void handle(const T& t) {
        s_term term;
        std::string p;
        if constexpr (std::is_base_of_v<ValueSymbol, T>) {
            t.getHierarchicalPath(p);               // Get the hierarchical path from current symbol to the root node 
            term.name = p;
            auto width = t.getType().bitstreamWidth();
            if(width)
                term.msb = width-1;
            if constexpr (std::is_base_of_v<NetSymbol, T>) {        // If the symbol is a Net, insert Wire as termtype
                term.termtype.insert("Wire");
            }
            else if constexpr (std::is_base_of_v<VariableSymbol, T>) {          // If the symbol is a Variable, insert Reg as termtype
                term.termtype.insert("Reg");
                
            }
                   

              //  PROCESS ASSIGNMENT EXPRESSIONS 

             

            s_terms[p] = term;                  // Add term to map of terms 

        }
        visitDefault(t);
    }
};

It would be helpful if you could give some input. Thanks!

[MikePopoloski]

Given a ValueSymbol, you can loop over the ValueDrivers via the drivers() method to find all of the expressions that drive a value for that symbol. You should be able to visit those expressions and collect all of the symbols that are used within it. You can also use getFirstPortBackref() and walk a linked list of ports that refer to those value symbols to find their directions.

[MikePopoloski]

That's right, currently it does not.

[yadu-kr]

Would that be something that could be included in a future release of slang? Maybe I could try and help with the implementation if required.

[MikePopoloski]

Yes, I think that's a worthwhile feature to add. I generally want to be careful about how much gets added to ValueDriver since there will be many in a large design and it will contribute heavily to memory usage, but adding one more pointer is probably fine.

[yadu-kr]

Understood. Could you point me to where I could start digging around if I wanted to add the feature?

And while on the topic of tracking the driver expressions, would it be possible to get the operators involved in the driving as well? In the example I gave above, I want to get the + operator so that I know sum is the addition of key and the modified in.

[MikePopoloski]

You'd need to add it to the ValueDriver class as a member and then populate it everywhere that the drivers are created.

The thing you would track is an Expression object, which is naturally made up of subexpressions and it would be easy to look at them to know which operators are involved.