view ir/irstruct.cpp @ 945:03d7c4aac654

SWITCHED TO LLVM 2.5 ! Applied patch from ticket #129 to compile against latest LLVM. Thanks Frits van Bommel. Fixed implicit return by asm block at the end of a function on x86-32. Other architectures will produce an error at the moment. Adding support for new targets is fairly simple. Fixed return calling convention for complex numbers, ST and ST(1) were switched around. Added some testcases. I've run a dstress test and there are no regressions. However, the runtime does not seem to compile with symbolic debug information. -O3 -release -inline works well and is what I used for the dstress run. Tango does not compile, a small workaround is needed in tango.io.digest.Digest.Digest.hexDigest. See ticket #206 .
author Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
date Sun, 08 Feb 2009 05:26:54 +0100
parents c62c6936635b
children 1714836f2c0b
line wrap: on
line source
#include "gen/llvm.h"

#include "mtype.h"
#include "aggregate.h"
#include "declaration.h"
#include "init.h"

#include "ir/irstruct.h"
#include "gen/irstate.h"
#include "gen/tollvm.h"
#include "gen/logger.h"
#include "gen/llvmhelpers.h"

IrInterface::IrInterface(BaseClass* b)
:   vtblInitTy(llvm::OpaqueType::get())
{
    base = b;
    decl = b->base;
    vtblInit = NULL;
    vtbl = NULL;
    infoTy = NULL;
    infoInit = NULL;
    info = NULL;

    index = 0;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

IrStruct::IrStruct(AggregateDeclaration* aggr)
:   initOpaque(llvm::OpaqueType::get()),
    classInfoOpaque(llvm::OpaqueType::get()),
    vtblTy(llvm::OpaqueType::get()),
    vtblInitTy(llvm::OpaqueType::get())
{
    aggrdecl = aggr;
    defaultFound = false;
    anon = NULL;
    index = 0;

    type = aggr->type;
    defined = false;
    constinited = false;

    interfaceInfos = NULL;
    vtbl = NULL;
    constVtbl = NULL;

    init = NULL;
    constInit = NULL;

    classInfo = NULL;
    constClassInfo = NULL;
    classInfoDeclared = false;
    classInfoDefined = false;

    packed = false;

    dwarfComposite = NULL;
}

IrStruct::~IrStruct()
{
}

//////////////////////////////////////////

void IrStruct::pushAnon(bool isunion)
{
    anon = new Anon(isunion, anon);
}

//////////////////////////////////////////

void IrStruct::popAnon()
{
    assert(anon);

    const LLType* BT;

    // get the anon type
    if (anon->isunion)
    {
        // get biggest type in block
        const LLType* biggest = getBiggestType(&anon->types[0], anon->types.size());
        std::vector<const LLType*> vec(1, biggest);
        BT = LLStructType::get(vec, aggrdecl->ir.irStruct->packed);
    }
    else
    {
        // build a struct from the types
        BT = LLStructType::get(anon->types, aggrdecl->ir.irStruct->packed);
    }

    // pop anon
    Anon* tmp = anon;
    anon = anon->parent;
    delete tmp;

    // is there a parent anon?
    if (anon)
    {
        // make sure type gets pushed in the anon, not the main
        anon->types.push_back(BT);
        // index is only manipulated at the top level, anons use raw offsets
    }
    // no parent anon, finally add to aggrdecl
    else
    {
        types.push_back(BT);
        // only advance to next position if main is not a union
        if (!aggrdecl->isUnionDeclaration())
        {
            index++;
        }
    }
}

//////////////////////////////////////////

void IrStruct::addVar(VarDeclaration * var)
{
    TypeVector* tvec = &types;
    if (anon)
    {
        // make sure type gets pushed in the anon, not the main
        tvec = &anon->types;

        // set but don't advance index
        var->ir.irField->index = index;

        // set offset in bytes from start of anon block
        var->ir.irField->unionOffset = var->offset - var->offset2;
    }
    else if (aggrdecl->isUnionDeclaration())
    {
        // set but don't advance index
        var->ir.irField->index = index;
    }
    else
    {
        // set and advance index
        var->ir.irField->index = index++;
    }

    // add type
    tvec->push_back(DtoType(var->type));

    // add var
    varDecls.push_back(var);
}

//////////////////////////////////////////

const LLType* IrStruct::build()
{
    // if types is empty, add a byte
    if (types.empty())
    {
        types.push_back(LLType::Int8Ty);
    }

    // union type
    if (aggrdecl->isUnionDeclaration())
    {
        const LLType* biggest = getBiggestType(&types[0], types.size());
        std::vector<const LLType*> vec(1, biggest);
        return LLStructType::get(vec, aggrdecl->ir.irStruct->packed);
    }
    // struct/class type
    else
    {
        return LLStructType::get(types, aggrdecl->ir.irStruct->packed);
    }
}

void addZeros(std::vector<const llvm::Type*>& inits, size_t pos, size_t offset)
{
    assert(offset > pos);
    size_t diff = offset - pos;

    size_t sz;

    do
    {
        if (pos%8 == 0 && diff >= 8)
            sz = 8;
        else if (pos%4 == 0 && diff >= 4)
            sz = 4;
        else if (pos%2 == 0 && diff >= 2)
            sz = 2;
        else // if (pos % 1 == 0)
            sz = 1;
        inits.push_back(LLIntegerType::get(sz*8));
        pos += sz;
        diff -= sz;
    } while (pos < offset);

    assert(pos == offset);
}

void addZeros(std::vector<llvm::Constant*>& inits, size_t pos, size_t offset)
{
    assert(offset > pos);
    size_t diff = offset - pos;

    size_t sz;

    do
    {
        if (pos%8 == 0 && diff >= 8)
            sz = 8;
        else if (pos%4 == 0 && diff >= 4)
            sz = 4;
        else if (pos%2 == 0 && diff >= 2)
            sz = 2;
        else // if (pos % 1 == 0)
            sz = 1;
        inits.push_back(LLConstant::getNullValue(LLIntegerType::get(sz*8)));
        pos += sz;
        diff -= sz;
    } while (pos < offset);

    assert(pos == offset);
}

// FIXME: body is exact copy of above
void addZeros(std::vector<llvm::Value*>& inits, size_t pos, size_t offset)
{
    assert(offset > pos);
    size_t diff = offset - pos;

    size_t sz;

    do
    {
        if (pos%8 == 0 && diff >= 8)
            sz = 8;
        else if (pos%4 == 0 && diff >= 4)
            sz = 4;
        else if (pos%2 == 0 && diff >= 2)
            sz = 2;
        else // if (pos % 1 == 0)
            sz = 1;
        inits.push_back(LLConstant::getNullValue(LLIntegerType::get(sz*8)));
        pos += sz;
        diff -= sz;
    } while (pos < offset);

    assert(pos == offset);
}

void IrStruct::buildDefaultConstInit(std::vector<llvm::Constant*>& inits)
{
    assert(!defaultFound);
    defaultFound = true;

    const llvm::StructType* structtype = isaStruct(aggrdecl->type->ir.type->get());
    Logger::cout() << "struct type: " << *structtype << '\n';

    size_t lastoffset = 0;
    size_t lastsize = 0;

    {
        Logger::println("Find the default fields");
        LOG_SCOPE;

        // go through all vars and find the ones that contribute to the default
        size_t nvars = varDecls.size();
        for (size_t i=0; i<nvars; i++)
        {
            VarDeclaration* var = varDecls[i];

            Logger::println("field %s %s = %s : +%u", var->type->toChars(), var->toChars(), var->init ? var->init->toChars() : var->type->defaultInit(var->loc)->toChars(), var->offset);

            // only add vars that don't overlap
            size_t offset = var->offset;
            size_t size = var->type->size();
            if (offset >= lastoffset+lastsize)
            {
                Logger::println("  added");
                lastoffset = offset;
                lastsize = size;
                defVars.push_back(var);
            }
        }
    }

    {
        Logger::println("Build the default initializer");
        LOG_SCOPE;

        lastoffset = 0;
        lastsize = 0;

        // go through the default vars and build the default constant initializer
        // adding zeros along the way to live up to alignment expectations
        size_t nvars = defVars.size();
        for (size_t i=0; i<nvars; i++)
        {
            VarDeclaration* var = defVars[i];

            Logger::println("field %s %s = %s : +%u", var->type->toChars(), var->toChars(), var->init ? var->init->toChars() : var->type->defaultInit(var->loc)->toChars(), var->offset);

            // get offset and size
            size_t offset = var->offset;
            size_t size = var->type->size();

            // is there space in between last last offset and this one?
            // if so, fill it with zeros
            if (offset > lastoffset+lastsize)
            {
                size_t pos = lastoffset + lastsize;
                addZeros(inits, pos, offset);
            }

            // add the field
            // lazily default initialize
            if (!var->ir.irField->constInit)
                var->ir.irField->constInit = DtoConstInitializer(var->loc, var->type, var->init);
            inits.push_back(var->ir.irField->constInit);

            lastoffset = offset;
            lastsize = var->type->size();
        }

        // there might still be padding after the last one, make sure that is zeroed as well
        // is there space in between last last offset and this one?
        size_t structsize = getTypePaddedSize(structtype);

        if (structsize > lastoffset+lastsize)
        {
            size_t pos = lastoffset + lastsize;
            addZeros(inits, pos, structsize);
        }
    }
}

LLConstant* IrStruct::buildDefaultConstInit()
{
    // doesn't work for classes, they add stuff before and maybe after data fields
    assert(!aggrdecl->isClassDeclaration());

    // initializer llvm constant list
    std::vector<LLConstant*> inits;

    // just start with an empty list
    buildDefaultConstInit(inits);

    // build the constant
    // note that the type matches the initializer, not the aggregate in cases with unions
    LLConstant* c = LLConstantStruct::get(inits, aggrdecl->ir.irStruct->packed);
    Logger::cout() << "llvm constant: " << *c << '\n';
//     assert(0);
    return c;
}