---

yaml
---
r: 81406
b: refs/heads/snap-stage3
c: 5dd1145
h: refs/heads/master
v: v3

Author: fhahn

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9ef4463b2a7d2c41fbc1072779951b445c80f95b
+refs/heads/snap-stage3: 5dd1145c9b5e4ee12d6ef6d5d87bcbe0941b174b
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -54,7 +54,7 @@ use middle::trans::glue;
 use middle::trans::inline;
 use middle::trans::llrepr::LlvmRepr;
 use middle::trans::machine;
-use middle::trans::machine::{llalign_of_min, llsize_of};
+use middle::trans::machine::{llalign_of_min, llsize_of, llsize_of_alloc};
 use middle::trans::meth;
 use middle::trans::monomorphize;
 use middle::trans::tvec;
@@ -2911,8 +2911,9 @@ pub fn decl_gc_metadata(ccx: &mut CrateContext, llmod_id: &str) {
     }
 }
 
-pub fn create_module_map(ccx: &mut CrateContext) -> (ValueRef, uint) {
-    let elttype = Type::struct_([ccx.int_type, ccx.int_type], false);
+pub fn create_module_map(ccx: &mut CrateContext) -> (ValueRef, uint, uint) {
+    let str_slice_type = Type::struct_([Type::i8p(), ccx.int_type], false);
+    let elttype = Type::struct_([str_slice_type, ccx.int_type], false);
     let maptype = Type::array(&elttype, ccx.module_data.len() as u64);
     let map = do "_rust_mod_map".with_c_str |buf| {
         unsafe {
@@ -2931,17 +2932,18 @@ pub fn create_module_map(ccx: &mut CrateContext) -> (ValueRef, uint) {
     }
 
     for key in keys.iter() {
-        let val = *ccx.module_data.find_equiv(key).unwrap();
-        let s_const = C_cstr(ccx, *key);
-        let s_ptr = p2i(ccx, s_const);
-        let v_ptr = p2i(ccx, val);
-        let elt = C_struct([s_ptr, v_ptr]);
-        elts.push(elt);
+            let val = *ccx.module_data.find_equiv(key).unwrap();
+            let v_ptr = p2i(ccx, val);
+            let elt = C_struct([
+                C_estr_slice(ccx, *key),
+                v_ptr
+            ]);
+            elts.push(elt);
     }
     unsafe {
         llvm::LLVMSetInitializer(map, C_array(elttype, elts));
     }
-    return (map, keys.len());
+    return (map, keys.len(), llsize_of_alloc(ccx, elttype));
 }
 
 
@@ -3003,17 +3005,19 @@ pub fn fill_crate_map(ccx: &mut CrateContext, map: ValueRef) {
         lib::llvm::SetLinkage(vec_elements, lib::llvm::InternalLinkage);
 
         llvm::LLVMSetInitializer(vec_elements, C_array(ccx.int_type, subcrates));
-        let (mod_map, mod_count) = create_module_map(ccx);
+        let (mod_map, mod_count, mod_struct_size) = create_module_map(ccx);
 
         llvm::LLVMSetInitializer(map, C_struct(
             [C_i32(1),
              C_struct([
                 p2i(ccx, mod_map),
-                C_int(ccx, (mod_count * 16) as int)
+                // byte size of the module map array, an entry consists of two integers
+                C_int(ccx, ((mod_count * mod_struct_size) as int))
              ]),
              C_struct([
                 p2i(ccx, vec_elements),
-                C_int(ccx, (subcrates.len() * 8) as int)
+                // byte size of the subcrates array, an entry consists of an integer
+                C_int(ccx, (subcrates.len() * llsize_of_alloc(ccx, ccx.int_type)) as int)
              ])
         ]));
     }

branches/snap-stage3/src/libstd/rt/crate_map.rs

@@ -11,7 +11,6 @@
 #[cfg(not(stage0))] use cast::transmute;
 use container::MutableSet;
 use hashmap::HashSet;
-use libc::c_char;
 use option::{Some, None};
 use vec::ImmutableVector;
 
@@ -29,19 +28,19 @@ extern {
     static CRATE_MAP: CrateMap<'static>;
 }
 
-pub struct ModEntry {
-    name: *c_char,
+pub struct ModEntry<'self> {
+    name: &'self str,
     log_level: *mut u32
 }
 
 pub struct CrateMapV0<'self> {
-    entries: &'self [ModEntry],
+    entries: &'self [ModEntry<'self>],
     children: &'self [&'self CrateMap<'self>]
 }
 
 pub struct CrateMap<'self> {
     version: i32,
-    entries: &'self [ModEntry],
+    entries: &'self [ModEntry<'self>],
     /// a dynamically sized struct, where all pointers to children are listed adjacent
     /// to the struct, terminated with NULL
     children: &'self [&'self CrateMap<'self>]
@@ -79,7 +78,7 @@ fn version(crate_map: &CrateMap) -> i32 {
 
 #[cfg(not(stage0))]
 fn get_entries_and_children<'a>(crate_map: &'a CrateMap<'a>) ->
-                    (&'a [ModEntry], &'a [&'a CrateMap<'a>]) {
+                    (&'a [ModEntry<'a>], &'a [&'a CrateMap<'a>]) {
     match version(crate_map) {
         0 => {
             unsafe {
@@ -127,34 +126,31 @@ pub fn iter_crate_map<'a>(crate_map: &'a CrateMap<'a>, f: &fn(&ModEntry)) {
 
 #[cfg(test)]
 mod tests {
-    use c_str::ToCStr;
-    use cast::transmute;
     use rt::crate_map::{CrateMap, ModEntry, iter_crate_map};
 
     #[test]
     fn iter_crate_map_duplicates() {
+        let mut level3: u32 = 3;
+
+        let entries = [
+            ModEntry { name: "c::m1", log_level: &mut level3},
+        ];
+
+        let child_crate = CrateMap {
+            version: 1,
+            entries: entries,
+            children: []
+        };
+
+        let root_crate = CrateMap {
+            version: 1,
+            entries: [],
+            children: [&child_crate, &child_crate]
+        };
+
+        let mut cnt = 0;
         unsafe {
-            let mod_name1 = "c::m1".to_c_str();
-            let mut level3: u32 = 3;
-
-            let entries = [
-                ModEntry { name: mod_name1.with_ref(|buf| buf), log_level: &mut level3},
-            ];
-
-            let child_crate = CrateMap {
-                version: 1,
-                entries: entries,
-                children: []
-            };
-
-            let root_crate = CrateMap {
-                version: 1,
-                entries: [],
-                children: [&child_crate, &child_crate]
-            };
-
-            let mut cnt = 0;
-            do iter_crate_map(transmute(&root_crate)) |entry| {
+            do iter_crate_map(&root_crate) |entry| {
                 assert!(*entry.log_level == 3);
                 cnt += 1;
             }
@@ -164,38 +160,36 @@ mod tests {
 
     #[test]
     fn iter_crate_map_follow_children() {
+        let mut level2: u32 = 2;
+        let mut level3: u32 = 3;
+        let child_crate2 = CrateMap {
+            version: 1,
+            entries: [
+                ModEntry { name: "c::m1", log_level: &mut level2},
+                ModEntry { name: "c::m2", log_level: &mut level3},
+            ],
+            children: []
+        };
+
+        let child_crate1 = CrateMap {
+            version: 1,
+            entries: [
+                ModEntry { name: "t::f1", log_level: &mut 1},
+            ],
+            children: [&child_crate2]
+        };
+
+        let root_crate = CrateMap {
+            version: 1,
+            entries: [
+                ModEntry { name: "t::f2", log_level: &mut 0},
+            ],
+            children: [&child_crate1]
+        };
+
+        let mut cnt = 0;
         unsafe {
-            let mod_name1 = "c::m1".to_c_str();
-            let mod_name2 = "c::m2".to_c_str();
-            let mut level2: u32 = 2;
-            let mut level3: u32 = 3;
-            let child_crate2 = CrateMap {
-                version: 1,
-                entries: [
-                    ModEntry { name: mod_name1.with_ref(|buf| buf), log_level: &mut level2},
-                    ModEntry { name: mod_name2.with_ref(|buf| buf), log_level: &mut level3},
-                ],
-                children: []
-            };
-
-            let child_crate1 = CrateMap {
-                version: 1,
-                entries: [
-                    ModEntry { name: "t::f1".to_c_str().with_ref(|buf| buf), log_level: &mut 1},
-                ],
-                children: [&child_crate2]
-            };
-
-            let root_crate = CrateMap {
-                version: 1,
-                entries: [
-                    ModEntry { name: "t::f1".to_c_str().with_ref(|buf| buf), log_level: &mut 0},
-                ],
-                children: [&child_crate1]
-            };
-
-            let mut cnt = 0;
-            do iter_crate_map(transmute(&root_crate)) |entry| {
+            do iter_crate_map(&root_crate) |entry| {
                 assert!(*entry.log_level == cnt);
                 cnt += 1;
             }