Merge branch 'master' of git://github.com/graydon/rust

Conflicts:
	src/boot/fe/ast.ml

Author: tohava

AUTHORS.txt

@@ -15,6 +15,7 @@ Jeff Mulzelaar <[email protected]>
 Jeffrey Yasskin <[email protected]>
 Matt Brubeck <[email protected]>
 Michael Bebenita <[email protected]>
+Or Brostovski <[email protected]>
 Patrick Walton <[email protected]>
 Ralph Giles <[email protected]>
 Roy Frostig <[email protected]>

src/Makefile

@@ -389,11 +389,13 @@ TEST_XFAILS_X86 :=  $(TASK_XFAILS) \
                     test/run-pass/child-outlives-parent.rs \
                     test/run-pass/clone-with-exterior.rs \
                     test/run-pass/constrained-type.rs \
+                    test/run-pass/destructor-ordering.rs \
                     test/run-pass/obj-as.rs \
                     test/run-pass/vec-slice.rs \
                     test/run-pass/fn-lval.rs \
                     test/run-pass/generic-fn-infer.rs \
                     test/run-pass/generic-recursive-tag.rs \
+                    test/run-pass/int-lib.rs \
                     test/run-pass/iter-ret.rs \
                     test/run-pass/lib-deque.rs \
                     test/run-pass/lib-map.rs \
@@ -418,7 +420,6 @@ TEST_XFAILS_LLVM := $(TASK_XFAILS) \
                       alt-tag.rs \
                       arithmetic-interference.rs \
                       argv.rs \
-                      auto-deref.rs \
                       autoderef-full-lval.rs \
                       autoderef-objfn.rs \
                       basic.rs \
@@ -452,7 +453,6 @@ TEST_XFAILS_LLVM := $(TASK_XFAILS) \
                       generic-drop-glue.rs \
                       generic-exterior-box.rs \
                       generic-fn-infer.rs \
-                      generic-fn-twice.rs \
                       generic-fn.rs \
                       generic-obj-with-derived-type.rs \
                       generic-obj.rs \
@@ -464,6 +464,8 @@ TEST_XFAILS_LLVM := $(TASK_XFAILS) \
                       i8-incr.rs \
                       import.rs \
                       inner-module.rs \
+                      integral-indexing.rs \
+                      int-lib.rs \
                       iter-range.rs \
                       iter-ret.rs \
                       large-records.rs \
@@ -481,8 +483,6 @@ TEST_XFAILS_LLVM := $(TASK_XFAILS) \
                       mutable-alias-vec.rs \
                       mutable-vec-drop.rs \
                       mutual-recursion-group.rs \
-                      native-mod.rc \
-                      native.rc \
                       obj-as.rs \
                       obj-drop.rs \
                       obj-dtor.rs \
@@ -506,6 +506,7 @@ TEST_XFAILS_LLVM := $(TASK_XFAILS) \
                       str-append.rs \
                       str-concat.rs \
                       str-idx.rs \
+                      str-lib.rs \
                       tag.rs \
                       tail-cps.rs \
                       tail-direct.rs \

src/boot/be/il.ml

@@ -695,7 +695,7 @@ type emitter = { mutable emit_pc: int;
                  emit_target_specific: (emitter -> quad -> unit);
                  mutable emit_quads: quads;
                  emit_annotations: (int,string) Hashtbl.t;
-                 emit_size_cache: ((size,operand) Hashtbl.t) Stack.t;
+                 emit_size_cache: (size,operand) Hashtbl.t;
                  emit_node: node_id option;
                }
 
@@ -722,7 +722,7 @@ let new_emitter
     emit_target_specific = emit_target_specific;
     emit_quads = Array.create 4 badq;
     emit_annotations = Hashtbl.create 0;
-    emit_size_cache = Stack.create ();
+    emit_size_cache = Hashtbl.create 0;
     emit_node = node;
   }
 ;;

src/boot/be/x86.ml

@@ -302,19 +302,49 @@ let emit_target_specific
               | Il.IMOD | Il.UMOD ->
                   let dst_eax = hr_like_cell eax dst in
                   let lhs_eax = hr_like_op eax lhs in
-                  let rhs_ecx = hr_like_op ecx lhs in
-                    if lhs <> (Il.Cell lhs_eax)
-                    then mov lhs_eax lhs;
-                    if rhs <> (Il.Cell rhs_ecx)
-                    then mov rhs_ecx rhs;
+                  let rhs_ecx = hr_like_op ecx rhs in
+                    (* Horrible: we bounce complex mul inputs off spill slots
+                     * to ensure non-interference between the temporaries used
+                     * during mem-base-reg reloads and the registers we're
+                     * preparing.  *)
+                  let next_spill_like op =
+                    Il.Mem (Il.next_spill_slot e
+                              (Il.ScalarTy (Il.operand_scalar_ty op)))
+                  in
+                  let is_mem op =
+                    match op with
+                        Il.Cell (Il.Mem _) -> true
+                      | _ -> false
+                  in
+                  let bounce_lhs = is_mem lhs in
+                  let bounce_rhs = is_mem rhs in
+                  let lhs_spill = next_spill_like lhs in
+                  let rhs_spill = next_spill_like rhs in
+
+                    if bounce_lhs
+                    then mov lhs_spill lhs;
+
+                    if bounce_rhs
+                    then mov rhs_spill rhs;
+
+                    mov lhs_eax
+                      (if bounce_lhs
+                       then (Il.Cell lhs_spill)
+                       else lhs);
+
+                    mov rhs_ecx
+                      (if bounce_rhs
+                       then (Il.Cell rhs_spill)
+                       else rhs);
+                    
                     put (Il.Binary
                            { b with
                                Il.binary_lhs = (Il.Cell lhs_eax);
                                Il.binary_rhs = (Il.Cell rhs_ecx);
                                Il.binary_dst = dst_eax; });
                     if dst <> dst_eax
                     then mov dst (Il.Cell dst_eax);
-
+                    
               | _ when (Il.Cell dst) <> lhs ->
                   mov dst lhs;
                   put (Il.Binary
@@ -1936,15 +1966,20 @@ let zero (dst:Il.cell) (count:Il.operand) : Asm.frag =
 ;;
 
 let mov (signed:bool) (dst:Il.cell) (src:Il.operand) : Asm.frag =
-  if is_ty8 (Il.cell_scalar_ty dst) || is_ty8 (Il.operand_scalar_ty src)
+  if is_ty8 (Il.cell_scalar_ty dst)
   then
     begin
-      (match dst with
-           Il.Reg (Il.Hreg r, _)
-           -> assert (is_ok_r8 r) | _ -> ());
-      (match src with
-           Il.Cell (Il.Reg (Il.Hreg r, _))
-           -> assert (is_ok_r8 r) | _ -> ());
+      match dst with
+          Il.Reg (Il.Hreg r, _) -> assert (is_ok_r8 r)
+        | _ -> ()
+    end;
+
+  if is_ty8 (Il.operand_scalar_ty src)
+  then
+    begin
+      match src with
+          Il.Cell (Il.Reg (Il.Hreg r, _)) -> assert (is_ok_r8 r)
+        | _ -> ()
     end;
 
   match (signed, dst, src) with

src/boot/fe/item.ml

@@ -253,7 +253,10 @@ and parse_stmts (ps:pstate) : Ast.stmt array =
                             let lv = name_to_lval apos bpos name in
                               Ast.PAT_tag (lv, paren_comma_list parse_pat ps)
 
-                      | LIT_INT _ | LIT_CHAR _ | LIT_BOOL _ ->
+                      | LIT_INT _
+                      | LIT_UINT _
+                      | LIT_CHAR _
+                      | LIT_BOOL _ ->
                           Ast.PAT_lit (Pexp.parse_lit ps)
 
                       | UNDERSCORE -> bump ps; Ast.PAT_wild

src/boot/fe/pexp.ml

@@ -817,11 +817,33 @@ and parse_or_pexp (ps:pstate) : pexp =
     step lhs
 
 
+and parse_as_pexp (ps:pstate) : pexp =
+  let apos = lexpos ps in
+  let pexp = ctxt "as pexp" parse_or_pexp ps in
+  let rec step accum =
+    match peek ps with
+        AS ->
+          bump ps;
+          let tapos = lexpos ps in
+          let t = parse_ty ps in
+          let bpos = lexpos ps in
+          let t = span ps tapos bpos t in
+          let node =
+            span ps apos bpos
+              (PEXP_unop ((Ast.UNOP_cast t), accum))
+          in
+            step node
+
+      | _ -> accum
+  in
+    step pexp
+
+
 and parse_relational_pexp (ps:pstate) : pexp =
   let name = "relational pexp" in
   let apos = lexpos ps in
-  let lhs = ctxt (name ^ " lhs") parse_or_pexp ps in
-  let build = binop_build ps name apos parse_or_pexp in
+  let lhs = ctxt (name ^ " lhs") parse_as_pexp ps in
+  let build = binop_build ps name apos parse_as_pexp in
   let rec step accum =
     match peek ps with
         LT -> build accum step Ast.BINOP_lt
@@ -883,30 +905,8 @@ and parse_oror_pexp (ps:pstate) : pexp =
     step lhs
 
 
-and parse_as_pexp (ps:pstate) : pexp =
-  let apos = lexpos ps in
-  let pexp = ctxt "as pexp" parse_oror_pexp ps in
-  let rec step accum =
-    match peek ps with
-        AS ->
-          bump ps;
-          let tapos = lexpos ps in
-          let t = parse_ty ps in
-          let bpos = lexpos ps in
-          let t = span ps tapos bpos t in
-          let node =
-            span ps apos bpos
-              (PEXP_unop ((Ast.UNOP_cast t), accum))
-          in
-            step node
-
-      | _ -> accum
-  in
-    step pexp
-
-
 and parse_pexp (ps:pstate) : pexp =
-  parse_as_pexp ps
+  parse_oror_pexp ps
 
 and parse_mutable_and_pexp (ps:pstate) : (Ast.mutability * pexp) =
   let mutability = parse_mutability ps in

src/boot/llvm/lltrans.ml

@@ -588,7 +588,7 @@ let trans_crate
     (* Maps a fn's or block's id to an LLVM metadata node (subprogram or
        lexical block) representing it. *)
   let (dbg_llscopes:(node_id, Llvm.llvalue) Hashtbl.t) = Hashtbl.create 0 in
-  let declare_mod_item
+  let rec declare_mod_item
       (name:Ast.ident)
       mod_item
       : unit =
@@ -616,9 +616,8 @@ let trans_crate
         | Ast.MOD_ITEM_type _ ->
             ()  (* Types get translated with their terms. *)
 
-        | Ast.MOD_ITEM_mod _ ->
-            ()  (* Modules simply contain other items that are translated
-                   on their own. *)
+        | Ast.MOD_ITEM_mod (_, items) ->
+            Hashtbl.iter declare_mod_item items
 
         | _ ->
             Common.unimpl (Some id)
@@ -807,6 +806,17 @@ let trans_crate
                             Ast.sprintf_lval lval)
       in
 
+      let trans_callee (fn:Ast.lval) : (Llvm.llvalue * Ast.ty) =
+        let fty = Hashtbl.find sem_cx.ctxt_all_lval_types (lval_base_id fn) in
+          if lval_base_is_item sem_cx fn then
+            let fn_item = lval_item sem_cx fn in
+            let llfn = Hashtbl.find llitems (fn_item.id) in
+              (llfn, fty)
+          else
+            (* indirect call to computed slot *)
+            trans_lval fn
+      in
+
       let trans_atom (atom:Ast.atom) : Llvm.llvalue =
         iflog (fun _ -> log sem_cx "trans_atom: %a" Ast.sprintf_atom atom);
         match atom with
@@ -959,7 +969,7 @@ let trans_crate
               | Ast.STMT_call (dest, fn, args) ->
                   let llargs = Array.map trans_atom args in
                   let (lldest, _) = trans_lval dest in
-                  let (llfn, _) = trans_lval fn in
+                  let (llfn, _) = trans_callee fn in
                   let llallargs = Array.append [| lldest; lltask |] llargs in
                   let llrv = build_call llfn llallargs "" llbuilder in
                     Llvm.set_instruction_call_conv Llvm.CallConv.c llrv;
@@ -1072,13 +1082,22 @@ let trans_crate
       ignore (Llvm.build_br llbodyblock llinitbuilder)
   in
 
-  let trans_mod_item
-      (_:Ast.ident)
-      { node = { Ast.decl_item = (item:Ast.mod_item') }; id = id }
+  let rec trans_mod_item
+      (name:Ast.ident)
+      mod_item
       : unit =
+    let { node = { Ast.decl_item = (item:Ast.mod_item') }; id = id } =
+      mod_item in
     match item with
-        Ast.MOD_ITEM_fn fn -> trans_fn fn id
-      | _ -> ()
+        Ast.MOD_ITEM_type _ ->
+          ()  (* Types get translated with their terms. *)
+      | Ast.MOD_ITEM_mod (_, items) ->
+          Hashtbl.iter trans_mod_item items
+      | Ast.MOD_ITEM_fn fn -> trans_fn fn id
+      | _ -> Common.unimpl (Some id)
+          "LLVM module declaration for: %a"
+            Ast.sprintf_mod_item (name, mod_item)
+
   in
 
   let exit_task_glue =