# HG changeset patch
# User lindquist
# Date 1215915068 -7200
# Node ID e20ce6d8d3745f2b39531a44b2ccd59b72f65715
# Parent  15eb8f5f24415ee549b960a6e7a2ea4e8ae0f666
[svn r365] Implemented raw struct equality comparison, uses C memcmp.
Renamed DtoDelegateCompare to DtoDelegateEquals, for consistency with the other equality helpers.

diff -r 15eb8f5f2441 -r e20ce6d8d374 gen/structs.cpp
--- a/gen/structs.cpp	Sun Jul 13 03:02:15 2008 +0200
+++ b/gen/structs.cpp	Sun Jul 13 04:11:08 2008 +0200
@@ -13,6 +13,7 @@
 #include "gen/arrays.h"
 #include "gen/logger.h"
 #include "gen/structs.h"
+#include "gen/dvalue.h"
 
 #include "ir/irstruct.h"
 
@@ -378,6 +379,28 @@
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////   D STRUCT UTILITIES     ////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+
+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)
+        cmpop = llvm::ICmpInst::ICMP_EQ;
+    else
+        cmpop = llvm::ICmpInst::ICMP_NE;
+
+    // call memcmp
+    size_t sz = getABITypeSize(DtoType(t));
+    LLValue* val = DtoMemCmp(lhs->getRVal(), rhs->getRVal(), DtoConstSize_t(sz));
+    return gIR->ir->CreateICmp(cmpop, val, LLConstantInt::get(val->getType(), 0, false), "tmp");
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////   D UNION HELPER CLASS   ////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////
 
diff -r 15eb8f5f2441 -r e20ce6d8d374 gen/structs.h
--- a/gen/structs.h	Sun Jul 13 03:02:15 2008 +0200
+++ b/gen/structs.h	Sun Jul 13 04:11:08 2008 +0200
@@ -25,6 +25,11 @@
  */
 void DtoDefineStruct(StructDeclaration* sd);
 
+/**
+ * Returns a boolean=true if the two structs are equal
+ */
+LLValue* DtoStructEquals(TOK op, DValue* lhs, DValue* rhs);
+
 typedef LLSmallVector<unsigned, 3> DStructIndexVector;
 LLValue* DtoIndexStruct(LLValue* ptr, StructDeclaration* sd, Type* t, unsigned os, DStructIndexVector& idxs);
 
diff -r 15eb8f5f2441 -r e20ce6d8d374 gen/toir.cpp
--- a/gen/toir.cpp	Sun Jul 13 03:02:15 2008 +0200
+++ b/gen/toir.cpp	Sun Jul 13 04:11:08 2008 +0200
@@ -1747,7 +1747,13 @@
     else if (t->ty == Tdelegate)
     {
         Logger::println("delegate");
-        eval = DtoDelegateCompare(op,l->getRVal(),r->getRVal());
+        eval = DtoDelegateEquals(op,l->getRVal(),r->getRVal());
+    }
+    else if (t->ty == Tstruct)
+    {
+        Logger::println("struct");
+        // when this is reached it means there is no opEquals overload.
+        eval = DtoStructEquals(op,l,r);
     }
     else
     {
@@ -2266,7 +2272,7 @@
         else {
             assert(l->getType() == r->getType());
         }
-        eval = DtoDelegateCompare(op,l,r);
+        eval = DtoDelegateEquals(op,l,r);
     }
     else if (t1->isfloating())
     {
diff -r 15eb8f5f2441 -r e20ce6d8d374 gen/tollvm.cpp
--- a/gen/tollvm.cpp	Sun Jul 13 03:02:15 2008 +0200
+++ b/gen/tollvm.cpp	Sun Jul 13 04:11:08 2008 +0200
@@ -186,9 +186,9 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-LLValue* DtoDelegateCompare(TOK op, LLValue* lhs, LLValue* rhs)
+LLValue* DtoDelegateEquals(TOK op, LLValue* lhs, LLValue* rhs)
 {
-    Logger::println("Doing delegate compare");
+    Logger::println("Doing delegate equality");
     llvm::ICmpInst::Predicate pred = (op == TOKequal || op == TOKidentity) ? llvm::ICmpInst::ICMP_EQ : llvm::ICmpInst::ICMP_NE;
     llvm::Value *b1, *b2;
     if (rhs == NULL)
@@ -444,6 +444,29 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
+LLValue* DtoMemCmp(LLValue* lhs, LLValue* rhs, LLValue* nbytes)
+{
+    // int memcmp ( const void * ptr1, const void * ptr2, size_t num );
+
+    LLFunction* fn = gIR->module->getFunction("memcmp");
+    if (!fn)
+    {
+        std::vector<const LLType*> params(3);
+        params[0] = getVoidPtrType();
+        params[1] = getVoidPtrType();
+        params[2] = DtoSize_t();
+        const LLFunctionType* fty = LLFunctionType::get(LLType::Int32Ty, params, false);
+        fn = LLFunction::Create(fty, LLGlobalValue::ExternalLinkage, "memcmp", gIR->module);
+    }
+
+    lhs = DtoBitCast(lhs,getVoidPtrType());
+    rhs = DtoBitCast(rhs,getVoidPtrType());
+
+    return gIR->ir->CreateCall3(fn, lhs, rhs, nbytes, "tmp");
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
 void DtoAggrZeroInit(LLValue* v)
 {
     uint64_t n = getTypeStoreSize(v->getType()->getContainedType(0));
diff -r 15eb8f5f2441 -r e20ce6d8d374 gen/tollvm.h
--- a/gen/tollvm.h	Sun Jul 13 03:02:15 2008 +0200
+++ b/gen/tollvm.h	Sun Jul 13 04:11:08 2008 +0200
@@ -27,7 +27,7 @@
 
 // delegate helpers
 const LLStructType* DtoDelegateType(Type* t);
-LLValue* DtoDelegateCompare(TOK op, LLValue* lhs, LLValue* rhs);
+LLValue* DtoDelegateEquals(TOK op, LLValue* lhs, LLValue* rhs);
 
 // return linkage type for symbol using the current ir state for context
 LLGlobalValue::LinkageTypes DtoLinkage(Dsymbol* sym);
@@ -114,6 +114,11 @@
 void DtoMemCpy(LLValue* dst, LLValue* src, LLValue* nbytes);
 
 /**
+ * Generates a call to C memcmp.
+ */
+LLValue* DtoMemCmp(LLValue* lhs, LLValue* rhs, LLValue* nbytes);
+
+/**
  * The same as DtoMemSetZero but figures out the size itself by "dereferencing" the v pointer once.
  * @param v Destination memory.
  */
diff -r 15eb8f5f2441 -r e20ce6d8d374 llvmdc.kdevelop.filelist
--- a/llvmdc.kdevelop.filelist	Sun Jul 13 03:02:15 2008 +0200
+++ b/llvmdc.kdevelop.filelist	Sun Jul 13 04:11:08 2008 +0200
@@ -58,6 +58,8 @@
 dmd/mangle.c
 dmd/mars.c
 dmd/mars.h
+dmd/md5.c
+dmd/md5.h
 dmd/mem.c
 dmd/mem.h
 dmd/module.c