llvm dev - May 2019 - How to get CLang array alloca alignments to be smaller than 16 bytes?

I am working on a custom LLVM backend for a 16 bit architecture.

For my architecture, I need smaller array alignments for arrays created on the
stack.

For example, consider the following code at the start of a C function:

  char localBuff[20];
  char localBuff2[6];

this gets converted by Clang into this:

  %localBuff = alloca [20 x i8], align 16
  %localBuff2 = alloca [6 x i8], align 1

Note that char arrays smaller than 16 bytes are specified to be aligned to 1
byte, but bigger ones are aligned to 16 bytes.

On the LLVM backend, this creates bigger than necessary frame index offsets,
which are undesirable for my architecture.

As a side note, my target machine is 16 bits, so I have already modified
‘TargetInfo.ccp' with 16 bit ints and pointers, which works like a charm

  PointerWidth = PointerAlign = 16;
  IntWidth = IntAlign = 16;

The Question is:

- How do I make CLang to emit code with smaller array alignment, say 2 or 4 byte
aligned arrays?
- Otherwise, is there a way to override that alignment on the LLVM backend
implementation, particularly to get it create frame index offsets aligned by a
smaller size, thus ignoring the clang specified alignment?

Joan Lluch


-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20190505/1c60bea2/attachment.html>

Hi Joan,

On Sun, 5 May 2019 at 17:09, Joan Lluch via llvm-dev
<llvm-dev at lists.llvm.org> wrote:
> this gets converted by Clang into this:
>
>   %localBuff = alloca [20 x i8], align 16
>   %localBuff2 = alloca [6 x i8], align 1
Is that when Clang is compiling for your target, or maybe you copied
x86 code into your target?

Because this ought to be controlled by "LargeArrayMinSize" and
"LargeArrayAlign" in lib/Basic/Targets/XYZ.cpp, and only x86 and
WebAssembly seem to set the value to 16. The default never increases
the alignment as far as I can tell.
> - Otherwise, is there a way to override that alignment on the LLVM backend
implementation, particularly to get it create frame index offsets aligned by a
smaller size, thus ignoring the clang specified alignment?
I don't think it's the kind of thing you can (or should) override in
the backend. Other bits of code could have been relying on it from the
start (e.g. to store 3 bits of whatever in the low part of a pointer),
and earlier optimizations might have made even more assumptions based
on that value.

Cheers.

Tim.

Hi Tim,

I have implemented all the steps to register a target backend for LLVM and so
far I’m doing ok with it, but I do not know how to select a particular target on
Clang. I just modified the “TargetInfo.cpp” file as I posted on my previous
email to get 16 bit ints. So, any more insights will be appreciated.

On the other hand I’m unable to find LargeArrayMinSize in any project files (not
even in lib/Basic/Targets/X86.cpp) and  LargeArrayAlign is only in TargetInfo.h
and TargetInfo.cpp which is set to a value of 0 (Zero)

I'm on version 7.0.1,

What am I missing?

Joan Lluch

Tel: 620 28 45 13
> On 5 May 2019, at 18:22, Tim Northover <t.p.northover at gmail.com
<mailto:t.p.northover at gmail.com>> wrote:
> 
> Hi Joan,
> 
> On Sun, 5 May 2019 at 17:09, Joan Lluch via llvm-dev
> <llvm-dev at lists.llvm.org <mailto:llvm-dev at
lists.llvm.org>> wrote:
>> this gets converted by Clang into this:
>> 
>>  %localBuff = alloca [20 x i8], align 16
>>  %localBuff2 = alloca [6 x i8], align 1
> 
> Is that when Clang is compiling for your target, or maybe you copied
> x86 code into your target?
> 
> Because this ought to be controlled by "LargeArrayMinSize" and
> "LargeArrayAlign" in lib/Basic/Targets/XYZ.cpp, and only x86 and
> WebAssembly seem to set the value to 16. The default never increases
> the alignment as far as I can tell.
> 
>> - Otherwise, is there a way to override that alignment on the LLVM
backend implementation, particularly to get it create frame index offsets
aligned by a smaller size, thus ignoring the clang specified alignment?
> 
> I don't think it's the kind of thing you can (or should) override
in
> the backend. Other bits of code could have been relying on it from the
> start (e.g. to store 3 bits of whatever in the low part of a pointer),
> and earlier optimizations might have made even more assumptions based
> on that value.
> 
> Cheers.
> 
> Tim.
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20190505/97c06d53/attachment.html>

(Adding llvm-dev back in, in case someone else searches with similar
questions; though cfe-dev might be better for these issues).

On Sun, 5 May 2019 at 17:54, Joan Lluch <joan.lluch at icloud.com>
wrote:
> I have implemented all the steps to register a target backend for LLVM and
so far I’m doing ok with it, but I do not know how to select a particular target
on Clang. I just modified the “TargetInfo.cpp” file as I posted on my previous
email to get 16 bit ints. So, any more insights will be appreciated.
There are probably about 5-10 different places that need at least
basic modification for a new target in Clang. It's something done
pretty rarely so there's not really any documentation, I'd suggest
grepping the source for an existing target (e.g. aarch64) and
copy/pasting that with modifications for yours.

This will mostly involve creating a few new subclasses for your
target, and telling generic clang code about them in one or two spots,
but I'm afraid I don't recall exact files & lines.

If you can run "clang -target myarch-none-elf" and get a Module
targeting your CPU (i.e. with the correct "target triple" and
"datalayout") that's a good first step. At some point you'll
want to
actually think about the ABI decisions you've made and perhaps modify
them (like this array issue), but to begin with you can leave it as
is.
> On the other hand I’m unable to find LargeArrayMinSize in any project files
(not even in lib/Basic/Targets/X86.cpp)
Sorry, I think that may actually be "LargeArrayMinWidth". I
investigated on a different computer to where I typed up my first
reply so didn't have the exact text on screen.
>  LargeArrayAlign is only in TargetInfo.h and TargetInfo.cpp which is set to
a value of 0 (Zero)
The default is set to 0 in TargetInfo.cpp, but I see it overridden in
X86.h, even in the 7.0 branch (again, typo in my original comment,
where I said .cpp). You'll be creating the equivalent file as part of
adding support to Clang for your target.

Cheers.

Tim.

Hi Tim,

I appreciate your reply, but I can’t still find any relation with
“LargeArrayMinWidth” and x86 target. This variable is only in the TargetInfo.cpp
and TargetInfo.h files and it’s not even in any x86 related file. I think there
should be something else that causes my issue. I have my backend very advanced
and already producing good assembly code, but this supposedly simple thing has
got me stuck. Are you sure there’s nothing else beyond LargeArrayMinWidth that
causes this?

John 

Tel: 620 28 45 13
> On 5 May 2019, at 19:07, Tim Northover <t.p.northover at gmail.com>
wrote:
> 
> (Adding llvm-dev back in, in case someone else searches with similar
> questions; though cfe-dev might be better for these issues).
> 
> On Sun, 5 May 2019 at 17:54, Joan Lluch <joan.lluch at icloud.com>
wrote:
>> I have implemented all the steps to register a target backend for LLVM
and so far I’m doing ok with it, but I do not know how to select a particular
target on Clang. I just modified the “TargetInfo.cpp” file as I posted on my
previous email to get 16 bit ints. So, any more insights will be appreciated.
> 
> There are probably about 5-10 different places that need at least
> basic modification for a new target in Clang. It's something done
> pretty rarely so there's not really any documentation, I'd suggest
> grepping the source for an existing target (e.g. aarch64) and
> copy/pasting that with modifications for yours.
> 
> This will mostly involve creating a few new subclasses for your
> target, and telling generic clang code about them in one or two spots,
> but I'm afraid I don't recall exact files & lines.
> 
> If you can run "clang -target myarch-none-elf" and get a Module
> targeting your CPU (i.e. with the correct "target triple" and
> "datalayout") that's a good first step. At some point
you'll want to
> actually think about the ABI decisions you've made and perhaps modify
> them (like this array issue), but to begin with you can leave it as
> is.
> 
>> On the other hand I’m unable to find LargeArrayMinSize in any project
files (not even in lib/Basic/Targets/X86.cpp)
> 
> Sorry, I think that may actually be "LargeArrayMinWidth". I
> investigated on a different computer to where I typed up my first
> reply so didn't have the exact text on screen.
> 
>> LargeArrayAlign is only in TargetInfo.h and TargetInfo.cpp which is set
to a value of 0 (Zero)
> 
> The default is set to 0 in TargetInfo.cpp, but I see it overridden in
> X86.h, even in the 7.0 branch (again, typo in my original comment,
> where I said .cpp). You'll be creating the equivalent file as part of
> adding support to Clang for your target.
> 
> Cheers.
> 
> Tim.
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20190505/7b920f7f/attachment.html>