自学教程：C++ DtoType函数代码示例

DValue *binMin(Loc &loc, Type *type, DValue *lhs, Expression *rhs,               bool loadLhsAfterRhs) {  Type *lhsType = lhs->type->toBasetype();  Type *rhsType = rhs->type->toBasetype();  if (lhsType != rhsType && lhsType->ty == Tpointer && rhsType->isintegral()) {    Logger::println("Subtracting integer from pointer");    return emitPointerOffset(loc, lhs, rhs, true, type, loadLhsAfterRhs);  }  auto rvals = evalSides(lhs, rhs, loadLhsAfterRhs);  if (lhsType->ty == Tpointer && rhsType->ty == Tpointer) {    LLValue *l = DtoRVal(rvals.lhs);    LLValue *r = DtoRVal(rvals.rhs);    LLType *llSizeT = DtoSize_t();    l = gIR->ir->CreatePtrToInt(l, llSizeT);    r = gIR->ir->CreatePtrToInt(r, llSizeT);    LLValue *diff = gIR->ir->CreateSub(l, r);    LLType *llType = DtoType(type);    if (diff->getType() != llType)      diff = gIR->ir->CreateIntToPtr(diff, llType);    return new DImValue(type, diff);  }  if (type->ty == Tnull)    return DtoNullValue(type, loc);  if (type->iscomplex())    return DtoComplexMin(loc, type, rvals.lhs, rvals.rhs);  LLValue *l = DtoRVal(DtoCast(loc, rvals.lhs, type));  LLValue *r = DtoRVal(DtoCast(loc, rvals.rhs, type));  if (auto aa = isAssociativeArrayAndNull(type, l, r))    return aa;  LLValue *res = (type->isfloating() ? gIR->ir->CreateFSub(l, r)                                     : gIR->ir->CreateSub(l, r));  return new DImValue(type, res);}

LLValue* DtoStructEquals(TOK op, DValue* lhs, DValue* rhs){    Type* t = lhs->getType()->toBasetype();    assert(t->ty == Tstruct);    // set predicate    llvm::ICmpInst::Predicate cmpop;    if (op == TOKequal || op == TOKidentity)        cmpop = llvm::ICmpInst::ICMP_EQ;    else        cmpop = llvm::ICmpInst::ICMP_NE;    // empty struct? EQ always true, NE always false    if (static_cast<TypeStruct*>(t)->sym->fields.dim == 0)        return DtoConstBool(cmpop == llvm::ICmpInst::ICMP_EQ);    // call memcmp    size_t sz = getTypePaddedSize(DtoType(t));    LLValue* val = DtoMemCmp(lhs->getRVal(), rhs->getRVal(), DtoConstSize_t(sz));    return gIR->ir->CreateICmp(cmpop, val, LLConstantInt::get(val->getType(), 0, false));}

LLStructType* DtoModuleReferenceType(){    if (gIR->moduleRefType)        return gIR->moduleRefType;    // this is a recursive type so start out with a struct without body    LLStructType* st = LLStructType::create(gIR->context(), "ModuleReference");    // add members    LLType *types[] = {        getPtrToType(st),        DtoType(Module::moduleinfo->type->pointerTo())    };    // resolve type    st->setBody(types);    // done    gIR->moduleRefType = st;    return st;}

LLValue *DtoBinFloatsEquals(Loc &loc, DValue *lhs, DValue *rhs, TOK op) {  LLValue *res = nullptr;  if (op == TOKequal || op == TOKnotequal) {    LLValue *l = DtoRVal(lhs);    LLValue *r = DtoRVal(rhs);    res = (op == TOKequal ? gIR->ir->CreateFCmpOEQ(l, r)                          : gIR->ir->CreateFCmpUNE(l, r));    if (lhs->type->toBasetype()->ty == Tvector) {      res = mergeVectorEquals(res, op);    }  } else {    const auto cmpop =        op == TOKidentity ? llvm::ICmpInst::ICMP_EQ : llvm::ICmpInst::ICMP_NE;    LLValue *sz = DtoConstSize_t(getTypeStoreSize(DtoType(lhs->type)));    LLValue *val = DtoMemCmp(makeLValue(loc, lhs), makeLValue(loc, rhs), sz);    res = gIR->ir->CreateICmp(cmpop, val,                              LLConstantInt::get(val->getType(), 0, false));  }  assert(res);  return res;}

void RTTIBuilder::push_array(llvm::Constant *CI, uint64_t dim, Type *valtype,                             Dsymbol *mangle_sym) {  std::string tmpStr(valtype->arrayOf()->toChars());  tmpStr.erase(remove(tmpStr.begin(), tmpStr.end(), '['), tmpStr.end());  tmpStr.erase(remove(tmpStr.begin(), tmpStr.end(), ']'), tmpStr.end());  tmpStr.append("arr");  std::string initname(mangle_sym ? mangle(mangle_sym) : ".ldc");  initname.append(".rtti.");  initname.append(tmpStr);  initname.append(".data");  const LinkageWithCOMDAT lwc(TYPEINFO_LINKAGE_TYPE, supportsCOMDAT());  auto G = new LLGlobalVariable(gIR->module, CI->getType(), true,                                lwc.first, CI, initname);  setLinkage(lwc, G);  G->setAlignment(DtoAlignment(valtype));  push_array(dim, DtoBitCast(G, DtoType(valtype->pointerTo())));}

llvm::FunctionType* DtoFunctionType(FuncDeclaration* fdecl){    // handle for C vararg intrinsics    if (DtoIsVaIntrinsic(fdecl))        return DtoVaFunctionType(fdecl);    Type *dthis=0, *dnest=0;    if (fdecl->ident == Id::ensure || fdecl->ident == Id::require) {        FuncDeclaration *p = fdecl->parent->isFuncDeclaration();        assert(p);        AggregateDeclaration *ad = p->isMember2();        assert(ad);        dnest = Type::tvoid->pointerTo();    } else    if (fdecl->needThis()) {        if (AggregateDeclaration* ad = fdecl->isMember2()) {            IF_LOG Logger::println("isMember = this is: %s", ad->type->toChars());            dthis = ad->type;            LLType* thisty = DtoType(dthis);            //Logger::cout() << "this llvm type: " << *thisty << '/n';            if (ad->isStructDeclaration())                thisty = getPtrToType(thisty);        }        else {            IF_LOG Logger::println("chars: %s type: %s kind: %s", fdecl->toChars(), fdecl->type->toChars(), fdecl->kind());            llvm_unreachable("needThis, but invalid parent declaration.");        }    }    else if (fdecl->isNested()) {        dnest = Type::tvoid->pointerTo();    }    LLFunctionType* functype = DtoFunctionType(fdecl->type, getIrFunc(fdecl, true)->irFty, dthis, dnest,                                               fdecl->isMain(), fdecl->isCtorDeclaration(),                                               fdecl->llvmInternal == LLVMintrinsic);    return functype;}

void TypeInfoEnumDeclaration::llvmDefine(){    Logger::println("TypeInfoEnumDeclaration::llvmDefine() %s", toChars());    LOG_SCOPE;    RTTIBuilder b(Type::typeinfoenum);    assert(tinfo->ty == Tenum);    TypeEnum *tc = static_cast<TypeEnum *>(tinfo);    EnumDeclaration *sd = tc->sym;    // TypeInfo base    b.push_typeinfo(sd->memtype);    // char[] name    b.push_string(sd->toPrettyChars());    // void[] init    // emit void[] with the default initialier, the array is null if the default    // initializer is zero    if (!sd->defaultval || tinfo->isZeroInit(0))    {        b.push_null_void_array();    }    // otherwise emit a void[] with the default initializer    else    {        LLType* memty = DtoType(sd->memtype);#if DMDV2        LLConstant* C = LLConstantInt::get(memty, sd->defaultval->toInteger(), !isLLVMUnsigned(sd->memtype));#else        LLConstant* C = LLConstantInt::get(memty, sd->defaultval, !isLLVMUnsigned(sd->memtype));#endif        b.push_void_array(C, sd->memtype, sd);    }    // finish    b.finalize(ir.irGlobal);}

LLValue* DtoVirtualFunctionPointer(DValue* inst, FuncDeclaration* fdecl, char* name){    // sanity checks    assert(fdecl->isVirtual());    assert(!fdecl->isFinal());    assert(fdecl->vtblIndex > 0); // 0 is always ClassInfo/Interface*    assert(inst->getType()->toBasetype()->ty == Tclass);    // get instance    LLValue* vthis = inst->getRVal();    if (Logger::enabled())        Logger::cout() << "vthis: " << *vthis << '/n';    LLValue* funcval = vthis;    // get the vtbl for objects    funcval = DtoGEPi(funcval, 0, 0, "tmp");    // load vtbl ptr    funcval = DtoLoad(funcval);    // index vtbl    std::string vtblname = name;    vtblname.append("@vtbl");    funcval = DtoGEPi(funcval, 0, fdecl->vtblIndex, vtblname.c_str());    // load funcptr    funcval = DtoAlignedLoad(funcval);    if (Logger::enabled())        Logger::cout() << "funcval: " << *funcval << '/n';    // cast to final funcptr type    funcval = DtoBitCast(funcval, getPtrToType(DtoType(fdecl->type)));    // postpone naming until after casting to get the name in call instructions    funcval->setName(name);    if (Logger::enabled())        Logger::cout() << "funcval casted: " << *funcval << '/n';    return funcval;}

DValue* DtoCastInterfaceToObject(DValue* val, Type* to){    // call:    // Object _d_toObject(void* p)    llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_d_toObject");    LLFunctionType* funcTy = func->getFunctionType();    // void* p    LLValue* tmp = val->getRVal();    tmp = DtoBitCast(tmp, funcTy->getParamType(0));    // call it    LLValue* ret = gIR->CreateCallOrInvoke(func, tmp, "tmp").getInstruction();    // cast return value    if (to != NULL)        ret = DtoBitCast(ret, DtoType(to));    else        to = ClassDeclaration::object->type;    return new DImValue(to, ret);}

LLStructType* DtoInterfaceInfoType(){    if (gIR->interfaceInfoType)        return gIR->interfaceInfoType;    // build interface info type    LLSmallVector<LLType*, 3> types;    // ClassInfo classinfo    ClassDeclaration* cd2 = ClassDeclaration::classinfo;    DtoResolveClass(cd2);    types.push_back(DtoType(cd2->type));    // void*[] vtbl    LLSmallVector<LLType*, 2> vtbltypes;    vtbltypes.push_back(DtoSize_t());    LLType* byteptrptrty = getPtrToType(getPtrToType(LLType::getInt8Ty(gIR->context())));    vtbltypes.push_back(byteptrptrty);    types.push_back(LLStructType::get(gIR->context(), vtbltypes));    // int offset    types.push_back(LLType::getInt32Ty(gIR->context()));    // create type    gIR->interfaceInfoType = LLStructType::get(gIR->context(), types);    return gIR->interfaceInfoType;}

LLConstant *DtoConstFP(Type *t, longdouble value) {  LLType *llty = DtoType(t);  assert(llty->isFloatingPointTy());  if (llty == LLType::getFloatTy(gIR->context()) ||      llty == LLType::getDoubleTy(gIR->context())) {    return LLConstantFP::get(llty, value);  }  if (llty == LLType::getX86_FP80Ty(gIR->context())) {    uint64_t bits[] = {0, 0};    bits[0] = *reinterpret_cast<uint64_t *>(&value);    bits[1] =        *reinterpret_cast<uint16_t *>(reinterpret_cast<uint64_t *>(&value) + 1);    return LLConstantFP::get(gIR->context(), APFloat(APFloat::x87DoubleExtended,                                                     APInt(80, 2, bits)));  }  if (llty == LLType::getFP128Ty(gIR->context())) {    union {      longdouble ld;      uint64_t bits[2];    } t;    t.ld = value;    return LLConstantFP::get(gIR->context(),                             APFloat(APFloat::IEEEquad, APInt(128, 2, t.bits)));  }  if (llty == LLType::getPPC_FP128Ty(gIR->context())) {    uint64_t bits[] = {0, 0};    bits[0] = *reinterpret_cast<uint64_t *>(&value);    bits[1] =        *reinterpret_cast<uint16_t *>(reinterpret_cast<uint64_t *>(&value) + 1);    return LLConstantFP::get(        gIR->context(), APFloat(APFloat::PPCDoubleDouble, APInt(128, 2, bits)));  }  llvm_unreachable("Unknown floating point type encountered");}

void DtoResolveClass(ClassDeclaration *cd) {  if (cd->ir->isResolved()) {    return;  }  cd->ir->setResolved();  IF_LOG Logger::println("DtoResolveClass(%s): %s", cd->toPrettyChars(),                         cd->loc.toChars());  LOG_SCOPE;  // make sure the base classes are processed first  for (auto bc : *cd->baseclasses) {    DtoResolveClass(bc->sym);  }  // make sure type exists  DtoType(cd->type);  // create IrAggr  IrAggr *irAggr = getIrAggr(cd, true);  // make sure all fields really get their ir field  for (auto vd : cd->fields) {    IF_LOG {      if (isIrFieldCreated(vd)) {        Logger::println("class field already exists");      }    }    getIrField(vd, true);  }  // interface only emit typeinfo and classinfo  if (cd->isInterfaceDeclaration()) {    irAggr->initializeInterface();  }}

IrTypePointer* IrTypePointer::get(Type* dt){    assert(!dt->ctype);    assert((dt->ty == Tpointer || dt->ty == Tnull) && "not pointer/null type");    LLType* elemType;    if (dt->ty == Tnull)    {        elemType = llvm::Type::getInt8Ty(llvm::getGlobalContext());    }    else    {        elemType = i1ToI8(voidToI8(DtoType(dt->nextOf())));        // DtoType could have already created the same type, e.g. for        // dt == Node* in struct Node { Node* n; }.        if (dt->ctype)            return dt->ctype->isPointer();    }    IrTypePointer* t = new IrTypePointer(dt, llvm::PointerType::get(elemType, 0));    dt->ctype = t;    return t;}

DValue* DtoDynamicCastObject(DValue* val, Type* _to){    // call:    // Object _d_dynamic_cast(Object o, ClassInfo c)    ClassDeclaration::object->codegen(Type::sir);    ClassDeclaration::classinfo->codegen(Type::sir);    llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_d_dynamic_cast");    LLFunctionType* funcTy = func->getFunctionType();    std::vector<LLValue*> args;    // Object o    LLValue* obj = val->getRVal();    obj = DtoBitCast(obj, funcTy->getParamType(0));    assert(funcTy->getParamType(0) == obj->getType());    // ClassInfo c    TypeClass* to = static_cast<TypeClass*>(_to->toBasetype());    to->sym->codegen(Type::sir);    LLValue* cinfo = to->sym->ir.irStruct->getClassInfoSymbol();    // unfortunately this is needed as the implementation of object differs somehow from the declaration    // this could happen in user code as well :/    cinfo = DtoBitCast(cinfo, funcTy->getParamType(1));    assert(funcTy->getParamType(1) == cinfo->getType());    // call it    LLValue* ret = gIR->CreateCallOrInvoke2(func, obj, cinfo, "tmp").getInstruction();    // cast return value    ret = DtoBitCast(ret, DtoType(_to));    return new DImValue(_to, ret);}

DValue* DtoNestedVariable(Loc& loc, Type* astype, VarDeclaration* vd, bool byref){    IF_LOG Logger::println("DtoNestedVariable for %s @ %s", vd->toChars(), loc.toChars());    LOG_SCOPE;    ////////////////////////////////////    // Locate context value    Dsymbol* vdparent = vd->toParent2();    assert(vdparent);    IrFunction* irfunc = gIR->func();    // Check whether we can access the needed frame    FuncDeclaration *fd = irfunc->decl;    while (fd != vdparent) {        if (fd->isStatic()) {            error(loc, "function %s cannot access frame of function %s", irfunc->decl->toPrettyChars(), vdparent->toPrettyChars());            return new DVarValue(astype, vd, llvm::UndefValue::get(getPtrToType(DtoType(astype))));        }        fd = getParentFunc(fd, false);        assert(fd);    }    // is the nested variable in this scope?    if (vdparent == irfunc->decl)    {        LLValue* val = vd->ir.getIrValue();        return new DVarValue(astype, vd, val);    }    LLValue *dwarfValue = 0;    std::vector<LLValue*> dwarfAddr;    // get the nested context    LLValue* ctx = 0;    if (irfunc->nestedVar) {        // If this function has its own nested context struct, always load it.        ctx = irfunc->nestedVar;        dwarfValue = ctx;    } else if (irfunc->decl->isMember2()) {        // If this is a member function of a nested class without its own        // context, load the vthis member.        AggregateDeclaration* cd = irfunc->decl->isMember2();        LLValue* val = irfunc->thisArg;        if (cd->isClassDeclaration())            val = DtoLoad(val);        ctx = DtoLoad(DtoGEPi(val, 0, cd->vthis->ir.irField->index, ".vthis"));    } else {        // Otherwise, this is a simple nested function, load from the context        // argument.        ctx = DtoLoad(irfunc->nestArg);        dwarfValue = irfunc->nestArg;        if (global.params.symdebug)            gIR->DBuilder.OpDeref(dwarfAddr);    }    assert(ctx);    DtoCreateNestedContextType(vdparent->isFuncDeclaration());    assert(vd->ir.irLocal);    ////////////////////////////////////    // Extract variable from nested context    LLValue* val = DtoBitCast(ctx, LLPointerType::getUnqual(irfunc->frameType));    IF_LOG {        Logger::cout() << "Context: " << *val << '/n';        Logger::cout() << "of type: " << *irfunc->frameType << '/n';    }    unsigned vardepth = vd->ir.irLocal->nestedDepth;    unsigned funcdepth = irfunc->depth;    IF_LOG {        Logger::cout() << "Variable: " << vd->toChars() << '/n';        Logger::cout() << "Variable depth: " << vardepth << '/n';        Logger::cout() << "Function: " << irfunc->decl->toChars() << '/n';        Logger::cout() << "Function depth: " << funcdepth << '/n';    }    if (vardepth == funcdepth) {        // This is not always handled above because functions without        // variables accessed by nested functions don't create new frames.        IF_LOG Logger::println("Same depth");    } else {        // Load frame pointer and index that...        if (dwarfValue && global.params.symdebug) {            gIR->DBuilder.OpOffset(dwarfAddr, val, vd->ir.irLocal->nestedDepth);            gIR->DBuilder.OpDeref(dwarfAddr);        }        IF_LOG Logger::println("Lower depth");        val = DtoGEPi(val, 0, vd->ir.irLocal->nestedDepth);        IF_LOG Logger::cout() << "Frame index: " << *val << '/n';        val = DtoAlignedLoad(val, (std::string(".frame.") + vdparent->toChars()).c_str());        IF_LOG Logger::cout() << "Frame: " << *val << '/n';    }    int idx = vd->ir.irLocal->nestedIndex;    assert(idx != -1 && "Nested context not yet resolved for variable.");//.........这里部分代码省略.........

//.........这里部分代码省略.........                if (v_begin >= f_end || v_end <= f_begin)                    continue;                overlaps = true;                break;            }        }        // if no overlap was found, add the default initializer        if (!overlaps)        {            IF_LOG Logger::println("adding default initializer for struct field %s",                field_it->toChars());            data[field_it.index] = *field_it;        }    }    // ok. now we can build a list of llvm types. and make sure zeros are inserted if necessary.    // first we sort the list by offset    std::sort(data.begin(), data.end(), var_offset_sort_cb);    // add types to list    for (size_t i = 0; i < n; i++)    {        VarDeclaration* vd = data[i];        if (vd == NULL)            continue;        assert(vd->offset >= offset && "it's a bug... most likely DMD bug 2481");        // add to default field list        if (cd == base)            default_fields.push_back(vd);        // get next aligned offset for this type        size_t alignedoffset = realignOffset(offset, vd->type);        // insert explicit padding?        if (alignedoffset < vd->offset)        {            field_index += add_zeros(defaultTypes, vd->offset - alignedoffset);        }        // add default type        defaultTypes.push_back(DtoType(vd->type));        // advance offset to right past this field        offset = vd->offset + vd->type->size();        // create ir field        vd->aggrIndex = (unsigned)field_index;        ++field_index;    }    // any interface implementations?    if (base->vtblInterfaces && base->vtblInterfaces->dim > 0)    {        bool new_instances = (base == cd);        ArrayIter<BaseClass> it2(*base->vtblInterfaces);        VarDeclarationIter interfaces_idx(ClassDeclaration::classinfo->fields, 3);	Type* first = interfaces_idx->type->nextOf()->pointerTo();        // align offset        offset = (offset + PTRSIZE - 1) & ~(PTRSIZE - 1);        for (; !it2.done(); it2.next())        {            BaseClass* b = it2.get();            IF_LOG Logger::println("Adding interface vtbl for %s", b->base->toPrettyChars());            FuncDeclarations arr;            b->fillVtbl(cd, &arr, new_instances);            llvm::Type* ivtbl_type = llvm::StructType::get(gIR->context(), buildVtblType(first, &arr));            defaultTypes.push_back(llvm::PointerType::get(ivtbl_type, 0));            offset += PTRSIZE;            // add to the interface map            addInterfaceToMap(b->base, field_index);            field_index++;            // inc count            num_interface_vtbls++;        }    }#if 0    // tail padding?    if (offset < base->structsize)    {        field_index += add_zeros(defaultTypes, base->structsize - offset);        offset = base->structsize;    }#endif}

IRLandingPadInfo::IRLandingPadInfo(Catch* catchstmt, llvm::BasicBlock* end): finallyBody(NULL){    target = llvm::BasicBlock::Create(gIR->context(), "catch", gIR->topfunc(), end);    gIR->scope() = IRScope(target,end);    // assign storage to catch var    if(catchstmt->var) {        // use the same storage for all exceptions that are not accessed in        // nested functions    #if DMDV2        if(!catchstmt->var->nestedrefs.dim) {    #else        if(!catchstmt->var->nestedref) {    #endif            assert(!catchstmt->var->ir.irLocal);            catchstmt->var->ir.irLocal = new IrLocal(catchstmt->var);            LLValue* catch_var = gIR->func()->gen->landingPadInfo.getExceptionStorage();            catchstmt->var->ir.irLocal->value = gIR->ir->CreateBitCast(catch_var, getPtrToType(DtoType(catchstmt->var->type)));        }        // this will alloca if we haven't already and take care of nested refs        DtoDeclarationExp(catchstmt->var);        // the exception will only be stored in catch_var. copy it over if necessary        if(catchstmt->var->ir.irLocal->value != gIR->func()->gen->landingPadInfo.getExceptionStorage()) {            LLValue* exc = gIR->ir->CreateBitCast(DtoLoad(gIR->func()->gen->landingPadInfo.getExceptionStorage()), DtoType(catchstmt->var->type));            DtoStore(exc, catchstmt->var->ir.irLocal->value);        }    }    // emit handler, if there is one    // handler is zero for instance for 'catch { debug foo(); }'    if(catchstmt->handler)        catchstmt->handler->toIR(gIR);    if (!gIR->scopereturned())        gIR->ir->CreateBr(end);    assert(catchstmt->type);    catchType = catchstmt->type->toBasetype()->isClassHandle();    assert(catchType);    catchType->codegen(Type::sir);}IRLandingPadInfo::IRLandingPadInfo(Statement* finallystmt): target(NULL), finallyBody(finallystmt), catchType(NULL){}void IRLandingPad::addCatch(Catch* catchstmt, llvm::BasicBlock* end){    unpushed_infos.push_front(IRLandingPadInfo(catchstmt, end));}

DValue* DtoNewClass(Loc& loc, TypeClass* tc, NewExp* newexp){    // resolve type    DtoResolveClass(tc->sym);    // allocate    LLValue* mem;    if (newexp->onstack)    {        // FIXME align scope class to its largest member        mem = DtoRawAlloca(DtoType(tc)->getContainedType(0), 0, ".newclass_alloca");    }    // custom allocator    else if (newexp->allocator)    {        DtoResolveFunction(newexp->allocator);        DFuncValue dfn(newexp->allocator, getIrFunc(newexp->allocator)->func);        DValue* res = DtoCallFunction(newexp->loc, NULL, &dfn, newexp->newargs);        mem = DtoBitCast(res->getRVal(), DtoType(tc), ".newclass_custom");    }    // default allocator    else    {        llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_newclass");        LLConstant* ci = DtoBitCast(getIrAggr(tc->sym)->getClassInfoSymbol(), DtoType(Type::typeinfoclass->type));        mem = gIR->CreateCallOrInvoke(fn, ci, ".newclass_gc_alloc").getInstruction();        mem = DtoBitCast(mem, DtoType(tc), ".newclass_gc");    }    // init    DtoInitClass(tc, mem);    // init inner-class outer reference    if (newexp->thisexp)    {        Logger::println("Resolving outer class");        LOG_SCOPE;        DValue* thisval = toElem(newexp->thisexp);        unsigned idx = getFieldGEPIndex(tc->sym, tc->sym->vthis);        LLValue* src = thisval->getRVal();        LLValue* dst = DtoGEPi(mem, 0, idx);        IF_LOG Logger::cout() << "dst: " << *dst << "/nsrc: " << *src << '/n';        DtoStore(src, DtoBitCast(dst, getPtrToType(src->getType())));    }    // set the context for nested classes    else if (tc->sym->isNested() && tc->sym->vthis)    {        DtoResolveNestedContext(loc, tc->sym, mem);    }    // call constructor    if (newexp->member)    {        Logger::println("Calling constructor");        assert(newexp->arguments != NULL);        DtoResolveFunction(newexp->member);        DFuncValue dfn(newexp->member, getIrFunc(newexp->member)->func, mem);        return DtoCallFunction(newexp->loc, tc, &dfn, newexp->arguments);    }    // return default constructed class    return new DImValue(tc, mem);}

DValue *DtoAAIndex(Loc &loc, Type *type, DValue *aa, DValue *key, bool lvalue) {  // D2:  // call:  // extern(C) void* _aaGetY(AA* aa, TypeInfo aati, size_t valuesize, void*  // pkey)  // or  // extern(C) void* _aaInX(AA aa*, TypeInfo keyti, void* pkey)  // first get the runtime function  llvm::Function *func = getRuntimeFunction(      loc, gIR->module, lvalue ? "_aaGetY" : "_aaInX");  LLFunctionType *funcTy = func->getFunctionType();  // aa param  LLValue *aaval = lvalue ? aa->getLVal() : aa->getRVal();  aaval = DtoBitCast(aaval, funcTy->getParamType(0));  // pkey param  LLValue *pkey = makeLValue(loc, key);  pkey = DtoBitCast(pkey, funcTy->getParamType(lvalue ? 3 : 2));  // call runtime  LLValue *ret;  if (lvalue) {    LLValue *rawAATI =        DtoTypeInfoOf(aa->type->unSharedOf()->mutableOf(), false);    LLValue *castedAATI = DtoBitCast(rawAATI, funcTy->getParamType(1));    LLValue *valsize = DtoConstSize_t(getTypePaddedSize(DtoType(type)));    ret = gIR->CreateCallOrInvoke(func, aaval, castedAATI, valsize, pkey,                                  "aa.index")              .getInstruction();  } else {    LLValue *keyti = DtoBitCast(to_keyti(aa), funcTy->getParamType(1));    ret = gIR->CreateCallOrInvoke(func, aaval, keyti, pkey, "aa.index")              .getInstruction();  }  // cast return value  LLType *targettype = DtoPtrToType(type);  if (ret->getType() != targettype) {    ret = DtoBitCast(ret, targettype);  }  // Only check bounds for rvalues ('aa[key]').  // Lvalue use ('aa[key] = value') auto-adds an element.  if (!lvalue && gIR->emitArrayBoundsChecks()) {    llvm::BasicBlock *failbb = llvm::BasicBlock::Create(        gIR->context(), "aaboundscheckfail", gIR->topfunc());    llvm::BasicBlock *okbb =        llvm::BasicBlock::Create(gIR->context(), "aaboundsok", gIR->topfunc());    LLValue *nullaa = LLConstant::getNullValue(ret->getType());    LLValue *cond = gIR->ir->CreateICmpNE(nullaa, ret, "aaboundscheck");    gIR->ir->CreateCondBr(cond, okbb, failbb);    // set up failbb to call the array bounds error runtime function    gIR->scope() = IRScope(failbb);    llvm::Function *errorfn =        getRuntimeFunction(loc, gIR->module, "_d_arraybounds");    gIR->CreateCallOrInvoke(        errorfn, DtoModuleFileName(gIR->func()->decl->getModule(), loc),        DtoConstUint(loc.linnum));    // the function does not return    gIR->ir->CreateUnreachable();    // if ok, proceed in okbb    gIR->scope() = IRScope(okbb);  }  return new DVarValue(type, ret);}

void IRLandingPad::constructLandingPad(llvm::BasicBlock* inBB){    // save and rewrite scope    IRScope savedscope = gIR->scope();    gIR->scope() = IRScope(inBB,savedscope.end);    // personality fn    llvm::Function* personality_fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_eh_personality");    // create landingpad    LLType *retType = LLStructType::get(LLType::getInt8PtrTy(gIR->context()), LLType::getInt32Ty(gIR->context()), NULL);    llvm::LandingPadInst *landingPad = gIR->ir->CreateLandingPad(retType, personality_fn, 0);    LLValue* eh_ptr = DtoExtractValue(landingPad, 0);    LLValue* eh_sel = DtoExtractValue(landingPad, 1);    // add landingpad clauses, emit finallys and 'if' chain to catch the exception    llvm::Function* eh_typeid_for_fn = GET_INTRINSIC_DECL(eh_typeid_for);    std::deque<IRLandingPadInfo> infos = this->infos;    std::stack<size_t> nInfos = this->nInfos;    std::deque<IRLandingPadInfo>::reverse_iterator rit, rend = infos.rend();    bool isFirstCatch = true;    for(rit = infos.rbegin(); rit != rend; ++rit)    {        // if it's a finally, emit its code        if(rit->finallyBody)        {            size_t n = this->nInfos.top();            this->infos.resize(n);            this->nInfos.pop();            rit->finallyBody->toIR(gIR);            landingPad->setCleanup(true);        }        // otherwise it's a catch and we'll add a if-statement        else        {            // if it is a first catch and some catch allocated storage, store exception object            if(isFirstCatch && catch_var)            {                LLType* objectTy = DtoType(ClassDeclaration::object->type);                gIR->ir->CreateStore(gIR->ir->CreateBitCast(eh_ptr, objectTy), catch_var);                isFirstCatch = false;            }            // create next block            llvm::BasicBlock *next = llvm::BasicBlock::Create(gIR->context(), "eh.next", gIR->topfunc(), gIR->scopeend());            // get class info symbol            LLValue *classInfo = rit->catchType->ir.irStruct->getClassInfoSymbol();            // add that symbol as landing pad clause            landingPad->addClause(classInfo);            // call llvm.eh.typeid.for to get class info index in the exception table            classInfo = DtoBitCast(classInfo, getPtrToType(DtoType(Type::tint8)));            LLValue *eh_id = gIR->ir->CreateCall(eh_typeid_for_fn, classInfo);            // check exception selector (eh_sel) against the class info index            gIR->ir->CreateCondBr(gIR->ir->CreateICmpEQ(eh_sel, eh_id), rit->target, next);            gIR->scope() = IRScope(next, gIR->scopeend());        }    }    // restore landing pad infos    this->infos = infos;    this->nInfos = nInfos;    // no catch matched and all finallys executed - resume unwind    llvm::Function* unwind_resume_fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_eh_resume_unwind");    gIR->ir->CreateCall(unwind_resume_fn, eh_ptr);    gIR->ir->CreateUnreachable();    // restore scope    gIR->scope() = savedscope;}

LLConstant * IrStruct::getVtblInit(){    if (constVtbl)        return constVtbl;    IF_LOG Logger::println("Building vtbl initializer");    LOG_SCOPE;    ClassDeclaration* cd = aggrdecl->isClassDeclaration();    assert(cd && "not class");    std::vector<llvm::Constant*> constants;    constants.reserve(cd->vtbl.dim);    // start with the classinfo    llvm::Constant* c = getClassInfoSymbol();    c = DtoBitCast(c, DtoType(ClassDeclaration::classinfo->type));    constants.push_back(c);    // add virtual function pointers    size_t n = cd->vtbl.dim;    for (size_t i = 1; i < n; i++)    {        Dsymbol* dsym = static_cast<Dsymbol*>(cd->vtbl.data[i]);        assert(dsym && "null vtbl member");        FuncDeclaration* fd = dsym->isFuncDeclaration();        assert(fd && "vtbl entry not a function");        if (cd->isAbstract() || (fd->isAbstract() && !fd->fbody))        {            c = getNullValue(DtoType(fd->type->pointerTo()));        }        else        {            fd->codegen(Type::sir);            assert(fd->ir.irFunc && "invalid vtbl function");            c = fd->ir.irFunc->func;#if DMDV2            if (cd->isFuncHidden(fd))            {   /* fd is hidden from the view of this class.                 * If fd overlaps with any function in the vtbl[], then                 * issue 'hidden' error.                 */                for (size_t j = 1; j < n; j++)                {   if (j == i)                        continue;                    FuncDeclaration *fd2 = static_cast<Dsymbol *>(cd->vtbl.data[j])->isFuncDeclaration();                    if (!fd2->ident->equals(fd->ident))                        continue;                    if (fd->leastAsSpecialized(fd2) || fd2->leastAsSpecialized(fd))                    {                        if (global.params.warnings)                        {                            TypeFunction *tf = static_cast<TypeFunction *>(fd->type);                            if (tf->ty == Tfunction)                                error("%s%s is hidden by %s/n", fd->toPrettyChars(), Parameter::argsTypesToChars(tf->parameters, tf->varargs), toChars());                            else                                error("%s is hidden by %s/n", fd->toPrettyChars(), toChars());                        }                        c = DtoBitCast(LLVM_D_GetRuntimeFunction(gIR->module, "_d_hidden_func"), c->getType());                        break;                    }                }            }#endif        }        constants.push_back(c);    }    // build the constant struct    LLType* vtblTy = stripModifiers(type)->irtype->isClass()->getVtbl();    constVtbl = LLConstantStruct::get(isaStruct(vtblTy), constants);#if 0   IF_LOG Logger::cout() << "constVtbl type: " << *constVtbl->getType() << std::endl;   IF_LOG Logger::cout() << "vtbl type: " << *stripModifiers(type)->irtype->isClass()->getVtbl() << std::endl;#endif#if 0    size_t nc = constants.size();    for (size_t i = 0; i < nc; ++i)    {        if (constVtbl->getOperand(i)->getType() != vtblTy->getContainedType(i))        {            Logger::cout() << "type mismatch for entry # " << i << " in vtbl initializer" << std::endl;            constVtbl->getOperand(i)->dump();            vtblTy->getContainedType(i)->dump();        }    }#endif    assert(constVtbl->getType() == stripModifiers(type)->irtype->isClass()->getVtbl() &&        "vtbl initializer type mismatch");    return constVtbl;//.........这里部分代码省略.........

DValue* DtoCastClass(Loc& loc, DValue* val, Type* _to){    IF_LOG Logger::println("DtoCastClass(%s, %s)", val->getType()->toChars(), _to->toChars());    LOG_SCOPE;    Type* to = _to->toBasetype();    // class -> pointer    if (to->ty == Tpointer) {        IF_LOG Logger::println("to pointer");        LLType* tolltype = DtoType(_to);        LLValue* rval = DtoBitCast(val->getRVal(), tolltype);        return new DImValue(_to, rval);    }    // class -> bool    else if (to->ty == Tbool) {        IF_LOG Logger::println("to bool");        LLValue* llval = val->getRVal();        LLValue* zero = LLConstant::getNullValue(llval->getType());        return new DImValue(_to, gIR->ir->CreateICmpNE(llval, zero));    }    // class -> integer    else if (to->isintegral()) {        IF_LOG Logger::println("to %s", to->toChars());        // get class ptr        LLValue* v = val->getRVal();        // cast to size_t        v = gIR->ir->CreatePtrToInt(v, DtoSize_t(), "");        // cast to the final int type        DImValue im(Type::tsize_t, v);        return DtoCastInt(loc, &im, _to);    }    // must be class/interface    assert(to->ty == Tclass);    TypeClass* tc = static_cast<TypeClass*>(to);    // from type    Type* from = val->getType()->toBasetype();    TypeClass* fc = static_cast<TypeClass*>(from);    // x -> interface    if (InterfaceDeclaration* it = tc->sym->isInterfaceDeclaration()) {        Logger::println("to interface");        // interface -> interface        if (fc->sym->isInterfaceDeclaration()) {            Logger::println("from interface");            return DtoDynamicCastInterface(loc, val, _to);        }        // class -> interface - static cast        else if (it->isBaseOf(fc->sym,NULL)) {            Logger::println("static down cast");            // get the from class            ClassDeclaration* cd = fc->sym->isClassDeclaration();            DtoResolveClass(cd); // add this            IrTypeClass* typeclass = stripModifiers(fc)->ctype->isClass();            // find interface impl            size_t i_index = typeclass->getInterfaceIndex(it);            assert(i_index != ~0UL && "requesting interface that is not implemented by this class");            // offset pointer            LLValue* v = val->getRVal();            LLValue* orig = v;            v = DtoGEPi(v, 0, i_index);            LLType* ifType = DtoType(_to);            IF_LOG {                Logger::cout() << "V = " << *v << std::endl;                Logger::cout() << "T = " << *ifType << std::endl;            }            v = DtoBitCast(v, ifType);            // Check whether the original value was null, and return null if so.            // Sure we could have jumped over the code above in this case, but            // it's just a GEP and (maybe) a pointer-to-pointer BitCast, so it            // should be pretty cheap and perfectly safe even if the original was null.            LLValue* isNull = gIR->ir->CreateICmpEQ(orig, LLConstant::getNullValue(orig->getType()), ".nullcheck");            v = gIR->ir->CreateSelect(isNull, LLConstant::getNullValue(ifType), v, ".interface");            // return r-value            return new DImValue(_to, v);        }

void IRLandingPad::constructLandingPad(llvm::BasicBlock* inBB){    // save and rewrite scope    IRScope savedscope = gIR->scope();    gIR->scope() = IRScope(inBB,savedscope.end);    // eh_ptr = llvm.eh.exception();    llvm::Function* eh_exception_fn = GET_INTRINSIC_DECL(eh_exception);    LLValue* eh_ptr = gIR->ir->CreateCall(eh_exception_fn);    // build selector arguments    LLSmallVector<LLValue*, 6> selectorargs;    // put in classinfos in the right order    bool hasFinally = false;    bool hasCatch = false;    std::deque<IRLandingPadInfo>::iterator it = infos.begin(), end = infos.end();    for(; it != end; ++it)    {        if(it->finallyBody)            hasFinally = true;        else        {            hasCatch = true;            assert(it->catchType);            assert(it->catchType->ir.irStruct);            selectorargs.insert(selectorargs.begin(), it->catchType->ir.irStruct->getClassInfoSymbol());        }    }    // if there's a finally, the eh table has to have a 0 action    if(hasFinally)        selectorargs.push_back(DtoConstUint(0));    // personality fn    llvm::Function* personality_fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_eh_personality");    LLValue* personality_fn_arg = gIR->ir->CreateBitCast(personality_fn, getPtrToType(LLType::getInt8Ty(gIR->context())));    selectorargs.insert(selectorargs.begin(), personality_fn_arg);    // eh storage target    selectorargs.insert(selectorargs.begin(), eh_ptr);    // if there is a catch and some catch allocated storage, store exception object    if(hasCatch && catch_var)    {        const LLType* objectTy = DtoType(ClassDeclaration::object->type);        gIR->ir->CreateStore(gIR->ir->CreateBitCast(eh_ptr, objectTy), catch_var);    }    // eh_sel = llvm.eh.selector(eh_ptr, cast(byte*)&_d_eh_personality, <selectorargs>);    llvm::Function* eh_selector_fn = GET_INTRINSIC_DECL(eh_selector);    LLValue* eh_sel = gIR->ir->CreateCall(eh_selector_fn, selectorargs.begin(), selectorargs.end());    // emit finallys and 'if' chain to catch the exception    llvm::Function* eh_typeid_for_fn = GET_INTRINSIC_DECL(eh_typeid_for);    std::deque<IRLandingPadInfo> infos = this->infos;    std::stack<size_t> nInfos = this->nInfos;    std::deque<IRLandingPadInfo>::reverse_iterator rit, rend = infos.rend();    for(rit = infos.rbegin(); rit != rend; ++rit)    {        // if it's a finally, emit its code        if(rit->finallyBody)        {            size_t n = this->nInfos.top();            this->infos.resize(n);            this->nInfos.pop();            rit->finallyBody->toIR(gIR);        }        // otherwise it's a catch and we'll add a if-statement        else        {            llvm::BasicBlock *next = llvm::BasicBlock::Create(gIR->context(), "eh.next", gIR->topfunc(), gIR->scopeend());            LLValue *classInfo = DtoBitCast(rit->catchType->ir.irStruct->getClassInfoSymbol(),                                            getPtrToType(DtoType(Type::tint8)));            LLValue *eh_id = gIR->ir->CreateCall(eh_typeid_for_fn, classInfo);            gIR->ir->CreateCondBr(gIR->ir->CreateICmpEQ(eh_sel, eh_id), rit->target, next);            gIR->scope() = IRScope(next, gIR->scopeend());        }    }    // restore landing pad infos    this->infos = infos;    this->nInfos = nInfos;    // no catch matched and all finallys executed - resume unwind    llvm::Function* unwind_resume_fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_eh_resume_unwind");    gIR->ir->CreateCall(unwind_resume_fn, eh_ptr);    gIR->ir->CreateUnreachable();    gIR->scope() = savedscope;}

void DtoResolveStruct(StructDeclaration* sd){    // don't do anything if already been here    if (sd->ir.resolved) return;    // make sure above works :P    sd->ir.resolved = true;    // log what we're doing    Logger::println("Resolving struct type: %s (%s)", sd->toChars(), sd->loc.toChars());    LOG_SCOPE;    // make sure type exists    DtoType(sd->type);    // if it's a forward declaration, all bets are off. The type should be enough    if (sd->sizeok != 1)        return;    // create the IrStruct    IrStruct* irstruct = new IrStruct(sd);    sd->ir.irStruct = irstruct;    // make sure all fields really get their ir field    ArrayIter<VarDeclaration> it(sd->fields);    for (; !it.done(); it.next())    {        VarDeclaration* vd = it.get();        if (vd->ir.irField == NULL) {            new IrField(vd);        } else {            IF_LOG Logger::println("struct field already exists!!!");        }    }    // perform definition    bool needs_def = mustDefineSymbol(sd);    if (needs_def)    {        // emit the initZ symbol        LLGlobalVariable* initZ = irstruct->getInitSymbol();        // set initZ initializer        initZ->setInitializer(irstruct->getDefaultInit());    }    // emit members    if (sd->members)    {        ArrayIter<Dsymbol> it(*sd->members);        while (!it.done())        {            Dsymbol* member = it.get();            if (member)                member->codegen(Type::sir);            it.next();        }    }    if (needs_def)    {        // emit typeinfo        DtoTypeInfoOf(sd->type);    }}

LLType* DtoType(Type* t){    t = stripModifiers( t );    if (t->ctype)    {        return t->ctype->getLLType();    }    IF_LOG Logger::println("Building type: %s", t->toChars());    LOG_SCOPE;    assert(t);    switch (t->ty)    {    // basic types    case Tvoid:    case Tint8:    case Tuns8:    case Tint16:    case Tuns16:    case Tint32:    case Tuns32:    case Tint64:    case Tuns64:    case Tint128:    case Tuns128:    case Tfloat32:    case Tfloat64:    case Tfloat80:    case Timaginary32:    case Timaginary64:    case Timaginary80:    case Tcomplex32:    case Tcomplex64:    case Tcomplex80:    //case Tbit:    case Tbool:    case Tchar:    case Twchar:    case Tdchar:    {        return IrTypeBasic::get(t)->getLLType();    }    // pointers    case Tnull:    case Tpointer:    {        return IrTypePointer::get(t)->getLLType();    }    // arrays    case Tarray:    {        return IrTypeArray::get(t)->getLLType();    }    case Tsarray:    {        return IrTypeSArray::get(t)->getLLType();    }    // aggregates    case Tstruct:    {        TypeStruct* ts = static_cast<TypeStruct*>(t);        if (ts->sym->type->ctype)        {            // This should not happen, but the frontend seems to be buggy. Not            // sure if this is the best way to handle the situation, but we            // certainly don't want to override ts->sym->type->ctype.            IF_LOG Logger::cout() << "Struct with multiple Types detected: " <<                ts->toChars() << " (" << ts->sym->locToChars() << ")" << std::endl;            return ts->sym->type->ctype->getLLType();        }        return IrTypeStruct::get(ts->sym)->getLLType();    }    case Tclass:    {        TypeClass* tc = static_cast<TypeClass*>(t);        if (tc->sym->type->ctype)        {            // See Tstruct case.            IF_LOG Logger::cout() << "Class with multiple Types detected: " <<                tc->toChars() << " (" << tc->sym->locToChars() << ")" << std::endl;            return tc->sym->type->ctype->getLLType();        }        return IrTypeClass::get(tc->sym)->getLLType();    }    // functions    case Tfunction:    {        return IrTypeFunction::get(t)->getLLType();    }    // delegates    case Tdelegate:    {//.........这里部分代码省略.........

//.........这里部分代码省略.........  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  // void _moduleCtor()  // void _moduleDtor()  createFwdDecl(LINKc, voidTy, {"_moduleCtor", "_moduleDtor"}, {});  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  // void _d_throw_exception(Object e)  createFwdDecl(LINKc, voidTy, {"_d_throw_exception"}, {objectTy});  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  // int _d_switch_string(char[][] table, char[] ca)  createFwdDecl(LINKc, intTy, {"_d_switch_string"},                {stringTy->arrayOf(), stringTy}, {}, Attr_ReadOnly);  // int _d_switch_ustring(wchar[][] table, wchar[] ca)  createFwdDecl(LINKc, intTy, {"_d_switch_ustring"},                {wstringTy->arrayOf(), wstringTy}, {}, Attr_ReadOnly);  // int _d_switch_dstring(dchar[][] table, dchar[] ca)  createFwdDecl(LINKc, intTy, {"_d_switch_dstring"},                {dstringTy->arrayOf(), dstringTy}, {}, Attr_ReadOnly);  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  // int _d_eh_personality(...)  {    if (global.params.targetTriple.isWindowsMSVCEnvironment()) {      // (ptr ExceptionRecord, ptr EstablisherFrame, ptr ContextRecord,      //  ptr DispatcherContext)      createFwdDecl(LINKc, intTy, {"_d_eh_personality"},                    {voidPtrTy, voidPtrTy, voidPtrTy, voidPtrTy});    } else if (global.params.targetTriple.getArch() == llvm::Triple::arm) {      // (int state, ptr ucb, ptr context)      createFwdDecl(LINKc, intTy, {"_d_eh_personality"},                    {intTy, voidPtrTy, voidPtrTy});    } else {      // (int ver, int actions, ulong eh_class, ptr eh_info, ptr context)      createFwdDecl(LINKc, intTy, {"_d_eh_personality"},                    {intTy, intTy, ulongTy, voidPtrTy, voidPtrTy});    }  }  // void _d_eh_resume_unwind(ptr)  createFwdDecl(LINKc, voidTy, {"_d_eh_resume_unwind"}, {voidPtrTy});  // Object _d_eh_enter_catch(ptr)  createFwdDecl(LINKc, objectTy, {"_d_eh_enter_catch"}, {voidPtrTy}, {},                Attr_NoUnwind);  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  // void invariant._d_invariant(Object o)  createFwdDecl(      LINKd, voidTy,      {gABI->mangleForLLVM("_D9invariant12_d_invariantFC6ObjectZv", LINKd)},      {objectTy});  // void _d_dso_registry(CompilerDSOData* data)  llvm::StringRef fname("_d_dso_registry");  LLType *LLvoidTy = LLType::getVoidTy(gIR->context());  LLType *LLvoidPtrPtrTy = getPtrToType(getPtrToType(LLvoidTy));  LLType *moduleInfoPtrPtrTy =      getPtrToType(getPtrToType(DtoType(Module::moduleinfo->type)));  llvm::StructType *dsoDataTy =      llvm::StructType::get(DtoSize_t(),        // version                            LLvoidPtrPtrTy,     // slot                            moduleInfoPtrPtrTy, // _minfo_beg                            moduleInfoPtrPtrTy, // _minfo_end                            NULL);  llvm::Type *types[] = {getPtrToType(dsoDataTy)};  llvm::FunctionType *fty = llvm::FunctionType::get(LLvoidTy, types, false);  llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////////  // extern (C) void _d_cover_register2(string filename, size_t[] valid,  //                                    uint[] data, ubyte minPercent)  if (global.params.cov) {    createFwdDecl(LINKc, voidTy, {"_d_cover_register2"},                  {stringTy, sizeTy->arrayOf(), uintTy->arrayOf(), ubyteTy});  }}

DValue* DtoAAIndex(Loc& loc, Type* type, DValue* aa, DValue* key, bool lvalue){    // D1:    // call:    // extern(C) void* _aaGet(AA* aa, TypeInfo keyti, size_t valuesize, void* pkey)    // or    // extern(C) void* _aaIn(AA aa*, TypeInfo keyti, void* pkey)    // D2:    // call:    // extern(C) void* _aaGetX(AA* aa, TypeInfo keyti, size_t valuesize, void* pkey)    // or    // extern(C) void* _aaInX(AA aa*, TypeInfo keyti, void* pkey)    // first get the runtime function    llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, lvalue?"_aaGetX":"_aaInX");    LLFunctionType* funcTy = func->getFunctionType();    // aa param    LLValue* aaval = lvalue ? aa->getLVal() : aa->getRVal();    aaval = DtoBitCast(aaval, funcTy->getParamType(0));    // keyti param    LLValue* keyti = to_keyti(aa);    keyti = DtoBitCast(keyti, funcTy->getParamType(1));    // pkey param    LLValue* pkey = makeLValue(loc, key);    pkey = DtoBitCast(pkey, funcTy->getParamType(lvalue ? 3 : 2));    // call runtime    LLValue* ret;    if (lvalue) {        // valuesize param        LLValue* valsize = DtoConstSize_t(getTypePaddedSize(DtoType(type)));        ret = gIR->CreateCallOrInvoke4(func, aaval, keyti, valsize, pkey, "aa.index").getInstruction();    } else {        ret = gIR->CreateCallOrInvoke3(func, aaval, keyti, pkey, "aa.index").getInstruction();    }    // cast return value    LLType* targettype = getPtrToType(DtoType(type));    if (ret->getType() != targettype)        ret = DtoBitCast(ret, targettype);    // Only check bounds for rvalues ('aa[key]').    // Lvalue use ('aa[key] = value') auto-adds an element.    if (!lvalue && global.params.useArrayBounds) {        llvm::BasicBlock* oldend = gIR->scopeend();        llvm::BasicBlock* failbb = llvm::BasicBlock::Create(gIR->context(), "aaboundscheckfail", gIR->topfunc(), oldend);        llvm::BasicBlock* okbb = llvm::BasicBlock::Create(gIR->context(), "aaboundsok", gIR->topfunc(), oldend);        LLValue* nullaa = LLConstant::getNullValue(ret->getType());        LLValue* cond = gIR->ir->CreateICmpNE(nullaa, ret, "aaboundscheck");        gIR->ir->CreateCondBr(cond, okbb, failbb);        // set up failbb to call the array bounds error runtime function        gIR->scope() = IRScope(failbb, okbb);        std::vector<LLValue*> args;        // module param        LLValue *moduleInfoSymbol = gIR->func()->decl->getModule()->moduleInfoSymbol();        LLType *moduleInfoType = DtoType(Module::moduleinfo->type);        args.push_back(DtoBitCast(moduleInfoSymbol, getPtrToType(moduleInfoType)));        // line param        LLConstant* c = DtoConstUint(loc.linnum);        args.push_back(c);        // call        llvm::Function* errorfn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_array_bounds");        gIR->CreateCallOrInvoke(errorfn, args);        // the function does not return        gIR->ir->CreateUnreachable();        // if ok, proceed in okbb        gIR->scope() = IRScope(okbb, oldend);    }    return new DVarValue(type, ret);}

bool X86_64TargetABI::passByVal(Type* t) {    t = t->toBasetype();    if (linkage() == LINKd) {        return t->toBasetype()->ty == Tstruct;    } else {        // This implements the C calling convention for x86-64.        // It might not be correct for other calling conventions.        Classification cl = classify(t);        if (cl.isMemory)            return true;                // Figure out how many registers we want for this arg:        RegCount wanted = { 0, 0 };        for (int i = 0 ; i < 2; i++) {            if (cl.classes[i] == Integer)                wanted.int_regs++;            else if (cl.classes[i] == Sse)                wanted.sse_regs++;        }                // See if they're available:        RegCount& state = this->state();        if (wanted.int_regs <= state.int_regs && wanted.sse_regs <= state.sse_regs) {            state.int_regs -= wanted.int_regs;            state.sse_regs -= wanted.sse_regs;        } else {            if (keepUnchanged(t)) {                // Not enough registers available, but this is passed as if it's                // multiple arguments. Just use the registers there are,                // automatically spilling the rest to memory.                if (wanted.int_regs > state.int_regs)                    state.int_regs = 0;                else                    state.int_regs -= wanted.int_regs;                                if (wanted.sse_regs > state.sse_regs)                    state.sse_regs = 0;                else                    state.sse_regs -= wanted.sse_regs;            } else if (t->iscomplex() || t->ty == Tstruct) {                // Spill entirely to memory, even if some of the registers are                // available.                                // FIXME: Don't do this if *none* of the wanted registers are available,                //        (i.e. only when absolutely necessary for abi-compliance)                //        so it gets alloca'd by the callee and -scalarrepl can                //        more easily break it up?                // Note: this won't be necessary if the following LLVM bug gets fixed:                //       http://llvm.org/bugs/show_bug.cgi?id=3741                return true;            } else {                assert(t == Type::tfloat80 || t == Type::timaginary80 || t->ty == Tsarray || t->size() <= 8                    && "What other big types are there?");                // In any case, they shouldn't be represented as structs in LLVM:                assert(!isaStruct(DtoType(t)));            }        }        // Everything else that's passed in memory is handled by LLVM.        return false;    }}