Выравнивание векторов в выводе LLVM amd64

Я пытаюсь использовать векторы внутри структур с LLVM. У меня есть следующее определение C моей структуры:

struct Foo
{
    uint32_t len;
    uint32_t data[32] __attribute__ ((aligned (16)));
};

и вот код LLVM для добавления 42 к элементу номер 3 поля data:

%Foo = type { i32, <32 x i32> }

define void @process(%Foo*) {
_L1:
  %data = getelementptr %Foo* %0, i32 0, i32 1
  %vec = load <32 x i32>* %data
  %x = extractelement <32 x i32> %vec, i32 3
  %xNew = add i32 42, %x
  %vecNew = insertelement <32 x i32> %vec, i32 %xNew, i32 3
  store <32 x i32> %vecNew, <32 x i32>* %data
  ret void
}

Однако вывод llc выглядит так, как если бы векторы должны были быть выровнены по 128 байтам, что кажется расточительным, а также неправильным (векторы AFAIK должны быть выровнены по 16 байтам):

    .file   "process.bc"
    .text
    .globl  process
    .align  16, 0x90
    .type   process,@function
process:                                # @process
.Leh_func_begin0:
# BB#0:                                 # %_L1
    movdqa  128(%rdi), %xmm0
    pextrd  $3, %xmm0, %eax
    addl    $42, %eax
    pinsrd  $3, %eax, %xmm0
    movdqa  %xmm0, 128(%rdi)
    ret
.Ltmp0:
    .size   process, .Ltmp0-process
.Leh_func_end0:

Конечно, если я изменю определение C, чтобы также выровнять поле данных по 128 байтам, это сработает, но потеря 124 байтов (по сравнению с 12 при использовании выравнивания по 16 байтам) кажется неправильной. Так что же здесь происходит?


x86-64 alignment llvm sse
person Cactus    schedule 21.02.2011    source источник
comment
Я только что понял, что 16 байт = 128 бит, так что, возможно, это ошибка LLVM, из-за которой вместо 128 бит он выравнивает векторы по 128 байтам.   -  person Cactus    schedule 21.02.2011

Ответы (1)


arrow_upward
2
arrow_downward

Я думаю, что ваши GEP немного не подходят для лучшего кодегена. Вот некоторый код C, который делает что-то подобное:

#include <stdint.h>

struct Foo
{
  uint32_t len;
  uint32_t data[32] __attribute__ ((aligned (16)));
};

void foo(struct Foo *F)
{
  F->data[3] = 4;
}

который clang превращается в это:

; ModuleID = 'foo.c'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-apple-darwin10.0.0"

%struct.Foo = type { i32, [12 x i8], [32 x i32] }

define void @foo(%struct.Foo* %F) nounwind ssp {
  %1 = alloca %struct.Foo*, align 8
  store %struct.Foo* %F, %struct.Foo** %1, align 8
  %2 = load %struct.Foo** %1, align 8
  %3 = getelementptr inbounds %struct.Foo* %2, i32 0, i32 2
  %4 = getelementptr inbounds [32 x i32]* %3, i32 0, i64 3
  store i32 4, i32* %4
  ret void
}

и соответствующий приятный код, который вы ожидаете:

_foo:                                   ## @foo
Leh_func_begin0:
## BB#0:
    pushq   %rbp
Ltmp0:
    movq    %rsp, %rbp
Ltmp1:
    movl    $4, 28(%rdi)
    popq    %rbp
    ret
Leh_func_end0:

Тем не менее, код, который у вас есть, неверен и должен быть:

_process:                               ## @process
Leh_func_begin1:
## BB#0:                                ## %_L1
        movaps  16(%rdi), %xmm0
        pextrd  $3, %xmm0, %eax
        addl    $42, %eax
        pinsrd  $3, %eax, %xmm0
        movaps  %xmm0, 16(%rdi)
        ret

и еще хуже в ToT, так что отчет об ошибке не будет лишним.

person echristo    schedule 21.03.2011