从 LLVM IR 访问结构成员和结构数组

Question

如果我有一个声明 struct 的 C++ 程序，请说：

struct S {
    short s;
    union U {
        bool b;
        void *v;
    };
    U u;
};

我通过 LLVM C++ API 生成一些 LLVM IR 来镜像 C++ 声明：

vector<Type*> members;
members.push_back( IntegerType::get( ctx, sizeof( short ) * 8 ) );
// since LLVM doesn't support unions, just use an ArrayType that's the same size
members.push_back( ArrayType::get( IntegerType::get( ctx, 8 ), sizeof( S::U ) ) );

StructType *const llvm_S = StructType::create( ctx, "S" );
llvm_S->setBody( members );

如何确保 C++ 代码中的 sizeof(S) 与 LLVM IR 代码中的 StructType 大小相同？单个成员的偏移量相同，即u.b。

这也是我在 C++ 中分配了一个S 数组的情况：

S *s_array = new S[10];

然后我将 s_array 传递给 LLVM IR 代码，在其中我访问数组的各个元素。为了使其正常工作，sizeof(S) 在 C++ 和 LLVM IR 中必须相同，因此：

%elt = getelementptr %S* %ptr_to_start, i64 1

将正确访问s_array[1]。

当我编译并运行下面的程序时，它会输出：

sizeof(S) = 16
allocSize(S) = 10

问题是 LLVM 在 S::s 和 S::u 之间缺少 6 个字节的填充。 C++ 编译器使union 以 8 字节对齐的边界开始，而 LLVM 则没有。

我在玩DataLayout。对于我的机器 [Mac OS X 10.9.5, g++ Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn)]，如果我打印数据布局字符串，我会得到：

e-m:o-i64:64-f80:128-n8:16:32:64-S128

如果我将数据布局强制设置为：

e-m:o-i64:64-f80:128-n8:16:32:64-S128-a:64

其中添加的是a:64，这意味着聚合类型的对象在 64 位边界上对齐，然后我得到 same 大小。那么为什么默认数据布局不正确呢？

---

下面的完整工作程序

// LLVM
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/ExecutionEngine/MCJIT.h>
#include <llvm/IR/DerivedTypes.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/Type.h>
#include <llvm/Support/TargetSelect.h>

// standard
#include <iostream>
#include <memory>
#include <string>

using namespace std;
using namespace llvm;

struct S {
    short s;
    union U {
        bool b;
        void *v;
    };
    U u;
};

ExecutionEngine* createEngine( Module *module ) {
    InitializeNativeTarget();
    InitializeNativeTargetAsmPrinter();

    unique_ptr<Module> u( module );
    EngineBuilder eb( move( u ) );
    string errStr;
    eb.setErrorStr( &errStr );
    eb.setEngineKind( EngineKind::JIT );
    ExecutionEngine *const exec = eb.create();
    if ( !exec ) {
        cerr << "Could not create ExecutionEngine: " << errStr << endl;
        exit( 1 );
    }
    return exec;
}

int main() {
    LLVMContext ctx;

    vector<Type*> members;
    members.push_back( IntegerType::get( ctx, sizeof( short ) * 8 ) );
    members.push_back( ArrayType::get( IntegerType::get( ctx, 8 ), sizeof( S::U ) ) );

    StructType *const llvm_S = StructType::create( ctx, "S" );
    llvm_S->setBody( members );

    Module *const module = new Module( "size_test", ctx );
    ExecutionEngine *const exec = createEngine( module );
    DataLayout const *const layout = exec->getDataLayout();
    module->setDataLayout( layout );

    cout << "sizeof(S) = " << sizeof( S ) << endl;
    cout << "allocSize(S) = " << layout->getTypeAllocSize( llvm_S ) << endl;

    delete exec;
    return 0;
}

Answer 1

由于原始答案是“预编辑”问题的正确答案，因此我正在为新问题编写一个全新的答案（我猜测结构实际上并不相同是非常好的）。

问题不在于DataLayout 本身 [但您将需要 DataLayout 来解决问题，因此您需要在开始制作 LLVM-IR 之前更新代码以创建模块]，但事实上您正在将具有对齐限制的 union 与 struct 中的对齐限制较小的对齐限制相结合：

struct S {
    short s;        // Alignment = 2 
    union U {    
        bool b;     // Alignment = 1
        void *v;    // Alignment = 4 or 8
    };
    U u;            // = Alignment = 4 or 8
};

现在在您的 LLVM 代码生成中：

members.push_back( IntegerType::get( ctx, sizeof( short ) * 8 ) );
members.push_back( ArrayType::get( IntegerType::get( ctx, 8 ), sizeof( S::U ) ) );

结构中的第二个元素是 char dummy[sizeof(S::U)]，其对齐要求为 1。因此，LLVM 对齐 struct 的方式当然不同于具有更严格对齐标准的 C++ 编译器。

在这种特殊情况下，使用i8 *（又名void *）代替i8 的数组可以解决问题[显然使用相关的bitcast 在访问时根据需要转换为其他类型b的值]

要解决这个问题，以一种完全通用的方式，您需要生成一个由union 中具有最大对齐要求的元素组成的struct，然后用足够的char 元素填充它以弥补最大的尺寸。

我现在要吃点东西，但我会用一些代码来正确解决它，但它比我最初想象的要复杂一些。

这是上面发布的 main 修改为使用指针而不是 char 数组：

int main() {
    LLVMContext ctx;

    vector<Type*> members;
    members.push_back( IntegerType::get( ctx, sizeof( short ) * 8 ) );
    members.push_back( PointerType::getUnqual( IntegerType::get( ctx, 8 ) ) );

    StructType *const llvm_S = StructType::create( ctx, "S" );
    llvm_S->setBody( members );

    Module *const module = new Module( "size_test", ctx );
    ExecutionEngine *const exec = createEngine( module );
    DataLayout const *const layout = exec->getDataLayout();
    module->setDataLayout( *layout );

    cout << "sizeof(S) = " << sizeof( S ) << endl;
    cout << "allocSize(S) = " << layout->getTypeAllocSize( llvm_S ) << endl;

    delete exec;
    return 0;
}

还有一些微小的变化来掩盖setDataLayout 在您的 LLVM 版本和我正在使用的版本之间发生变化的事实。

最后是允许使用任何类型的通用版本：

Type* MakeUnionType( Module* module, LLVMContext& ctx, vector<Type*> um )
{
    const DataLayout dl( module );
    size_t maxSize = 0;
    size_t maxAlign = 0;
    Type*  maxAlignTy = 0;

    for( auto m : um )
    {
        size_t sz = dl.getTypeAllocSize( m );
        size_t al = dl.getPrefTypeAlignment( m );
        if( sz > maxSize ) 
            maxSize = sz;
        if( al > maxAlign) 
        {
            maxAlign = al;
            maxAlignTy = m;
        }
    }
    vector<Type*> sv = { maxAlignTy };
    size_t mas = dl.getTypeAllocSize( maxAlignTy );
    if( mas < maxSize )
    {
        size_t n = maxSize - mas;
        sv.push_back(ArrayType::get( IntegerType::get( ctx, 8 ), n ) );
    }
    StructType* u = StructType::create( ctx, "U" );
    u->setBody( sv );
    return u;
}

int main() {
    LLVMContext ctx;

    Module *const module = new Module( "size_test", ctx );
    ExecutionEngine *const exec = createEngine( module );
    DataLayout const *const layout = exec->getDataLayout();
    module->setDataLayout( *layout );

    vector<Type*> members;
    members.push_back( IntegerType::get( ctx, sizeof( short ) * 8 ) );
    vector<Type*> unionMembers = { PointerType::getUnqual( IntegerType::get( ctx, 8 ) ), 
                   IntegerType::get( ctx, 1 )  };
    members.push_back( MakeUnionType( module, ctx, unionMembers ) );

    StructType *const llvm_S = StructType::create( ctx, "S" );
    llvm_S->setBody( members );

    cout << "sizeof(S) = " << sizeof( S ) << endl;
    cout << "allocSize(S) = " << layout->getTypeAllocSize( llvm_S ) << endl;

    delete exec;
    return 0;
}

请注意，在这两种情况下，您都需要一个bitcast 操作来转换b 的地址 - 而在第二种情况下，您还需要一个位转换来将struct 转换为void *，但假设您实际上想要通用的union 支持，无论如何你都必须这样做。

可以在此处找到生成union 类型的完整代码，这是用于我的Pascal 编译器的variant [这是Pascal 制作union 的方式]：

https://github.com/Leporacanthicus/lacsap/blob/master/types.cpp#L525 和代码生成，包括比特广播： https://github.com/Leporacanthicus/lacsap/blob/master/expr.cpp#L520

Answer 2

DataLayout的主要目的是了解元素的对齐方式。如果您不需要知道代码中元素的大小、对齐方式或偏移量[并且 LLVM 除了 GEP 指令之外并没有真正有用的方法来查找偏移量，因此您几乎可以忽略偏移量部分]，您在您从 IR 执行（或生成目标文件）之前，不需要数据布局。

（当我为我的编译器实现 -m32 开关时，我在尝试使用 64 位“本机”数据布局编译 32 位代码时确实遇到了一些非常有趣的错误 - 在中间切换 DataLayout 不是一个好主意编译，我这样做是因为我使用了“默认”文件，然后在创建实际目标文件时设置了一个不同的文件）。