• State Resolved
  • Locked Locked
  • Replies 7 replies
  • Subscribers 55 subscribers
  • Views 570 views
  • Users 0 members are here
Support feedback
Options
Options
Related

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

Compiler/DRA80M: CGT Compiler Options

Rishabh Garg
Guru 55685 points

Part Number: DRA80M

Tool/software: TI C/C++ Compiler

Hi,

Below options are present in our makerules:

-oe
--inline_recursion_limit=20

But I can't find their exact meanings either using armcl help or armlnk help.

I am using CGT 16.9.2.LTS and building for R5F.

Regards,

Rishabh

  • 0
    TI__Guru**** 249980 points

    The option -oe embeds the i-code in the object file.  Please trust me when I say it is not worth understanding what that means.  Just use --opt_level=4 instead.  It solves the same problem much more cleanly.  And it is documented.

    The option --inline_recursion_limit=number states how many calls levels deep a particular function may go and still be inlined.  20 is an unusually high number.  In practice, I would expect very few functions to go that deep.  The net effect, is that, with regard to call depth, almost all functions are eligible for inlining.  This option is no longer documented.  The compiler still accepts it.  But I'm not sure whether it actually does anything.  I'll check and get back to you.

    Thanks and regards,

    -George

  • 0 in reply to George Mock
    TI__Expert 4930 points

    --inline_recursion_limit has no effect on ARM releases of that vintage or newer.

  • 0 in reply to pf
    Guru 26200 points

    Hello PF,

    just to confirm,
    does it mean no limits in inline nesting?

  • 0 in reply to pf
    TI__Guru 55685 points
    Hi George/PF,

    If --inline_recursion_limit has no effect then how many calls levels a particular function can go?

    Regards,
    Rishabh
  • 0 in reply to Rishabh Garg
    Guru 26200 points
    According to my experience,
    till stack overflow.
  • 0 in reply to Tomasz Kocon
    TI__Guru 55685 points

    Tom/George/PF,

    Thanks for the support.

    Regards,
    Rishabh

  • 0 in reply to Tomasz Kocon
    TI__Expert 4930 points

    No specific limit, no.  Nested calls are subject to the same heuristics as other potentially-inlined calls:  does inlining it seem to improve speed, is the size increase within the limit for that --opt_for_speed level, might this call blow up the compiler?

    Inline nesting tends to increase size, giving a loose limit that way, but if you had a chain of calls that somehow did not increase size, it could go quite deep.  Note that recursive functions are not inlined;  if a chain of calls forms a recursion, one of them will be flagged to not inline.