thr3ads.net - llvm dev - [llvm-dev] Code generation option for wide integers on x86

If this information is useful, please help other people find it:
Share via:

Riyaz Puthiyapurayil via llvm-dev

2020-Aug-17 18:53 UTC

[llvm-dev] Code generation option for wide integers on x86_64?

Is there an existing option in X86_64 target code generator to emit a loop for
the following code:

define i4096 @add(i4096 %a, i4096 %b) alwaysinline {
    %c = add i4096 %a, %b
    ret i4096 %c
}

instead of:

     movq %rdi, %rax
     addq 96(%rsp), %rsi
     adcq 104(%rsp), %rdx
     movq %rdx, 8(%rdi)
     movq %rsi, (%rdi)
     adcq 112(%rsp), %rcx
     movq %rcx, 16(%rdi)
     adcq 120(%rsp), %r8
     movq %r8, 24(%rdi)
     adcq 128(%rsp), %r9
     movq %r9, 32(%rdi)
     movq 8(%rsp), %rcx
     adcq 136(%rsp), %rcx
     movq %rcx, 40(%rdi)
     movq 16(%rsp), %rcx
           :
     :
     :

What is the best strategy for lowering wide integer types/operations on x86_64
without causing code blow up? Should we the code run through a custom pass that
replaces wide operations with a library function call (or alternatively a loop)
before code generation? Is there any existing code that can be reused?

Is there any documentation that describe strategies for lowering from languages
that support arbitrarily wide integers?

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

Eli Friedman via llvm-dev

2020-Aug-17 19:08 UTC

head link

[llvm-dev] Code generation option for wide integers on x86_64?

If you're dealing with integers that wide, I'd recommend avoiding the
builtin IR integers.  There are dedicated libraries for wide integers; the most
well-known is probably GMP.

-Eli

From: llvm-dev <llvm-dev-bounces at lists.llvm.org> On Behalf Of Riyaz
Puthiyapurayil via llvm-dev
Sent: Monday, August 17, 2020 11:54 AM
To: llvm-dev <llvm-dev at lists.llvm.org>
Subject: [EXT] [llvm-dev] Code generation option for wide integers on x86_64?

Is there an existing option in X86_64 target code generator to emit a loop for
the following code:

define i4096 @add(i4096 %a, i4096 %b) alwaysinline {
    %c = add i4096 %a, %b
    ret i4096 %c
}

instead of:

     movq %rdi, %rax
     addq 96(%rsp), %rsi
     adcq 104(%rsp), %rdx
     movq %rdx, 8(%rdi)
     movq %rsi, (%rdi)
     adcq 112(%rsp), %rcx
     movq %rcx, 16(%rdi)
     adcq 120(%rsp), %r8
     movq %r8, 24(%rdi)
     adcq 128(%rsp), %r9
     movq %r9, 32(%rdi)
     movq 8(%rsp), %rcx
     adcq 136(%rsp), %rcx
     movq %rcx, 40(%rdi)
     movq 16(%rsp), %rcx
           :
     :
     :

What is the best strategy for lowering wide integer types/operations on x86_64
without causing code blow up? Should we the code run through a custom pass that
replaces wide operations with a library function call (or alternatively a loop)
before code generation? Is there any existing code that can be reused?

Is there any documentation that describe strategies for lowering from languages
that support arbitrarily wide integers?

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

Philip Reames via llvm-dev

2020-Aug-17 20:01 UTC

head link

[llvm-dev] Code generation option for wide integers on x86_64?

I'll comment that I'd love to see someone improve LLVM's lowering
for
wide integers, but this definitely falls into the "interesting
project"
camp, not the "fastest way to make progress" camp.

Philip

On 8/17/20 12:08 PM, Eli Friedman via llvm-dev wrote:>
> If you’re dealing with integers that wide, I’d recommend avoiding the 
> builtin IR integers.  There are dedicated libraries for wide integers; 
> the most well-known is probably GMP.
>
> -Eli
>
> *From:* llvm-dev <llvm-dev-bounces at lists.llvm.org> *On Behalf Of 
> *Riyaz Puthiyapurayil via llvm-dev
> *Sent:* Monday, August 17, 2020 11:54 AM
> *To:* llvm-dev <llvm-dev at lists.llvm.org>
> *Subject:* [EXT] [llvm-dev] Code generation option for wide integers 
> on x86_64?
>
> Is there an existing option in X86_64 target code generator to emit a 
> loop for the following code:
>
> define i4096 @add(i4096 %a, i4096 %b) *alwaysinline* {
>
>     %c = add i4096 %a, %b
>
>     ret i4096 %c
>
> }
>
> instead of:
>
>      movq %rdi, %rax
>
>      addq 96(%rsp), %rsi
>
>      adcq 104(%rsp), %rdx
>
>      movq %rdx, 8(%rdi)
>
>      movq %rsi, (%rdi)
>
>      adcq 112(%rsp), %rcx
>
>      movq %rcx, 16(%rdi)
>
>      adcq 120(%rsp), %r8
>
>      movq %r8, 24(%rdi)
>
>      adcq 128(%rsp), %r9
>
>      movq %r9, 32(%rdi)
>
>      movq 8(%rsp), %rcx
>
>      adcq 136(%rsp), %rcx
>
>      movq %rcx, 40(%rdi)
>
>      movq 16(%rsp), %rcx
>
>            :
>
>      :
>
>      :
>
> What is the best strategy for lowering wide integer types/operations 
> on x86_64 without causing code blow up? Should we the code run through 
> a custom pass that replaces wide operations with a library function 
> call (or alternatively a loop) before code generation? Is there any 
> existing code that can be reused?
>
> Is there any documentation that describe strategies for lowering from 
> languages that support arbitrarily wide integers?
>
>
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> https://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/20200817/890c6d12/attachment.html>

Riyaz Puthiyapurayil via llvm-dev

2020-Aug-17 20:35 UTC

head link

[llvm-dev] Code generation option for wide integers on x86_64?

I do not mind using dedicated libraries for wide integers (in fact, I mentioned
that in my email below).

But the question is whether I should do that when lowering from the front-end
representation to LLVM IR or at first use the LLVM IR integer representation,
run machine independent transformation passes and then prior to running the code
gen passes, convert the wide integers to an alternative representation and
convert all operations on them to library calls?

If latter, how would I go about doing that? Create 'alloca' for the wide
integers, bit cast and store them to stack and call the library functions? I
don't know if there is a way to get rid of unnecessary alloca's. For
example, if these wide integers are already in memory; it is a waste to load
them from memory and copy them to stack; the address of the original location
could be passed to the library.

Or lowering to library calls from the front-end representation, the better
alternative?

/Riyaz

From: Eli Friedman <efriedma at quicinc.com>
Sent: Monday, August 17, 2020 12:08 PM
To: Riyaz Puthiyapurayil <riyaz at synopsys.com>; llvm-dev at
lists.llvm.org
Subject: RE: [llvm-dev] Code generation option for wide integers on x86_64?

If you're dealing with integers that wide, I'd recommend avoiding the
builtin IR integers.  There are dedicated libraries for wide integers; the most
well-known is probably GMP.

-Eli

From: llvm-dev <llvm-dev-bounces at lists.llvm.org<mailto:llvm-dev-bounces
at lists.llvm.org>> On Behalf Of Riyaz Puthiyapurayil via llvm-dev
Sent: Monday, August 17, 2020 11:54 AM
To: llvm-dev <llvm-dev at lists.llvm.org<mailto:llvm-dev at
lists.llvm.org>>
Subject: [EXT] [llvm-dev] Code generation option for wide integers on x86_64?

Is there an existing option in X86_64 target code generator to emit a loop for
the following code:

define i4096 @add(i4096 %a, i4096 %b) alwaysinline {
    %c = add i4096 %a, %b
    ret i4096 %c
}

instead of:

     movq %rdi, %rax
     addq 96(%rsp), %rsi
     adcq 104(%rsp), %rdx
     movq %rdx, 8(%rdi)
     movq %rsi, (%rdi)
     adcq 112(%rsp), %rcx
     movq %rcx, 16(%rdi)
     adcq 120(%rsp), %r8
     movq %r8, 24(%rdi)
     adcq 128(%rsp), %r9
     movq %r9, 32(%rdi)
     movq 8(%rsp), %rcx
     adcq 136(%rsp), %rcx
     movq %rcx, 40(%rdi)
     movq 16(%rsp), %rcx
           :
     :
     :

What is the best strategy for lowering wide integer types/operations on x86_64
without causing code blow up? Should we the code run through a custom pass that
replaces wide operations with a library function call (or alternatively a loop)
before code generation? Is there any existing code that can be reused?

Is there any documentation that describe strategies for lowering from languages
that support arbitrarily wide integers?

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

Apparently Analagous Threads

Search for more reasonably related threads

llvm dev - Aug 2020 - Code generation option for wide integers on x86_64?

[llvm-dev] Code generation option for wide integers on x86_64?

[llvm-dev] Code generation option for wide integers on x86_64?

[llvm-dev] Code generation option for wide integers on x86_64?

[llvm-dev] Code generation option for wide integers on x86_64?

Apparently Analagous Threads