llvm dev - Sep 2016 - RFC: Adding Register Calling Convention Support

Hi All,

The Register Calling Convention (RegCall) was introduced by Intel to optimize
parameter transfer on function call.
This calling convention ensures that as many values as possible are passed or
returned in registers.

To use RegCall, place the keyword before a function declaration. For example:
__regcall int foo (int i, int j); // Windows OS
__attribute__((regcall)) foo (int I, int j); // Linux OS and Mac OS X)

The calling convention is described in more details here:
https://software.intel.com/en-us/node/693069

We are adding support for RegCall calling convention for Clang and LLVM IR.
The first step will include the implementation for LLVM IR.

I will appreciate your comments.

Thanks,
Oren

---------------------------------------------------------------------
Intel Israel (74) Limited

This e-mail and any attachments may contain confidential material for
the sole use of the intended recipient(s). Any review or distribution
by others is strictly prohibited. If you are not the intended
recipient, please contact the sender and delete all copies.
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160922/42d306e3/attachment.html>

Seems technically straight forward form the LLVM perspective. The only 
complication is it looks like your callee saved register lists are 
influenced by the number of arguments to the functions. I'm not sure 
that'll be easy to encode with the current infrastructure.

Philip


On 09/22/2016 12:07 AM, Ben Simhon, Oren via llvm-dev
wrote:
>
> Hi All,
>
> The Register Calling Convention (RegCall) was introduced by Intel to 
> optimize parameter transfer on function call.
>
> This calling convention ensures that as many values as possible are 
> passed or returned in registers.
>
> To use RegCall, place the keyword before a function declaration. For 
> example:
>
> /__regcall int foo (int i, int j); // Windows OS/
>
> /__attribute__((regcall)) foo (int I, int j); // Linux OS and Mac OS X)/
>
> The calling convention is described in more details here:
>
> /_https://software.intel.com/en-us/node/693069_/
>
> We are adding support for RegCall calling convention for Clang and 
> LLVM IR.
>
> The first step will include the implementation for LLVM IR.
>
> I will appreciate your comments.
>
> Thanks,
>
> Oren
>
> ---------------------------------------------------------------------
> Intel Israel (74) Limited
>
> This e-mail and any attachments may contain confidential material for
> the sole use of the intended recipient(s). Any review or distribution
> by others is strictly prohibited. If you are not the intended
> recipient, please contact the sender and delete all copies.
>
>
>
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160924/6e94c20a/attachment.html>

Thanks, Philip, for pointing it out.
You are correct. We have a task to add the relevant infrastructure.
Currently registers are statically defined as callee/caller saved.
In order to take into account which registers were passed as parameter we need
to add relevant infrastructure.
Only then LLVM will ensure RegCall cross-compiler Interoperability.

Thanks again,
Oren

From: Philip Reames [mailto:listmail at philipreames.com]
Sent: Sunday, September 25, 2016 02:08
To: Ben Simhon, Oren <oren.ben.simhon at intel.com>; llvm-dev at
lists.llvm.org
Subject: Re: [llvm-dev] RFC: Adding Register Calling Convention Support


Seems technically straight forward form the LLVM perspective.  The only
complication is it looks like your callee saved register lists are influenced by
the number of arguments to the functions.  I'm not sure that'll be easy
to encode with the current infrastructure.

Philip

On 09/22/2016 12:07 AM, Ben Simhon, Oren via llvm-dev wrote:
Hi All,

The Register Calling Convention (RegCall) was introduced by Intel to optimize
parameter transfer on function call.
This calling convention ensures that as many values as possible are passed or
returned in registers.

To use RegCall, place the keyword before a function declaration. For example:
__regcall int foo (int i, int j); // Windows OS
__attribute__((regcall)) foo (int I, int j); // Linux OS and Mac OS X)

The calling convention is described in more details here:
https://software.intel.com/en-us/node/693069

We are adding support for RegCall calling convention for Clang and LLVM IR.
The first step will include the implementation for LLVM IR.

I will appreciate your comments.

Thanks,
Oren


---------------------------------------------------------------------
Intel Israel (74) Limited

This e-mail and any attachments may contain confidential material for
the sole use of the intended recipient(s). Any review or distribution
by others is strictly prohibited. If you are not the intended
recipient, please contact the sender and delete all copies.




_______________________________________________

LLVM Developers mailing list

llvm-dev at lists.llvm.org<mailto:llvm-dev at lists.llvm.org>

http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev

---------------------------------------------------------------------
Intel Israel (74) Limited

This e-mail and any attachments may contain confidential material for
the sole use of the intended recipient(s). Any review or distribution
by others is strictly prohibited. If you are not the intended
recipient, please contact the sender and delete all copies.
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160926/f945eefe/attachment.html>