ADE Assembler: variable values with leading zeros interpreted as octal in ICADVM20.1

Dear dontpanic,

dontpanic said:

We recently switched to ICADVM20.1 and started to get weird results in many old testbenches. After a close lookup, it turns out that all the variables with values starting with zero ("0") are being interpreted as octal!

Yes. It appears this is a known issue as detailed in the On-line support article:

Virtuoso Known Problems and Solutions
Product Version ICADVM20.1, March 2021

at URL:

support.cadence.com/.../techpubDocViewerPage

which includes the following:

Problem: Entering leading zeroes in numeric fields results in octal interpretation

Description: If a number is immediately preceded by a zero, SKILL interprets this as an octal number.

Solution: Use the Backspace key to delete the zero before you type a new number.

I don't think the suggested "Solution"  is to your liking though! I am not privy to any potential date for correcting the behavior nor a release in which the known issue will be corrected - sorry!

Shawn

The manual that Shawn mentions isn't strictly speaking related to this issue - it's a general point that numeric fields on forms in Virtuoso will interpret integers as SKILL does, where leading zeros indicate octal. This is not new, and there's nothing that's going to be fixed. In this case, we're talking about global variables in ADE, and the field for these isn't a numeric field, so that manual isn't really relevant here (even though the symptoms are similar).

The problem in this case is that global variables in ADE Explorer/Assembler (and indeed ADE XL) are first evaluated in SKILL to allow complex functions to be used, before passing to the simulator anything else. There have been some changes to this flow recently to try to preserve parameters within such expressions so that they can be swept within an analysis in Spectre, but it's not that change that causes this problem. I checked, and expressions with numbers starting with 0 in global variables have always been treated as octal since IC617 was first released with Assembler (that's when Assembler was first released). I suspect it goes back even further with ADE XL (I did not check that). So this is not new, and I am surprised that you have existing test benches that weren't broken before (maybe they were run in ADE L before? ADE L didn't evaluate any design variables in SKILL and passed the expressions through to the simulator, so that could well be a difference).

I haven't spotted any reports of this being an issue with anybody else (and I can understand why it's a pain), but I can't see any plan to alter this behaviour (it would be quite hard). Potentially I can imagine some SKILL code to fix these automatically would be possible...

Andrew

I remember a similar issue where the ternary operator worked in ADE L, but did not work in ADE XL, Explorer or Assembler. This was fixed eventually, see support.cadence.com/.../ArticleAttachmentPortal

Thank you all for your replies. Interesting situation to say the least! (I wonder about the origins of the idea of using "0" as a prefix for octal--never heard of that before in my entire career!)

I guess we'll have to explore the solution of automatically updating it via skill, but that will be a problem for "future Jorge". For the time being I guess we'll have to update manually on a per-case basis...

Cheers,

Jorge.

Hi Jorge,

The C language also treats literal integers which start with a 0 as octal, so it's not unique to SKILL. Of course, most designers would not necessarily expect this - in the same way that designers get confused by the fact that 1/2 in expressions is 0!

I wrote some code that I think will do the job of the cleanup. Caveat emptor, since I've really not done a huge amount of testing - you might want to try using abCleanOctalLikeNumbersInVars() on an open session or two before trying abRegOctalLikeNumbers() to do it automatically when a maestro view is opened (if you really want that). Hopefully I got the regular expression right!

Regards,

Andrew

/* abCleanOctalLikeNumbers.il

Author     A.D.Beckett
Group      Custom IC (UK), Cadence Design Systems Ltd.
Language   SKILL
Date       Apr 01, 2021 
Modified   
By         

Provide functions to clean up numbers that will be interpreted
in SKILL as octal, even though that wasn't what the designer intended

abCleanOctalLikeNumbersInVars([session]
    cleans up all design and global variables in the given (or current)
    ADE XL/Explorer/Assembler session

abRegCleanOctalLikeNumbers()
    registers a trigger to do the cleanup whenever a maestro or adexl
    view is opened. Use once you're happy it works properly (I
    have only done limited testing)

***************************************************

SCCS Info: @(#) abCleanOctalLikeNumbers.il 04/02/21.10:25:24 1.2

*/

/************************************************************************
*                                                                       *
*                  abCleanOctalLikeNumbers(expression)                  *
*                                                                       *
* Take a string expression, and replace any number that starts with a 0 *
* so that it doesn't start with a number any more. This avoids numbers  *
*              starting with 0 as being treated as octal.               *
*                                                                       *
************************************************************************/

procedure(abCleanOctalLikeNumbers(expression)
    ;--------------------------------------------------------------------
    ; pattern looks for a non-word non-dot character, followed by one 
    ; or more zeros, followed by one or more digits
    ;--------------------------------------------------------------------
    let(((pat pcreCompile("(^|[^\\w.])0+(\\d+)")))
        if(stringp(expression) && pcreExecute(pat expression) then
            pcreReplace(pat expression "\\1\\2" 0)
        else
            expression
        )
    )
)

/***********************************************************************
*                                                                      *
*                abCleanOctalLikeNumbersForHandle(sdb)                 *
*                                                                      *
*   Passed either a handle for the whole view (for global variables)   *
* or for a test (for design variables) and iterates over all variables *
*        and tries cleaning them up to avoid octal-like values         *
*                                                                      *
***********************************************************************/

procedure(abCleanOctalLikeNumbersForHandle(sdb)
    let((var curValue newValue)
        foreach(varName cadr(axlGetVars(sdb))
            var=axlGetVar(sdb varName)
            curValue=axlGetVarValue(var)
            newValue=abCleanOctalLikeNumbers(curValue)
            unless(newValue==curValue
                printf("Changing Expression %s to %s\n" curValue newValue)
                axlPutVar(sdb varName newValue)
            )
        )
        t
    )
)

/***************************************************************
*                                                              *
*           abCleanOctalLikeNumbersInVars([session])           *
*                                                              *
*     Fixes all the octal-like numbers in a given session      *
*                 (defaults to current window)                 *
*                                                              *
***************************************************************/

procedure(abCleanOctalLikeNumbersInVars(
        @optional (session axlGetWindowSession()))
    let((sdb test)
        sdb=axlGetMainSetupDB(session)
        abCleanOctalLikeNumbersForHandle(sdb)
        foreach(testName cadr(axlGetTests(sdb))
            test=axlGetTest(sdb testName)
            abCleanOctalLikeNumbersForHandle(test)
        )
        t
    )
)

/***************************************************************
*                                                              *
*           abRegCleanOctalLikeNumbersInit(session)            *
*                                                              *
*   Registers a trigger to do the cleanup once the UI is up    *
*                                                              *
***************************************************************/

procedure(abRegCleanOctalLikeNumbersInit(session)
    axlSessionConnect(session "postInstall" 'abCleanOctalLikeNumbersInVars)
)

/***************************************************************
*                                                              *
*                 abRegCleanOctalLikeNumbers()                 *
*                                                              *
*   Registers the postInstall trigger at startup of the view   *
*                                                              *
***************************************************************/

procedure(abRegCleanOctalLikeNumbers()
    axlSessionRegisterCreationCallback('abRegCleanOctalLikeNumbersInit)
)

/***************************************************************
*                                                              *
*                abTestCleanOctalLikeNumbers()                 *
*                                                              *
*            Test code to check for a few examples             *
*                                                              *
***************************************************************/

procedure(abTestCleanOctalLikeNumbers()
    assert(abCleanOctalLikeNumbers("0123")=="123")
    assert(abCleanOctalLikeNumbers("(0562+0*012)/073^02")=="(562+0*12)/73^2")
    assert(abCleanOctalLikeNumbers("TRIM_024_VAL+014")=="TRIM_024_VAL+14")
    assert(abCleanOctalLikeNumbers("0.0033")=="0.0033")
    assert(abCleanOctalLikeNumbers("if( 012==12 0515 0632 )")==
        "if( 12==12 515 632 )")
    t
)

Hi Jorge,

I updated the code I posted yesterday - so don't use the code in any email notification from yesterday; use the latest code in the thread above (I replaced it in the post with version 1.2 to avoid having two versions in the thread). I suddenly realised (in the middle of the night, as you do) that it would rather unhelpfully "clean" floating point numbers that had zeros (e.g. "0.0012" would have become "0.12", which is clearly wrong). Hopefully there aren't other issues (other than I know it will still remove leading zeros in numbers inside double quotes within the expression - I decided that was fairly unlikely to happen and probably not worth the complexity of trying to deal with).

Andrew