Summary: "rol" in core.bitop
           Product: D
           Version: D2
          Platform: All
        OS/Version: All
            Status: NEW
          Severity: enhancement
          Priority: P2
         Component: DMD

--- Comment #0 from 2011-03-10 14:10:33 PST ---
I'd like the "rol" X86 instrinsic added to core.bitop module.



I'd like the intrinsic because rotating bits in a 32 bit number is a common
enough operation (there was recently a thread in D.learn of a person in need
for the fastest rotation of the bytes of a uint), and in C-derived languages
there isn't a bitwise operator for it, while most CPUs have four or more
instructions to rotate a register.

In C-like languages the problem is sometimes solved making the compiler a bit
smarter, but this little test shows DMD is not able to optimize two shifts plus
or into a single rot instruction:

dmd -O -release -inline test.d

int main(string[] args) {
    uint x = args.length;
    return (x << 24) | (x >> 8);

__Dmain comdat
    mov EAX,4[ESP]
    mov ECX,4[ESP]
    shl EAX,018h
    shr ECX,8
    or  EAX,ECX


Using inline asm is an option:

int main(string[] args) {
    uint x = args.length;
    asm {
        rol x, 8;
    return x;

__Dmain    comdat
    push    EBP
    mov    EBP,ESP
    push    EAX
    mov    EAX,8[EBP]
    mov    -4[EBP],EAX
    rol    -4[EBP],8
    mov    EAX,-4[EBP]
    mov    ESP,EBP
    pop    EBP


But in some cases the inline gives problems, so I think an inlined intrinsic is
more handy, safer, shorter, simpler to use:

union Four {
    uint u;
    ubyte[4] a;
void main() {
    Four f;
    asm {
        rol f.u, 8;

test.d(8): bad type/size of operands 'f.u'


Note: an alternative to the intrinsic is to introduce in D/DMD a standard
syntax for inlined asm expressions using __asm(), as present in LDC, but they
are quite less easy to use than a rot() function-like intrinsic (but they are
much more useful than a single intrinsic):

Configure issuemail:
------- You are receiving this mail because: -------

Reply via email to