Mercurial > projects > ldc

changeset 109:5ab8e92611f9 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r113] Added initial support for associative arrays (AAs). Fixed some problems with the string runtime support functions. Fixed initialization of array of structs. Fixed slice assignment where LHS is slice but RHS is dynamic array. Fixed problems with result of assignment expressions. Fixed foreach problems with key type mismatches.
author lindquist
date Wed, 21 Nov 2007 04:13:15 +0100
parents 288fe1029e1f
children e8da7856a260
files dmd/mtype.c gen/aa.cpp gen/aa.h gen/arrays.cpp gen/functions.cpp gen/statements.cpp gen/toir.cpp gen/tollvm.cpp gen/tollvm.h gen/typinf.cpp llvmdc.kdevelop llvmdc.kdevelop.filelist lphobos/build.sh lphobos/gc/gcbits.d lphobos/internal/aaA.d lphobos/internal/adi.d lphobos/internal/arrays.d lphobos/internal/qsort2.d test/aa1.d test/aa2.d test/aa3.d test/aa4.d test/aa5.d test/arrays14.d test/typeinfo13.d
diffstat 25 files changed, 756 insertions(+), 122 deletions(-) [+]
line wrap: on
line diff
--- a/dmd/mtype.c	Tue Nov 20 05:29:20 2007 +0100
+++ b/dmd/mtype.c	Wed Nov 21 04:13:15 2007 +0100
@@ -1515,6 +1515,7 @@
 	nm = name[n->ty == Twchar];
 	fd = FuncDeclaration::genCfunc(Type::tindex, nm);
     fd->llvmRunTimeHack = true;
+    ((TypeFunction*)fd->type)->llvmRetInPtr = true;
 	ec = new VarExp(0, fd);
 	e = e->castTo(sc, n->arrayOf());	// convert to dynamic array
 	arguments = new Expressions();
@@ -1533,6 +1534,7 @@
 	nm = name[n->ty == Twchar];
 	fd = FuncDeclaration::genCfunc(Type::tindex, nm);
     fd->llvmRunTimeHack = true;
+    ((TypeFunction*)fd->type)->llvmRetInPtr = true;
 	ec = new VarExp(0, fd);
 	e = e->castTo(sc, n->arrayOf());	// convert to dynamic array
 	arguments = new Expressions();
@@ -1551,6 +1553,8 @@
 	assert(size);
 	dup = (ident == Id::dup);
 	fd = FuncDeclaration::genCfunc(Type::tindex, dup ? Id::adDup : Id::adReverse);
+    fd->llvmRunTimeHack = true;
+    ((TypeFunction*)fd->type)->llvmRetInPtr = true;
 	ec = new VarExp(0, fd);
 	e = e->castTo(sc, n->arrayOf());	// convert to dynamic array
 	arguments = new Expressions();
@@ -1571,6 +1575,7 @@
 	fd = FuncDeclaration::genCfunc(tint32->arrayOf(),
 		(char*)(n->ty == Tbit ? "_adSortBit" : "_adSort"));
     fd->llvmRunTimeHack = true;
+    ((TypeFunction*)fd->type)->llvmRetInPtr = true;
 	ec = new VarExp(0, fd);
 	e = e->castTo(sc, n->arrayOf());	// convert to dynamic array
 	arguments = new Expressions();
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gen/aa.cpp	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,153 @@
+#include "gen/llvm.h"
+
+#include "mtype.h"
+#include "declaration.h"
+#include "aggregate.h"
+
+#include "gen/aa.h"
+#include "gen/runtime.h"
+#include "gen/tollvm.h"
+#include "gen/logger.h"
+#include "gen/irstate.h"
+#include "gen/dvalue.h"
+
+// makes sure the key value lives in memory so it can be passed to the runtime functions without problems
+// returns the pointer
+static llvm::Value* to_pkey(DValue* key)
+{
+    Type* keytype = key->getType();
+    bool needmem = !DtoIsPassedByRef(keytype);
+    llvm::Value* pkey;
+    if (key->isIm()) {
+        pkey = key->getRVal();
+    }
+    else if (DVarValue* var = key->isVar()) {
+        if (var->lval) {
+            pkey = key->getLVal();
+            needmem = false;
+        }
+        else {
+            pkey = key->getRVal();
+        }
+    }
+    else if (key->isConst()) {
+        needmem = true;
+        pkey = key->getRVal();
+    }
+    else {
+        assert(0);
+    }
+
+    // give memory
+    if (needmem) {
+        llvm::Value* tmp = new llvm::AllocaInst(DtoType(keytype), "aatmpkeystorage", gIR->topallocapoint());
+        DtoStore(pkey, tmp);
+        pkey = tmp;
+    }
+
+    return pkey;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+
+DValue* DtoAAIndex(Type* type, DValue* aa, DValue* key)
+{
+    // call:
+    // extern(C) void* _aaGet(AA* aa, TypeInfo keyti, void* pkey, size_t valuesize)
+
+    // first get the runtime function
+    llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_aaGet");
+    const llvm::FunctionType* funcTy = func->getFunctionType();
+
+    // aa param
+    llvm::Value* aaval = aa->getLVal();
+    aaval = DtoBitCast(aaval, funcTy->getParamType(0));
+
+    // keyti param
+    Type* keytype = key->getType();
+    keytype->getTypeInfo(NULL);
+    TypeInfoDeclaration* tid = keytype->getTypeInfoDeclaration();
+    assert(tid);
+    DtoResolveDsymbol(Type::typeinfo);
+    DtoForceDeclareDsymbol(tid);
+    assert(tid->llvmValue);
+    llvm::Value* keyti = tid->llvmValue;
+    keyti = DtoBitCast(keyti, funcTy->getParamType(1));
+
+    // pkey param
+    llvm::Value* pkey = to_pkey(key);
+    pkey = DtoBitCast(pkey, funcTy->getParamType(2));
+
+    // valuesize param
+    llvm::Value* valsize = DtoConstSize_t(gTargetData->getTypeSize(DtoType(type)));
+
+    // build arg vector
+    std::vector<llvm::Value*> args;
+    args.push_back(aaval);
+    args.push_back(keyti);
+    args.push_back(pkey);
+    args.push_back(valsize);
+
+    // call runtime
+    llvm::Value* ret = gIR->ir->CreateCall(func, args.begin(), args.end(), "aaGet");
+
+    // cast return value
+    const llvm::Type* targettype = llvm::PointerType::get(DtoType(type));
+    if (ret->getType() != targettype)
+        ret = DtoBitCast(ret, targettype);
+
+    return new DVarValue(type, ret, true);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+
+DValue* DtoAAIn(Type* type, DValue* aa, DValue* key)
+{
+    // call:
+    // extern(C) void* _aaIn(AA aa*, TypeInfo keyti, void* pkey)
+
+    // first get the runtime function
+    llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_aaIn");
+    const llvm::FunctionType* funcTy = func->getFunctionType();
+
+    Logger::cout() << "_aaIn = " << *func << '\n';
+
+    // aa param
+    llvm::Value* aaval = aa->getRVal();
+    Logger::cout() << "aaval: " << *aaval << '\n';
+    Logger::cout() << "totype: " << *funcTy->getParamType(0) << '\n';
+    aaval = DtoBitCast(aaval, funcTy->getParamType(0));
+
+    // keyti param
+    Type* keytype = key->getType();
+    keytype->getTypeInfo(NULL);
+    TypeInfoDeclaration* tid = keytype->getTypeInfoDeclaration();
+    assert(tid);
+    DtoResolveDsymbol(Type::typeinfo);
+    DtoForceDeclareDsymbol(tid);
+    assert(tid->llvmValue);
+    llvm::Value* keyti = tid->llvmValue;
+    keyti = DtoBitCast(keyti, funcTy->getParamType(1));
+
+    // pkey param
+    llvm::Value* pkey = to_pkey(key);
+    pkey = DtoBitCast(pkey, funcTy->getParamType(2));
+
+    // build arg vector
+    std::vector<llvm::Value*> args;
+    args.push_back(aaval);
+    args.push_back(keyti);
+    args.push_back(pkey);
+
+    // call runtime
+    llvm::Value* ret = gIR->ir->CreateCall(func, args.begin(), args.end(), "aaIn");
+
+    // cast return value
+    const llvm::Type* targettype = DtoType(type);
+    if (ret->getType() != targettype)
+        ret = DtoBitCast(ret, targettype);
+
+    return new DImValue(type, ret);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gen/aa.h	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,7 @@
+#ifndef LLVMDC_GEN_AA_H
+#define LLVMDC_GEN_AA_H
+
+DValue* DtoAAIndex(Type* type, DValue* aa, DValue* key);
+DValue* DtoAAIn(Type* type, DValue* aa, DValue* key);
+
+#endif // LLVMDC_GEN_AA_H
--- a/gen/arrays.cpp	Tue Nov 20 05:29:20 2007 +0100
+++ b/gen/arrays.cpp	Wed Nov 21 04:13:15 2007 +0100
@@ -151,11 +151,11 @@
 
 void DtoArrayInit(llvm::Value* ptr, llvm::Value* dim, llvm::Value* val)
 {
-    Logger::println("HELLO");
     Logger::cout() << "array: " << *ptr << " dim: " << *dim << " val: " << *val << '\n';
     const llvm::Type* pt = ptr->getType()->getContainedType(0);
     const llvm::Type* t = val->getType();
     const llvm::Type* finalTy;
+    size_t aggrsz = 0;
     if (size_t arrsz = checkRectArrayInit(pt, finalTy)) {
         assert(finalTy == t);
         llvm::Constant* c = isaConstant(dim);
@@ -164,12 +164,27 @@
         ptr = gIR->ir->CreateBitCast(ptr, llvm::PointerType::get(finalTy), "tmp");
     }
     else if (isaStruct(t)) {
-        assert(0);
+        aggrsz = gTargetData->getTypeSize(t);
+        llvm::Constant* c = isaConstant(val);
+        if (c && c->isNullValue()) {
+            llvm::Value* nbytes;
+            if (aggrsz == 1)
+                nbytes = dim;
+            else
+                nbytes = gIR->ir->CreateMul(dim, DtoConstSize_t(aggrsz), "tmp");
+            DtoMemSetZero(ptr,nbytes);
+            return;
+        }
+        else {
+            ptr = gIR->ir->CreateBitCast(ptr, llvm::PointerType::get(llvm::Type::Int8Ty), "tmp");
+        }
     }
     else {
         assert(t == pt);
     }
 
+    Logger::cout() << "array: " << *ptr << " dim: " << *dim << " val: " << *val << '\n';
+
     std::vector<llvm::Value*> args;
     args.push_back(ptr);
     args.push_back(dim);
@@ -177,7 +192,11 @@
 
     const char* funcname = NULL;
 
-    if (isaPointer(t)) {
+    if (aggrsz) {
+        funcname = "_d_array_init_mem";
+        args.push_back(DtoConstSize_t(aggrsz));
+    }
+    else if (isaPointer(t)) {
         funcname = "_d_array_init_pointer";
 
         const llvm::Type* dstty = llvm::PointerType::get(llvm::PointerType::get(llvm::Type::Int8Ty));
--- a/gen/functions.cpp	Tue Nov 20 05:29:20 2007 +0100
+++ b/gen/functions.cpp	Wed Nov 21 04:13:15 2007 +0100
@@ -44,6 +44,7 @@
     }
     else {
         assert(rt);
+        Type* rtfin = DtoDType(rt);
         if (DtoIsPassedByRef(rt)) {
             rettype = llvm::PointerType::get(DtoType(rt));
             actualRettype = llvm::Type::VoidTy;
--- a/gen/statements.cpp	Tue Nov 20 05:29:20 2007 +0100
+++ b/gen/statements.cpp	Wed Nov 21 04:13:15 2007 +0100
@@ -128,8 +128,8 @@
     Logger::println("ExpStatement::toIR(%d): %s", esi++, toChars());
     LOG_SCOPE;
 
-//     if (global.params.symdebug)
-//         DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
 
     if (exp != 0) {
         elem* e = exp->toElem(p);
@@ -731,6 +731,18 @@
         assert(0 && "aggregate type is not Tarray or Tsarray");
     }
 
+    if (niters->getType() != keytype)
+    {
+        size_t sz1 = gTargetData->getTypeSize(niters->getType());
+        size_t sz2 = gTargetData->getTypeSize(keytype);
+        if (sz1 < sz2)
+            niters = gIR->ir->CreateZExt(niters, keytype, "foreachtrunckey");
+        else if (sz1 > sz2)
+            niters = gIR->ir->CreateTrunc(niters, keytype, "foreachtrunckey");
+        else
+            niters = gIR->ir->CreateBitCast(niters, keytype, "foreachtrunckey");
+    }
+
     llvm::Constant* delta = 0;
     if (op == TOKforeach) {
         new llvm::StoreInst(zerokey, keyvar, p->scopebb());
--- a/gen/toir.cpp	Tue Nov 20 05:29:20 2007 +0100
+++ b/gen/toir.cpp	Wed Nov 21 04:13:15 2007 +0100
@@ -30,6 +30,7 @@
 #include "gen/typeinf.h"
 #include "gen/complex.h"
 #include "gen/dvalue.h"
+#include "gen/aa.h"
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -66,6 +67,7 @@
                 //allocainst->setAlignment(vd->type->alignsize()); // TODO
                 vd->llvmValue = allocainst;
             }
+
             Logger::cout() << "llvm value for decl: " << *vd->llvmValue << '\n';
             DValue* ie = DtoInitializer(vd->init);
         }
@@ -409,8 +411,13 @@
         else if (p->topexp()->e2 == this) {
             DValue* arr = p->topexp()->v;
             assert(arr);
-            DtoSetArray(arr->getLVal(), clen, arrptr);
-            return new DImValue(type, arr->getLVal(), true);
+            if (arr->isSlice()) {
+                return new DSliceValue(type, clen, arrptr);
+            }
+            else {
+                DtoSetArray(arr->getRVal(), clen, arrptr);
+                return new DImValue(type, arr->getLVal(), true);
+            }
         }
         assert(0);
     }
@@ -490,7 +497,14 @@
 
     if (l->isSlice() || l->isComplex())
         return l;
-    return new DImValue(type, l->getRVal());
+
+    llvm::Value* v;
+    if (l->isVar() && l->isVar()->lval)
+        v = l->getLVal();
+    else
+        v = l->getRVal();
+
+    return new DVarValue(type, v, true);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -893,15 +907,26 @@
             llvm::Value* tlv = topexp->v->getLVal();
             assert(isaStruct(tlv->getType()->getContainedType(0)));
             llargs[j] = tlv;
-            if (DtoIsPassedByRef(tf->next)) {
+            isInPlace = true;
+            /*if (DtoIsPassedByRef(tf->next)) {
                 isInPlace = true;
             }
             else
-            assert(0);
+            assert(0);*/
         }
         else {
             llargs[j] = new llvm::AllocaInst(argiter->get()->getContainedType(0),"rettmp",p->topallocapoint());
         }
+
+        if (dfn && dfn->func && dfn->func->llvmRunTimeHack) {
+            const llvm::Type* rettype = llvm::PointerType::get(DtoType(type));
+            if (llargs[j]->getType() != llfnty->getParamType(j)) {
+                Logger::println("llvmRunTimeHack==true - force casting return value param");
+                Logger::cout() << "casting: " << *llargs[j] << " to type: " << *llfnty->getParamType(j) << '\n';
+                llargs[j] = DtoBitCast(llargs[j], llfnty->getParamType(j));
+            }
+        }
+
         ++j;
         ++argiter;
     }
@@ -1004,10 +1029,12 @@
                 llargs[j] = DtoArgument(llfnty->getParamType(j), fnarg, (Expression*)arguments->data[i]);
                 // this hack is necessary :/
                 if (dfn && dfn->func && dfn->func->llvmRunTimeHack) {
-                    Logger::println("llvmRunTimeHack==true - force casting argument");
-                    if (llargs[j]->getType() != llfnty->getParamType(j)) {
-                        Logger::cout() << "from: " << *llargs[j]->getType() << " to: " << *llfnty->getParamType(j);
-                        llargs[j] = DtoBitCast(llargs[j], llfnty->getParamType(j));
+                    if (llfnty->getParamType(j) != NULL) {
+                        if (llargs[j]->getType() != llfnty->getParamType(j)) {
+                            Logger::println("llvmRunTimeHack==true - force casting argument");
+                            Logger::cout() << "casting: " << *llargs[j] << " to type: " << *llfnty->getParamType(j) << '\n';
+                            llargs[j] = DtoBitCast(llargs[j], llfnty->getParamType(j));
+                        }
                     }
                 }
             }
@@ -1024,12 +1051,21 @@
     if (llfnty->getReturnType() != llvm::Type::VoidTy)
         varname = "tmp";
 
-    Logger::cout() << "Calling: " << *funcval->getType() << '\n';
+    Logger::cout() << "Calling: " << *funcval << '\n';
 
     // call the function
     llvm::CallInst* call = new llvm::CallInst(funcval, llargs.begin(), llargs.end(), varname, p->scopebb());
     llvm::Value* retllval = (retinptr) ? llargs[0] : call;
 
+    if (retinptr && dfn && dfn->func && dfn->func->llvmRunTimeHack) {
+        const llvm::Type* rettype = llvm::PointerType::get(DtoType(type));
+        if (retllval->getType() != rettype) {
+            Logger::println("llvmRunTimeHack==true - force casting return value");
+            Logger::cout() << "from: " << *retllval->getType() << " to: " << *rettype << '\n';
+            retllval = DtoBitCast(retllval, rettype);
+        }
+    }
+
     // set calling convention
     if (dfn && dfn->func) {
         int li = dfn->func->llvmInternal;
@@ -1328,7 +1364,13 @@
         arrptr = new llvm::LoadInst(arrptr,"tmp",p->scopebb());
         arrptr = new llvm::GetElementPtrInst(arrptr,r->getRVal(),"tmp",p->scopebb());
     }
-    assert(arrptr);
+    else if (e1type->ty == Taarray) {
+        return DtoAAIndex(type, l, r);
+    }
+    else {
+        Logger::println("invalid index exp! e1type: %s", e1type->toChars());
+        assert(0);
+    }
     return new DVarValue(type, arrptr, true);
 }
 
@@ -2452,11 +2494,24 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
+DValue* InExp::toElem(IRState* p)
+{
+    Logger::print("InExp::toElem: %s | %s\n", toChars(), type->toChars());
+    LOG_SCOPE;
+
+    DValue* key = e1->toElem(p);
+    DValue* aa = e2->toElem(p);
+
+    return DtoAAIn(type, aa, key);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
 #define STUB(x) DValue *x::toElem(IRState * p) {error("Exp type "#x" not implemented: %s", toChars()); fatal(); return 0; }
 //STUB(IdentityExp);
 //STUB(CondExp);
 //STUB(EqualExp);
-STUB(InExp);
+//STUB(InExp);
 //STUB(CmpExp);
 //STUB(AndAndExp);
 //STUB(OrOrExp);
--- a/gen/tollvm.cpp	Tue Nov 20 05:29:20 2007 +0100
+++ b/gen/tollvm.cpp	Wed Nov 21 04:13:15 2007 +0100
@@ -177,8 +177,11 @@
     // associative arrays
     case Taarray:
     {
-        // TODO this is a kludge
-        return llvm::PointerType::get(llvm::Type::Int8Ty);
+        TypeAArray* taa = (TypeAArray*)t;
+        std::vector<const llvm::Type*> types;
+        types.push_back(DtoType(taa->key));
+        types.push_back(DtoType(taa->next));
+        return llvm::PointerType::get(llvm::StructType::get(types));
     }
 
     default:
@@ -1236,6 +1239,32 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
+void DtoMemSetZero(llvm::Value* dst, llvm::Value* nbytes)
+{
+    llvm::Type* arrty = llvm::PointerType::get(llvm::Type::Int8Ty);
+    llvm::Value *dstarr;
+    if (dst->getType() == arrty)
+    {
+        dstarr = dst;
+    }
+    else
+    {
+        dstarr = new llvm::BitCastInst(dst,arrty,"tmp",gIR->scopebb());
+    }
+
+    llvm::Function* fn = (global.params.is64bit) ? LLVM_DeclareMemSet64() : LLVM_DeclareMemSet32();
+    std::vector<llvm::Value*> llargs;
+    llargs.resize(4);
+    llargs[0] = dstarr;
+    llargs[1] = llvm::ConstantInt::get(llvm::Type::Int8Ty, 0, false);
+    llargs[2] = nbytes;
+    llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
+
+    new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
 void DtoMemCpy(llvm::Value* dst, llvm::Value* src, llvm::Value* nbytes)
 {
     assert(dst->getType() == src->getType());
--- a/gen/tollvm.h	Tue Nov 20 05:29:20 2007 +0100
+++ b/gen/tollvm.h	Wed Nov 21 04:13:15 2007 +0100
@@ -74,6 +74,7 @@
 void DtoForceDefineDsymbol(Dsymbol* dsym);
 
 // llvm wrappers
+void DtoMemSetZero(llvm::Value* dst, llvm::Value* nbytes);
 void DtoMemCpy(llvm::Value* dst, llvm::Value* src, llvm::Value* nbytes);
 bool DtoCanLoad(llvm::Value* ptr);
 llvm::Value* DtoLoad(llvm::Value* src);
--- a/gen/typinf.cpp	Tue Nov 20 05:29:20 2007 +0100
+++ b/gen/typinf.cpp	Wed Nov 21 04:13:15 2007 +0100
@@ -654,33 +654,69 @@
 
 void TypeInfoAssociativeArrayDeclaration::llvmDeclare()
 {
-    assert(0 && "TypeInfoAssociativeArrayDeclaration");
+    Logger::println("TypeInfoAssociativeArrayDeclaration::toDt() %s", toChars());
+    LOG_SCOPE;
+
+    // init typeinfo class
+    ClassDeclaration* base = Type::typeinfoassociativearray;
+    DtoResolveClass(base);
+
+    // get type of typeinfo class
+    const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
+
+    // create the symbol
+    llvmValue = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,NULL,toChars(),gIR->module);
 }
 
 void TypeInfoAssociativeArrayDeclaration::llvmDefine()
 {
-    assert(0 && "TypeInfoAssociativeArrayDeclaration");
+    Logger::println("TypeInfoAssociativeArrayDeclaration::toDt() %s", toChars());
+    LOG_SCOPE;
+
+    // init typeinfo class
+    ClassDeclaration* base = Type::typeinfoassociativearray;
+    DtoForceConstInitDsymbol(base);
+
+    // get type of typeinfo class
+    const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
+
+    // initializer vector
+    std::vector<llvm::Constant*> sinits;
+    // first is always the vtable
+    sinits.push_back(base->llvmVtbl);
+
+    // get type
+    assert(tinfo->ty == Taarray);
+    TypeAArray *tc = (TypeAArray *)tinfo;
+
+    // value typeinfo
+    tc->next->getTypeInfo(NULL);
+
+    // get symbol
+    assert(tc->next->vtinfo);
+    DtoForceDeclareDsymbol(tc->next->vtinfo);
+    llvm::Constant* castbase = isaConstant(tc->next->vtinfo->llvmValue);
+    castbase = llvm::ConstantExpr::getBitCast(castbase, stype->getElementType(1));
+    sinits.push_back(castbase);
+
+    // key typeinfo
+    tc->index->getTypeInfo(NULL);
+
+    // get symbol
+    assert(tc->index->vtinfo);
+    DtoForceDeclareDsymbol(tc->index->vtinfo);
+    castbase = isaConstant(tc->index->vtinfo->llvmValue);
+    castbase = llvm::ConstantExpr::getBitCast(castbase, stype->getElementType(2));
+    sinits.push_back(castbase);
+
+    // create the symbol
+    llvm::Constant* tiInit = llvm::ConstantStruct::get(stype, sinits);
+    isaGlobalVar(llvmValue)->setInitializer(tiInit);
 }
 
 void TypeInfoAssociativeArrayDeclaration::toDt(dt_t **pdt)
 {
-    assert(0 && "TypeInfoAssociativeArrayDeclaration");
-
-    /*
-    //printf("TypeInfoAssociativeArrayDeclaration::toDt()\n");
-    dtxoff(pdt, Type::typeinfoassociativearray->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_AssociativeArray
-    dtdword(pdt, 0);                // monitor
-
-    assert(tinfo->ty == Taarray);
-
-    TypeAArray *tc = (TypeAArray *)tinfo;
-
-    tc->next->getTypeInfo(NULL);
-    dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type
-
-    tc->index->getTypeInfo(NULL);
-    dtxoff(pdt, tc->index->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type
-    */
+    assert(0);
 }
 
 /* ========================================================================= */
--- a/llvmdc.kdevelop	Tue Nov 20 05:29:20 2007 +0100
+++ b/llvmdc.kdevelop	Wed Nov 21 04:13:15 2007 +0100
@@ -98,7 +98,7 @@
       <hidenonlocation>false</hidenonlocation>
     </groups>
     <tree>
-      <hidepatterns>*.bc</hidepatterns>
+      <hidepatterns>*.bc,*.ll</hidepatterns>
       <hidenonprojectfiles>false</hidenonprojectfiles>
     </tree>
   </kdevfileview>
--- a/llvmdc.kdevelop.filelist	Tue Nov 20 05:29:20 2007 +0100
+++ b/llvmdc.kdevelop.filelist	Wed Nov 21 04:13:15 2007 +0100
@@ -100,6 +100,8 @@
 dmd/version.c
 dmd/version.h
 gen
+gen/aa.cpp
+gen/aa.h
 gen/arrays.cpp
 gen/arrays.h
 gen/binops.cpp
@@ -136,6 +138,7 @@
 lphobos
 lphobos/crc32.d
 lphobos/gc
+lphobos/gc/gcbits.d
 lphobos/gc/gclinux.d
 lphobos/gc/gcstub.d
 lphobos/gcstats.d
@@ -145,7 +148,6 @@
 lphobos/internal/aaA.d
 lphobos/internal/adi.d
 lphobos/internal/arrays.d
-lphobos/internal/cmath2.d
 lphobos/internal/contract.d
 lphobos/internal/mem.d
 lphobos/internal/moduleinit.d
@@ -232,6 +234,10 @@
 test
 test/a.d
 test/aa1.d
+test/aa2.d
+test/aa3.d
+test/aa4.d
+test/aa5.d
 test/alignment.d
 test/alloca1.d
 test/arrayinit.d
@@ -240,6 +246,7 @@
 test/arrays11.d
 test/arrays12.d
 test/arrays13.d
+test/arrays14.d
 test/arrays2.d
 test/arrays3.d
 test/arrays4.d
@@ -316,6 +323,7 @@
 test/bug71.d
 test/bug72.d
 test/bug73.d
+test/bug74.d
 test/bug8.d
 test/bug9.d
 test/c.d
@@ -418,6 +426,7 @@
 test/typeinfo10.d
 test/typeinfo11.d
 test/typeinfo12.d
+test/typeinfo13.d
 test/typeinfo2.d
 test/typeinfo3.d
 test/typeinfo4.d
--- a/lphobos/build.sh	Tue Nov 20 05:29:20 2007 +0100
+++ b/lphobos/build.sh	Wed Nov 21 04:13:15 2007 +0100
@@ -51,7 +51,8 @@
 echo "compiling garbage collector"
 llvmdc gc/gclinux.d -c -odobj || exit 1
 llvmdc gc/gcstub.d -c -odobj -Igc || exit 1
-llvm-link -f -o=../lib/llvmdcore.bc obj/gclinux.bc obj/gcstub.bc ../lib/llvmdcore.bc || exit 1
+llvmdc gc/gcbits.d -c -odobj -Igc || exit 1
+llvm-link -f -o=../lib/llvmdcore.bc obj/gclinux.bc obj/gcstub.bc obj/gcbits.bc ../lib/llvmdcore.bc || exit 1
 
 echo "compiling phobos"
 rebuild phobos.d -c -oqobj -dc=llvmdc-posix || exit 1
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lphobos/gc/gcbits.d	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,176 @@
+
+// Copyright (C) 2001-2002 by Digital Mars
+// All Rights Reserved
+// www.digitalmars.com
+// Written by Walter Bright
+
+import std.c.string;
+import std.c.stdlib;
+import std.outofmemory;
+import std.intrinsic;
+
+//version = Asm86;
+version = bitops;
+
+struct GCBits
+{
+    const int BITS_PER_WORD = 32;
+    const int BITS_SHIFT = 5;
+    const int BITS_MASK = 31;
+
+    uint *data = null;
+    uint nwords = 0;	// allocated words in data[] excluding sentinals
+    uint nbits = 0;	// number of bits in data[] excluding sentinals
+
+    void Dtor()
+    {
+	if (data)
+	{
+	    free(data);
+	    data = null;
+	}
+    }
+
+    invariant
+    {
+	if (data)
+	{
+	    assert(nwords * data[0].sizeof * 8 >= nbits);
+	}
+    }
+
+    void alloc(uint nbits)
+    {
+	this.nbits = nbits;
+	nwords = (nbits + (BITS_PER_WORD - 1)) >> BITS_SHIFT;
+	data = cast(uint *)calloc(nwords + 2, uint.sizeof);
+	if (!data)
+	    _d_OutOfMemory();
+    }
+
+    uint test(uint i)
+    in
+    {
+	assert(i < nbits);
+    }
+    body
+    {
+	//return (cast(bit *)(data + 1))[i];
+	return data[1 + (i >> BITS_SHIFT)] & (1 << (i & BITS_MASK));
+    }
+
+    void set(uint i)
+    in
+    {
+	assert(i < nbits);
+    }
+    body
+    {
+	//(cast(bit *)(data + 1))[i] = 1;
+	data[1 + (i >> BITS_SHIFT)] |= (1 << (i & BITS_MASK));
+    }
+
+    void clear(uint i)
+    in
+    {
+	assert(i < nbits);
+    }
+    body
+    {
+	//(cast(bit *)(data + 1))[i] = 0;
+	data[1 + (i >> BITS_SHIFT)] &= ~(1 << (i & BITS_MASK));
+    }
+
+    uint testClear(uint i)
+    {
+	version (bitops)
+	{
+	    return std.intrinsic.btr(data + 1, i);
+	}
+	else version (Asm86)
+	{
+	    asm
+	    {
+		naked			;
+		mov	EAX,data[EAX]	;
+		mov	ECX,i-4[ESP]	;
+		btr	4[EAX],ECX	;
+		sbb	EAX,EAX		;
+		ret	4		;
+	    }
+	}
+	else
+	{   uint result;
+
+	    //result = (cast(bit *)(data + 1))[i];
+	    //(cast(bit *)(data + 1))[i] = 0;
+
+	    uint *p = &data[1 + (i >> BITS_SHIFT)];
+	    uint mask = (1 << (i & BITS_MASK));
+	    result = *p & mask;
+	    *p &= ~mask;
+	    return result;
+	}
+    }
+
+    void zero()
+    {
+	memset(data + 1, 0, nwords * uint.sizeof);
+    }
+
+    void copy(GCBits *f)
+    in
+    {
+	assert(nwords == f.nwords);
+    }
+    body
+    {
+	memcpy(data + 1, f.data + 1, nwords * uint.sizeof);
+    }
+
+    uint *base()
+    in
+    {
+	assert(data);
+    }
+    body
+    {
+	return data + 1;
+    }
+}
+
+unittest
+{
+    GCBits b;
+
+    b.alloc(786);
+    assert(b.test(123) == 0);
+    assert(b.testClear(123) == 0);
+    b.set(123);
+    assert(b.test(123) != 0);
+    assert(b.testClear(123) != 0);
+    assert(b.test(123) == 0);
+
+    b.set(785);
+    b.set(0);
+    assert(b.test(785) != 0);
+    assert(b.test(0) != 0);
+    b.zero();
+    assert(b.test(785) == 0);
+    assert(b.test(0) == 0);
+
+    GCBits b2;
+    b2.alloc(786);
+    b2.set(38);
+    b.copy(&b2);
+    assert(b.test(38) != 0);
+    b2.Dtor();
+
+    b.Dtor();
+}
+
+/+
+void main()
+{
+}
++/
--- a/lphobos/internal/aaA.d	Tue Nov 20 05:29:20 2007 +0100
+++ b/lphobos/internal/aaA.d	Wed Nov 21 04:13:15 2007 +0100
@@ -27,13 +27,19 @@
  *     distribution.
  */
 
+/*
+ * Modified for LLVMDC by Tomas Lindquist Olsen.
+ * The DMD implementation wont quite work due to the differences in how
+ * structs are handled.
+ */
+
 
 //import std.stdio;
 import std.c.stdarg;
 import std.c.stdio;
 import std.c.stdlib;
 import std.c.string;
-import std.string;
+//import std.string;
 
 import std.outofmemory;
 
@@ -51,17 +57,17 @@
 
 /* This is the type of the return value for dynamic arrays.
  * It should be a type that is returned in registers.
- * Although DMD will return types of Array in registers,
- * gcc will not, so we instead use a 'long'.
  */
-alias long ArrayRet_t;
+alias Array ArrayRet_t;
 
+pragma(LLVM_internal, "notypeinfo")
 struct Array
 {
     size_t length;
     void* ptr;
 }
 
+pragma(LLVM_internal, "notypeinfo")
 struct aaA
 {
     aaA *left;
@@ -71,6 +77,7 @@
     /* value */
 }
 
+pragma(LLVM_internal, "notypeinfo")
 struct BB
 {
     aaA*[] b;
@@ -81,10 +88,7 @@
  * it is completely opaque.
  */
 
-struct AA
-{
-    BB* a;
-}
+alias BB* AA;
 
 /**********************************
  * Align to next pointer boundary, so that
@@ -198,9 +202,9 @@
 	    }
 	}
 
-	if (aa.a)
+	if (aa)
 	{
-	    foreach (e; aa.a.b)
+	    foreach (e; aa.b)
 	    {
 		if (e)
 		    _aaLen_x(e);
@@ -212,7 +216,7 @@
     }
     body
     {
-	return aa.a ? aa.a.nodes : 0;
+	return aa ? aa.nodes : 0;
     }
 
 
@@ -221,7 +225,7 @@
  * Add entry for key if it is not already there.
  */
 
-void* _aaGet(AA* aa, TypeInfo keyti, size_t valuesize, ...)
+void* _aaGet(AA* aa, TypeInfo keyti, void* pkey, size_t valuesize)
     in
     {
 	assert(aa);
@@ -229,32 +233,32 @@
     out (result)
     {
 	assert(result);
-	assert(aa.a);
-	assert(aa.a.b.length);
-	//assert(_aaInAh(*aa.a, key));
+	assert(*aa);
+	assert((*aa).b.length);
+	//assert(_aaInAh(*aa, key));
     }
     body
     {
-	auto pkey = cast(void *)(&valuesize + 1);
+	//auto pkey = cast(void *)(&valuesize + 1);
 	size_t i;
 	aaA* e;
 	auto keysize = aligntsize(keyti.tsize());
 
-	if (!aa.a)
-	    aa.a = new BB();
+	if (!*aa)
+	    *aa = new BB();
 
-	if (!aa.a.b.length)
+	if (!(*aa).b.length)
 	{
 	    alias aaA *pa;
 	    auto len = prime_list[0];
 
-	    aa.a.b = new pa[len];
+	    (*aa).b = new pa[len];
 	}
 
 	auto key_hash = keyti.getHash(pkey);
 	//printf("hash = %d\n", key_hash);
-	i = key_hash % aa.a.b.length;
-	auto pe = &aa.a.b[i];
+	i = key_hash % (*aa).b.length;
+	auto pe = &(*aa).b[i];
 	while ((e = *pe) != null)
 	{
 	    if (key_hash == e.hash)
@@ -275,9 +279,9 @@
 	e.hash = key_hash;
 	*pe = e;
 
-	auto nodes = ++aa.a.nodes;
-	//printf("length = %d, nodes = %d\n", (*aa.a).length, nodes);
-	if (nodes > aa.a.b.length * 4)
+	auto nodes = ++(*aa).nodes;
+	//printf("length = %d, nodes = %d\n", (*aa).length, nodes);
+	if (nodes > (*aa).b.length * 4)
 	{
 	    _aaRehash(aa,keyti);
 	}
@@ -292,22 +296,22 @@
  * Returns null if it is not already there.
  */
 
-void* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, ...)
+void* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, void* pkey)
     {
 	//printf("_aaGetRvalue(valuesize = %u)\n", valuesize);
-	if (!aa.a)
+	if (!aa)
 	    return null;
 
-	auto pkey = cast(void *)(&valuesize + 1);
+	//auto pkey = cast(void *)(&valuesize + 1);
 	auto keysize = aligntsize(keyti.tsize());
-	auto len = aa.a.b.length;
+	auto len = aa.b.length;
 
 	if (len)
 	{
 	    auto key_hash = keyti.getHash(pkey);
 	    //printf("hash = %d\n", key_hash);
 	    size_t i = key_hash % len;
-	    auto e = aa.a.b[i];
+	    auto e = aa.b[i];
 	    while (e != null)
 	    {
 		if (key_hash == e.hash)
@@ -332,7 +336,7 @@
  *	!=null	in aa, return pointer to value
  */
 
-void* _aaIn(AA aa, TypeInfo keyti, ...)
+void* _aaIn(AA aa, TypeInfo keyti, void* pkey)
     in
     {
     }
@@ -342,19 +346,19 @@
     }
     body
     {
-	if (aa.a)
+	if (aa)
 	{
-	    auto pkey = cast(void *)(&keyti + 1);
+	    //auto pkey = cast(void *)(&keyti + 1);
 
-	    //printf("_aaIn(), .length = %d, .ptr = %x\n", aa.a.length, cast(uint)aa.a.ptr);
-	    auto len = aa.a.b.length;
+	    //printf("_aaIn(), .length = %d, .ptr = %x\n", aa.length, cast(uint)aa.ptr);
+	    auto len = aa.b.length;
 
 	    if (len)
 	    {
 		auto key_hash = keyti.getHash(pkey);
 		//printf("hash = %d\n", key_hash);
 		size_t i = key_hash % len;
-		auto e = aa.a.b[i];
+		auto e = aa.b[i];
 		while (e != null)
 		{
 		    if (key_hash == e.hash)
@@ -380,17 +384,17 @@
  * If key is not in aa[], do nothing.
  */
 
-void _aaDel(AA aa, TypeInfo keyti, ...)
+void _aaDel(AA aa, TypeInfo keyti, void* pkey)
     {
-	auto pkey = cast(void *)(&keyti + 1);
+	//auto pkey = cast(void *)(&keyti + 1);
 	aaA* e;
 
-	if (aa.a && aa.a.b.length)
+	if (aa && aa.b.length)
 	{
 	    auto key_hash = keyti.getHash(pkey);
 	    //printf("hash = %d\n", key_hash);
-	    size_t i = key_hash % aa.a.b.length;
-	    auto pe = &aa.a.b[i];
+	    size_t i = key_hash % aa.b.length;
+	    auto pe = &aa.b[i];
 	    while ((e = *pe) != null)	// null means not found
 	    {
 		if (key_hash == e.hash)
@@ -423,7 +427,7 @@
 			    e.right = null;
 			}
 
-			aa.a.nodes--;
+			aa.nodes--;
 
 			// Should notify GC that e can be free'd now
 			break;
@@ -470,19 +474,19 @@
 	    } while (e != null);
 	}
 
-	if (aa.a)
+	if (aa)
 	{
 	    a.length = _aaLen(aa);
 	    a.ptr = (new void[a.length * valuesize]).ptr;
 	    resi = 0;
-	    foreach (e; aa.a.b)
+	    foreach (e; aa.b)
 	    {
 		if (e)
 		    _aaValues_x(e);
 	    }
 	    assert(resi == a.length);
 	}
-	return *cast(ArrayRet_t*)(&a);
+	return a;
     }
 
 
@@ -493,6 +497,7 @@
 void* _aaRehash(AA* paa, TypeInfo keyti)
     in
     {
+    assert(paa);
 	//_aaInvAh(paa);
     }
     out (result)
@@ -549,9 +554,9 @@
 	}
 
 	//printf("Rehash\n");
-	if (paa.a)
+	if (paa)
 	{
-	    auto aa = paa.a;
+	    auto aa = *paa;
 	    auto len = _aaLen(*paa);
 	    if (len)
 	    {   size_t i;
@@ -573,9 +578,9 @@
 		newb.nodes = aa.nodes;
 	    }
 
-	    *paa.a = newb;
+	    **paa = newb;
 	}
-	return (*paa).a;
+	return *paa;
     }
 
 
@@ -607,20 +612,17 @@
 
 	auto len = _aaLen(aa);
 	if (!len)
-	    return 0;
+	    return ArrayRet_t.init;
 	res = cast(byte[])new void[len * keysize];
 	resi = 0;
-	foreach (e; aa.a.b)
+	foreach (e; aa.b)
 	{
 	    if (e)
 		_aaKeys_x(e);
 	}
 	assert(resi == len);
 
-	Array a;
-	a.length = len;
-	a.ptr = res.ptr;
-	return *cast(ArrayRet_t*)(&a);
+	return Array(len, res.ptr);
     }
 
 
@@ -639,7 +641,7 @@
 body
 {   int result;
 
-    //printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa.a, keysize, dg);
+    //printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa, keysize, dg);
 
     int treewalker(aaA* e)
     {	int result;
@@ -666,9 +668,9 @@
 	return result;
     }
 
-    if (aa.a)
+    if (aa)
     {
-	foreach (e; aa.a.b)
+	foreach (e; aa.b)
 	{
 	    if (e)
 	    {
@@ -692,7 +694,7 @@
 body
 {   int result;
 
-    //printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa.a, keysize, dg);
+    //printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa, keysize, dg);
 
     int treewalker(aaA* e)
     {	int result;
@@ -719,9 +721,9 @@
 	return result;
     }
 
-    if (aa.a)
+    if (aa)
     {
-	foreach (e; aa.a.b)
+	foreach (e; aa.b)
 	{
 	    if (e)
 	    {
--- a/lphobos/internal/adi.d	Tue Nov 20 05:29:20 2007 +0100
+++ b/lphobos/internal/adi.d	Wed Nov 21 04:13:15 2007 +0100
@@ -51,7 +51,7 @@
  * reversed.
  */
 
-extern (C) long _adReverseChar(char[] a)
+extern (C) char[] _adReverseChar(char[] a)
 {
     if (a.length > 1)
     {
@@ -111,7 +111,7 @@
         hi = hi - 1 + (stridehi - stridelo);
     }
     }
-    return *cast(long*)(&a);
+    return a;
 }
 
 unittest
@@ -147,7 +147,7 @@
  * reversed.
  */
 
-extern (C) long _adReverseWchar(wchar[] a)
+extern (C) wchar[] _adReverseWchar(wchar[] a)
 {
     if (a.length > 1)
     {
@@ -205,7 +205,7 @@
         hi = hi - 1 + (stridehi - stridelo);
     }
     }
-    return *cast(long*)(&a);
+    return a;
 }
 
 unittest
@@ -230,13 +230,8 @@
  * Support for array.reverse property.
  */
 
-extern (C) long _adReverse(Array a, size_t szelem)
-    out (result)
-    {
-    assert(result is *cast(long*)(&a));
-    }
-    body
-    {
+extern (C) Array _adReverse(Array a, size_t szelem)
+{
     if (a.length >= 2)
     {
         byte* tmp;
@@ -272,8 +267,8 @@
             //delete tmp;
         }
     }
-    return *cast(long*)(&a);
-    }
+    return a;
+}
 
 unittest
 {
@@ -364,7 +359,7 @@
  * Sort array of chars.
  */
 
-extern (C) long _adSortChar(char[] a)
+extern (C) char[] _adSortChar(char[] a)
 {
     if (a.length > 1)
     {
@@ -379,14 +374,14 @@
     }
     delete da;
     }
-    return *cast(long*)(&a);
+    return a;
 }
 
 /**********************************************
  * Sort array of wchars.
  */
 
-extern (C) long _adSortWchar(wchar[] a)
+extern (C) wchar[] _adSortWchar(wchar[] a)
 {
     if (a.length > 1)
     {
@@ -401,7 +396,7 @@
     }
     delete da;
     }
-    return *cast(long*)(&a);
+    return a;
 }
 
 /**********************************************
@@ -803,3 +798,41 @@
     assert(a >= e);
 }
 }
+
+/**********************************
+ * Support for array.dup property.
+ */
+
+extern(C)
+void* _d_realloc(void*, size_t);
+
+extern(C)
+Array _adDupT(TypeInfo ti, Array a)
+{
+    Array r;
+    if (a.length)
+    {
+        auto sizeelem = ti.next.tsize();        // array element size
+        auto size = a.length * sizeelem;
+        r.ptr = _d_realloc(null,size);
+        r.length = a.length;
+        memcpy(r.ptr, a.ptr, size);
+    }
+    return r;
+}
+
+unittest
+{
+    int[] a;
+    int[] b;
+    int i;
+
+    debug(adi) printf("array.dup.unittest\n");
+
+    a = new int[3];
+    a[0] = 1; a[1] = 2; a[2] = 3;
+    b = a.dup;
+    assert(b.length == 3);
+    for (i = 0; i < 3; i++)
+    assert(b[i] == i + 1);
+}
--- a/lphobos/internal/arrays.d	Tue Nov 20 05:29:20 2007 +0100
+++ b/lphobos/internal/arrays.d	Wed Nov 21 04:13:15 2007 +0100
@@ -78,7 +78,7 @@
         *p++ = v;
 }
 
-void _d_array_init(void* a, size_t na, void* v, size_t nv)
+void _d_array_init_mem(void* a, size_t na, void* v, size_t nv)
 {
     auto p = a;
     auto end = a + na*nv;
--- a/lphobos/internal/qsort2.d	Tue Nov 20 05:29:20 2007 +0100
+++ b/lphobos/internal/qsort2.d	Wed Nov 21 04:13:15 2007 +0100
@@ -14,6 +14,7 @@
 
 import std.c.stdlib;
 
+pragma(LLVM_internal, "notypeinfo")
 struct Array
 {
     size_t length;
@@ -27,14 +28,14 @@
     return tiglobal.compare(p1, p2);
 }
 
-extern (C) long _adSort(Array a, TypeInfo ti)
+extern (C) Array _adSort(Array a, TypeInfo ti)
 {
     synchronized
     {
 	tiglobal = ti;
 	std.c.stdlib.qsort(a.ptr, a.length, cast(size_t)ti.tsize(), &cmp);
     }
-    return *cast(long*)(&a);
+    return a;
 }
 
 
--- a/test/aa1.d	Tue Nov 20 05:29:20 2007 +0100
+++ b/test/aa1.d	Wed Nov 21 04:13:15 2007 +0100
@@ -3,4 +3,13 @@
 void main()
 {
     int[int] aai;
+    assert(aai is null);
+    aai[0] = 52;
+    assert(aai !is null);
+    int i = aai[0];
+    assert(i == 52);
+    aai[32] = 123;
+    int j = aai[32];
+    assert(i == 52);
+    assert(j == 123);
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/aa2.d	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,12 @@
+module aa2;
+
+void main()
+{
+    long[float] aa;
+    long* p = 2.0f in aa;
+    assert(!p);
+    aa[4f] = 23;
+    p = 4f in aa;
+    assert(p);
+    assert(*p == 23);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/aa3.d	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,24 @@
+module aa3;
+
+void main()
+{
+    int[string] aa;
+    {aa["hello"] = 1;}
+    {int* p = "" in aa;}
+    aa[" worl"] = 2;
+    aa["d"] = 3;
+    aa["thisisgreat"] = 10;
+    int sum;
+    string cat;
+    {
+    foreach(k,v;aa)
+    {
+        printf("int[%.*s] = %d\n", k.length, k.ptr, v);
+        sum += v;
+        cat ~= k;
+    }
+    }
+    assert(sum == 16);
+    printf("cat = %.*s\n", cat.length, cat.ptr);
+    assert(cat.length == 22);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/aa4.d	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,20 @@
+module aa4;
+
+void main()
+{
+    int[int] aa;
+    aa = addkey(aa,42,12);
+    int* p = haskey(aa,42);
+    assert(p && *p == 12);
+}
+
+int[int] addkey(int[int] aa, int key, int val)
+{
+    aa[key] = val;
+    return aa;
+}
+
+int* haskey(int[int] aa, int key)
+{
+    return key in aa;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/aa5.d	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,9 @@
+module aa5;
+
+void main()
+{
+    int[int] aa;
+    aa[42] = 1;
+    int i = aa[42];
+    assert(i == 1);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/arrays14.d	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,7 @@
+module arrays14;
+
+void main()
+{
+    auto s = "hello world";
+    auto d = s.dup;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/typeinfo13.d	Wed Nov 21 04:13:15 2007 +0100
@@ -0,0 +1,13 @@
+module typeinfo13;
+
+void main()
+{
+    float[long] aa;
+    auto ti = typeid(typeof(aa));
+    assert(ti.toString() == "float[long]");
+    assert(ti.next() is typeid(float));
+    assert(ti.tsize() == size_t.sizeof);
+    auto aati = cast(TypeInfo_AssociativeArray)ti;
+    assert(aati.value is typeid(float));
+    assert(aati.key is typeid(long));
+}