---

yaml
---
r: 2970
b: refs/heads/master
c: 698022d
h: refs/heads/master
v: v3

Author: cixtor

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 08dcb9306b46bc38c0f4bbb8049da2a93c13082a
+refs/heads/master: 698022d351e552b51cd9cca878bdc0de3de05b8c

trunk/src/comp/back/link.rs

@@ -153,7 +153,6 @@ mod write {
                                               True,  // unit-at-a-time
                                               True,  // unroll loops
                                               True,  // simplify lib calls
-                                              True,  // have exceptions
                                               threshold); // inline threshold
         }
 

trunk/src/comp/lib/llvm.rs

@@ -88,6 +88,7 @@ const uint LLVMNoImplicitFloatAttribute = 8388608u;
 const uint LLVMNakedAttribute = 16777216u;
 const uint LLVMInlineHintAttribute = 33554432u;
 const uint LLVMStackAttribute = 469762048u;     // 7 << 26
+const uint LLVMUWTableAttribute = 1073741824u; // 1 << 30
 
 
 // Consts for the LLVM IntPredicate type, pre-cast to uint.
@@ -813,7 +814,6 @@ native mod llvm = llvm_lib {
                                    Bool UnitAtATime,
                                    Bool UnrollLoops,
                                    Bool SimplifyLibCalls,
-                                   Bool HaveExceptions,
                                    uint InliningThreshold);
 
     /** Destroys a memory buffer. */

trunk/src/comp/middle/trans.rs

@@ -1820,6 +1820,11 @@ fn set_no_inline(ValueRef f) {
                               lib::llvm::llvm::Attribute);
 }
 
+fn set_uwtable(ValueRef f) {
+    llvm::LLVMAddFunctionAttr(f, lib::llvm::LLVMUWTableAttribute as
+                              lib::llvm::llvm::Attribute);
+}
+
 fn set_always_inline(ValueRef f) {
     llvm::LLVMAddFunctionAttr(f, lib::llvm::LLVMAlwaysInlineAttribute as
                               lib::llvm::llvm::Attribute);
@@ -6962,6 +6967,7 @@ fn trans_fn(@local_ctxt cx, &span sp, &ast::_fn f, ast::def_id fid,
             option::t[ty_self_pair] ty_self,
             &vec[ast::ty_param] ty_params, &ast::ann ann) {
     auto llfndecl = cx.ccx.item_ids.get(fid);
+    set_uwtable(llfndecl);
 
     // Set up arguments to the function.
     auto fcx = new_fn_ctxt(cx, sp, llfndecl);

trunk/src/comp/middle/typeck.rs

@@ -52,10 +52,16 @@ import middle::tstate::ann::ts_ann;
 type ty_table = hashmap[ast::def_id, ty::t];
 type fn_purity_table = hashmap[ast::def_id, ast::purity];
 
+type unify_cache_entry = tup(ty::t,ty::t,vec[mutable ty::t]);
+type unify_cache = hashmap[unify_cache_entry,ty::unify::result];
+
 type obj_info = rec(vec[ast::obj_field] obj_fields, ast::def_id this_obj);
 
 type crate_ctxt = rec(mutable vec[obj_info] obj_infos,
                       @fn_purity_table fn_purity_table,
+                      unify_cache unify_cache,
+                      mutable uint cache_hits,
+                      mutable uint cache_misses,
                       ty::ctxt tcx);
 
 type fn_ctxt = rec(ty::t ret_ty,
@@ -814,9 +820,22 @@ mod collect {
 mod unify {
     fn simple(&@fn_ctxt fcx, &ty::t expected, &ty::t actual)
             -> ty::unify::result {
+        /*auto cache_key = tup(expected, actual, param_substs);
+        alt (fcx.ccx.unify_cache.find(cache_key)) {
+            case (some(?r)) {
+                fcx.ccx.cache_hits += 1u;
+                ret r;
+            }
+            case (none) {
+                fcx.ccx.cache_misses += 1u;
+            }
+        }*/
+
         auto result = ty::unify::unify(expected, actual, fcx.var_bindings,
                                        fcx.ccx.tcx);
 
+        //fcx.ccx.unify_cache.insert(cache_key, result);
+
         // FIXME: Shouldn't be necessary, but is until we remove pushdown.
         alt (result) {
             case (ures_ok(?typ)) {
@@ -2837,6 +2856,37 @@ fn check_item(@crate_ctxt ccx, &@ast::item it) {
     }
 }
 
+// Utilities for the unification cache
+
+fn hash_unify_cache_entry(&unify_cache_entry uce) -> uint {
+    auto h = ty::hash_ty(uce._0);
+    h += h << 5u + ty::hash_ty(uce._1);
+
+    auto i = 0u;
+    auto tys_len = vec::len(uce._2);
+    while (i < tys_len) {
+        h += h << 5u + ty::hash_ty(uce._2.(i));
+        i += 1u;
+    }
+
+    ret h;
+}
+
+fn eq_unify_cache_entry(&unify_cache_entry a, &unify_cache_entry b) -> bool {
+    if (!ty::eq_ty(a._0, b._0) || !ty::eq_ty(a._1, b._1)) { ret false; }
+
+    auto i = 0u;
+    auto tys_len = vec::len(a._2);
+    if (vec::len(b._2) != tys_len) { ret false; }
+
+    while (i < tys_len) {
+        if (!ty::eq_ty(a._2.(i), b._2.(i))) { ret false; }
+        i += 1u;
+    }
+
+    ret true;
+}
+
 fn mk_fn_purity_table(&@ast::crate crate) -> @fn_purity_table {
     auto res = @new_def_hash[ast::purity]();
 
@@ -2864,16 +2914,26 @@ fn check_crate(&ty::ctxt tcx, &@ast::crate crate) {
 
     let vec[obj_info] obj_infos = [];
 
+    auto hasher = hash_unify_cache_entry;
+    auto eqer = eq_unify_cache_entry;
+    auto unify_cache =
+        map::mk_hashmap[unify_cache_entry,ty::unify::result](hasher, eqer);
     auto fpt = mk_fn_purity_table(crate); // use a variation on collect
 
     auto ccx = @rec(mutable obj_infos=obj_infos,
                     fn_purity_table=fpt,
+                    unify_cache=unify_cache,
+                    mutable cache_hits=0u,
+                    mutable cache_misses=0u,
                     tcx=tcx);
 
     auto visit = rec(visit_item_pre = bind check_item(ccx, _)
                      with walk::default_visitor());
 
     walk::walk_crate(visit, *crate);
+
+    log #fmt("cache hit rate: %u/%u", ccx.cache_hits,
+             ccx.cache_hits + ccx.cache_misses);
 }
 
 //

trunk/src/rustllvm/Passes2.cpp

@@ -1,5 +1,5 @@
 #include "llvm/Analysis/Passes.h"
-#include "llvm/Support/StandardPasses.h"
+#include "llvm/Support/PassManagerBuilder.h"
 #include "llvm/PassManager.h"
 #include "llvm-c/Core.h"
 #include <cstdlib>
@@ -8,22 +8,29 @@ using namespace llvm;
 
 extern "C" void LLVMAddStandardFunctionPasses(LLVMPassManagerRef PM,
     unsigned int OptimizationLevel) {
-  createStandardFunctionPasses(unwrap(PM), OptimizationLevel);
+  PassManagerBuilder PMBuilder;
+  PMBuilder.OptLevel = OptimizationLevel;
+  FunctionPassManager *FPM = (FunctionPassManager*) unwrap(PM);
+  PMBuilder.populateFunctionPassManager(*FPM);
 }
 
 extern "C" void LLVMAddStandardModulePasses(LLVMPassManagerRef PM,
     unsigned int OptimizationLevel, LLVMBool OptimizeSize,
     LLVMBool UnitAtATime, LLVMBool UnrollLoops, LLVMBool SimplifyLibCalls,
-    LLVMBool HaveExceptions, unsigned int InliningThreshold) {
-  Pass *InliningPass;
+    unsigned int InliningThreshold) {
+
+  PassManagerBuilder PMBuilder;
+  PMBuilder.OptLevel = OptimizationLevel;
+  PMBuilder.SizeLevel = OptimizeSize;
+  PMBuilder.DisableUnitAtATime = !UnitAtATime;
+  PMBuilder.DisableUnrollLoops = !UnrollLoops;
+
+  PMBuilder.DisableSimplifyLibCalls = !SimplifyLibCalls;
+
   if (InliningThreshold)
-    InliningPass = createFunctionInliningPass(InliningThreshold);
-  else
-    InliningPass = NULL;
+    PMBuilder.Inliner = createFunctionInliningPass(InliningThreshold);
 
-  createStandardModulePasses(unwrap(PM), OptimizationLevel, OptimizeSize,
-                             UnitAtATime, UnrollLoops, SimplifyLibCalls,
-                             HaveExceptions, InliningPass);
+  PassManager *MPM = (PassManager*) unwrap(PM);
+  PMBuilder.populateModulePassManager(*MPM);
 }
 
-

trunk/src/rustllvm/RustWrapper.cpp

@@ -47,7 +47,7 @@ extern "C" const char *LLVMRustGetLastError(void) {
 extern "C" void LLVMAddBasicAliasAnalysisPass(LLVMPassManagerRef PM);
 extern "C" void LLVMAddStandardModulePasses(LLVMPassManagerRef PM,
     unsigned int OptimizationLevel, bool OptimizeSize, bool UnitAtATime,
-    bool UnrollLoops, bool SimplifyLibCalls, bool HaveExceptions,
+    bool UnrollLoops, bool SimplifyLibCalls,
     unsigned int InliningThreshold);
 
 int *RustHackToFetchPassesO = (int*)LLVMAddBasicAliasAnalysisPass;
@@ -80,7 +80,6 @@ extern "C" void LLVMRustWriteOutputFile(LLVMPassManagerRef PMR,
                                         LLVMCodeGenFileType FileType) {
 
   // Set compilation options.
-  llvm::UnwindTablesMandatory = true;
   llvm::NoFramePointerElim = true;
 
   InitializeAllTargets();