Add new TransItem for global_asm trans

mrhota · mrhota · commit 4ed08b5fc14f · 2017-03-30T00:25:43.000-05:00
diff --git a/src/librustc_trans/asm.rs b/src/librustc_trans/asm.rs
@@ -124,3 +124,11 @@ pub fn trans_inline_asm<'a, 'tcx>(
             llvm::LLVMMDNodeInContext(bcx.ccx.llcx(), &val, 1));
     }
 }
+
+pub fn trans_global_asm<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
+                                  ga: &hir::GlobalAsm) {
+    let asm = CString::new(ga.asm.as_str().as_bytes()).unwrap();
+    unsafe {
+        llvm::LLVMSetModuleInlineAsm(ccx.llmod(), asm.as_ptr());
+    }
+}
diff --git a/src/librustc_trans/collector.rs b/src/librustc_trans/collector.rs
@@ -349,6 +349,9 @@ fn collect_items_rec<'a, 'tcx: 'a>(scx: &SharedCrateContext<'a, 'tcx>,
 
             collect_neighbours(scx, instance, &mut neighbors);
         }
+        TransItem::GlobalAsm(..) => {
+            recursion_depth_reset = None;
+        }
     }
 
     record_inlining_canditates(scx.tcx(), starting_point, &neighbors[..], inlining_map);
@@ -811,7 +814,6 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> {
             hir::ItemExternCrate(..) |
             hir::ItemUse(..)         |
             hir::ItemForeignMod(..)  |
-            hir::ItemGlobalAsm(..)   |
             hir::ItemTy(..)          |
             hir::ItemDefaultImpl(..) |
             hir::ItemTrait(..)       |
@@ -841,6 +843,12 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> {
                     }
                 }
             }
+            hir::ItemGlobalAsm(..) => {
+                debug!("RootCollector: ItemGlobalAsm({})",
+                       def_id_to_string(self.scx.tcx(),
+                                        self.scx.tcx().hir.local_def_id(item.id)));
+                self.output.push(TransItem::GlobalAsm(item.id));
+            }
             hir::ItemStatic(..) => {
                 debug!("RootCollector: ItemStatic({})",
                        def_id_to_string(self.scx.tcx(),
diff --git a/src/librustc_trans/partitioning.rs b/src/librustc_trans/partitioning.rs
@@ -185,15 +185,16 @@ impl<'tcx> CodegenUnit<'tcx> {
             symbol_name.len().hash(&mut state);
             symbol_name.hash(&mut state);
             let exported = match item {
-               TransItem::Fn(ref instance) => {
-                   let node_id =
-                       scx.tcx().hir.as_local_node_id(instance.def_id());
+                TransItem::Fn(ref instance) => {
+                    let node_id =
+                        scx.tcx().hir.as_local_node_id(instance.def_id());
                     node_id.map(|node_id| exported_symbols.contains(&node_id))
-                           .unwrap_or(false)
-               }
-               TransItem::Static(node_id) => {
+                        .unwrap_or(false)
+                }
+                TransItem::Static(node_id) => {
                     exported_symbols.contains(&node_id)
-               }
+                }
+                TransItem::GlobalAsm(..) => true,
             };
             exported.hash(&mut state);
         }
@@ -243,7 +244,9 @@ impl<'tcx> CodegenUnit<'tcx> {
                 TransItem::Fn(instance) => {
                     tcx.hir.as_local_node_id(instance.def_id())
                 }
-                TransItem::Static(node_id) => Some(node_id),
+                TransItem::Static(node_id) | TransItem::GlobalAsm(node_id) => {
+                    Some(node_id)
+                }
             }
         }
     }
@@ -338,7 +341,8 @@ fn place_root_translation_items<'a, 'tcx, I>(scx: &SharedCrateContext<'a, 'tcx>,
                 None => {
                     match trans_item {
                         TransItem::Fn(..) |
-                        TransItem::Static(..) => llvm::ExternalLinkage,
+                        TransItem::Static(..) |
+                        TransItem::GlobalAsm(..) => llvm::ExternalLinkage,
                     }
                 }
             };
@@ -483,7 +487,8 @@ fn characteristic_def_id_of_trans_item<'a, 'tcx>(scx: &SharedCrateContext<'a, 't
 
             Some(def_id)
         }
-        TransItem::Static(node_id) => Some(tcx.hir.local_def_id(node_id)),
+        TransItem::Static(node_id) |
+        TransItem::GlobalAsm(node_id) => Some(tcx.hir.local_def_id(node_id)),
     }
 }
 
diff --git a/src/librustc_trans/symbol_map.rs b/src/librustc_trans/symbol_map.rs
@@ -99,7 +99,10 @@ impl<'tcx> SymbolMap<'tcx> {
                 TransItem::Fn(Instance { def, .. }) => {
                     tcx.hir.as_local_node_id(def.def_id())
                 }
-                TransItem::Static(node_id) => Some(node_id),
+                TransItem::Static(node_id) |
+                TransItem::GlobalAsm(node_id) => {
+                    Some(node_id)
+                }
             }.map(|node_id| {
                 tcx.hir.span(node_id)
             })
diff --git a/src/librustc_trans/trans_item.rs b/src/librustc_trans/trans_item.rs
@@ -14,6 +14,7 @@
 //! item-path. This is used for unit testing the code that generates
 //! paths etc in all kinds of annoying scenarios.
 
+use asm;
 use attributes;
 use base;
 use consts;
@@ -38,7 +39,8 @@ use std::iter;
 #[derive(PartialEq, Eq, Clone, Copy, Debug, Hash)]
 pub enum TransItem<'tcx> {
     Fn(Instance<'tcx>),
-    Static(NodeId)
+    Static(NodeId),
+    GlobalAsm(NodeId),
 }
 
 /// Describes how a translation item will be instantiated in object files.
@@ -89,6 +91,14 @@ impl<'a, 'tcx> TransItem<'tcx> {
                     span_bug!(item.span, "Mismatch between hir::Item type and TransItem type")
                 }
             }
+            TransItem::GlobalAsm(node_id) => {
+                let item = ccx.tcx().hir.expect_item(node_id);
+                if let hir::ItemGlobalAsm(ref ga) = item.node {
+                    asm::trans_global_asm(ccx, ga);
+                } else {
+                    span_bug!(item.span, "Mismatch between hir::Item type and TransItem type")
+                }
+            }
             TransItem::Fn(instance) => {
                 let _task = ccx.tcx().dep_graph.in_task(
                     DepNode::TransCrateItem(instance.def_id())); // (*)
@@ -123,6 +133,7 @@ impl<'a, 'tcx> TransItem<'tcx> {
             TransItem::Fn(instance) => {
                 TransItem::predefine_fn(ccx, instance, linkage, &symbol_name);
             }
+            TransItem::GlobalAsm(..) => {}
         }
 
         debug!("END PREDEFINING '{} ({})' in cgu {}",
@@ -185,6 +196,10 @@ impl<'a, 'tcx> TransItem<'tcx> {
                 let def_id = scx.tcx().hir.local_def_id(node_id);
                 symbol_names::symbol_name(Instance::mono(scx.tcx(), def_id), scx)
             }
+            TransItem::GlobalAsm(node_id) => {
+                let def_id = scx.tcx().hir.local_def_id(node_id);
+                format!("global_asm_{:?}", def_id)
+            }
         }
     }
 
@@ -202,6 +217,7 @@ impl<'a, 'tcx> TransItem<'tcx> {
                 }
             }
             TransItem::Static(..) => InstantiationMode::GloballyShared,
+            TransItem::GlobalAsm(..) => InstantiationMode::GloballyShared,
         }
     }
 
@@ -210,14 +226,16 @@ impl<'a, 'tcx> TransItem<'tcx> {
             TransItem::Fn(ref instance) => {
                 instance.substs.types().next().is_some()
             }
-            TransItem::Static(..)   => false,
+            TransItem::Static(..) |
+            TransItem::GlobalAsm(..) => false,
         }
     }
 
     pub fn explicit_linkage(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Option<llvm::Linkage> {
         let def_id = match *self {
             TransItem::Fn(ref instance) => instance.def_id(),
             TransItem::Static(node_id) => tcx.hir.local_def_id(node_id),
+            TransItem::GlobalAsm(..) => return None,
         };
 
         let attributes = tcx.get_attrs(def_id);
@@ -249,6 +267,9 @@ impl<'a, 'tcx> TransItem<'tcx> {
                 let instance = Instance::new(def_id, tcx.intern_substs(&[]));
                 to_string_internal(tcx, "static ", instance)
             },
+            TransItem::GlobalAsm(..) => {
+                "global_asm".to_string()
+            }
         };
 
         fn to_string_internal<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
@@ -273,6 +294,9 @@ impl<'a, 'tcx> TransItem<'tcx> {
             TransItem::Static(id) => {
                 format!("Static({:?})", id)
             }
+            TransItem::GlobalAsm(id) => {
+                format!("GlobalAsm({:?})", id)
+            }
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -124,3 +124,11 @@ pub fn trans_inline_asm<'a, 'tcx>(`
`124`	`124`	`llvm::LLVMMDNodeInContext(bcx.ccx.llcx(), &val, 1));`
`125`	`125`	`}`
`126`	`126`	`}`
	`127`	`+`
	`128`	`+pub fn trans_global_asm<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,`
	`129`	`+ ga: &hir::GlobalAsm) {`
	`130`	`+ let asm = CString::new(ga.asm.as_str().as_bytes()).unwrap();`
	`131`	`+ unsafe {`
	`132`	`+ llvm::LLVMSetModuleInlineAsm(ccx.llmod(), asm.as_ptr());`
	`133`	`+ }`
	`134`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -349,6 +349,9 @@ fn collect_items_rec<'a, 'tcx: 'a>(scx: &SharedCrateContext<'a, 'tcx>,`
`349`	`349`
`350`	`350`	`collect_neighbours(scx, instance, &mut neighbors);`
`351`	`351`	`}`
	`352`	`+ TransItem::GlobalAsm(..) => {`
	`353`	`+ recursion_depth_reset = None;`
	`354`	`+ }`
`352`	`355`	`}`
`353`	`356`
`354`	`357`	`record_inlining_canditates(scx.tcx(), starting_point, &neighbors[..], inlining_map);`
`@@ -811,7 +814,6 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> {`
`811`	`814`	`hir::ItemExternCrate(..) \|`
`812`	`815`	`hir::ItemUse(..) \|`
`813`	`816`	`hir::ItemForeignMod(..) \|`
`814`		`- hir::ItemGlobalAsm(..) \|`
`815`	`817`	`hir::ItemTy(..) \|`
`816`	`818`	`hir::ItemDefaultImpl(..) \|`
`817`	`819`	`hir::ItemTrait(..) \|`
`@@ -841,6 +843,12 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> {`
`841`	`843`	`}`
`842`	`844`	`}`
`843`	`845`	`}`
	`846`	`+ hir::ItemGlobalAsm(..) => {`
	`847`	`+ debug!("RootCollector: ItemGlobalAsm({})",`
	`848`	`+ def_id_to_string(self.scx.tcx(),`
	`849`	`+ self.scx.tcx().hir.local_def_id(item.id)));`
	`850`	`+ self.output.push(TransItem::GlobalAsm(item.id));`
	`851`	`+ }`
`844`	`852`	`hir::ItemStatic(..) => {`
`845`	`853`	`debug!("RootCollector: ItemStatic({})",`
`846`	`854`	`def_id_to_string(self.scx.tcx(),`
Original file line number	Diff line number	Diff line change
`@@ -185,15 +185,16 @@ impl<'tcx> CodegenUnit<'tcx> {`
`185`	`185`	`symbol_name.len().hash(&mut state);`
`186`	`186`	`symbol_name.hash(&mut state);`
`187`	`187`	`let exported = match item {`
`188`		`- TransItem::Fn(ref instance) => {`
`189`		`- let node_id =`
`190`		`- scx.tcx().hir.as_local_node_id(instance.def_id());`
	`188`	`+ TransItem::Fn(ref instance) => {`
	`189`	`+ let node_id =`
	`190`	`+ scx.tcx().hir.as_local_node_id(instance.def_id());`
`191`	`191`	`node_id.map(\|node_id\| exported_symbols.contains(&node_id))`
`192`		`- .unwrap_or(false)`
`193`		`- }`
`194`		`- TransItem::Static(node_id) => {`
	`192`	`+ .unwrap_or(false)`
	`193`	`+ }`
	`194`	`+ TransItem::Static(node_id) => {`
`195`	`195`	`exported_symbols.contains(&node_id)`
`196`		`- }`
	`196`	`+ }`
	`197`	`+ TransItem::GlobalAsm(..) => true,`
`197`	`198`	`};`
`198`	`199`	`exported.hash(&mut state);`
`199`	`200`	`}`
`@@ -243,7 +244,9 @@ impl<'tcx> CodegenUnit<'tcx> {`
`243`	`244`	`TransItem::Fn(instance) => {`
`244`	`245`	`tcx.hir.as_local_node_id(instance.def_id())`
`245`	`246`	`}`
`246`		`- TransItem::Static(node_id) => Some(node_id),`
	`247`	`+ TransItem::Static(node_id) \| TransItem::GlobalAsm(node_id) => {`
	`248`	`+ Some(node_id)`
	`249`	`+ }`
`247`	`250`	`}`
`248`	`251`	`}`
`249`	`252`	`}`
`@@ -338,7 +341,8 @@ fn place_root_translation_items<'a, 'tcx, I>(scx: &SharedCrateContext<'a, 'tcx>,`
`338`	`341`	`None => {`
`339`	`342`	`match trans_item {`
`340`	`343`	`TransItem::Fn(..) \|`
`341`		`- TransItem::Static(..) => llvm::ExternalLinkage,`
	`344`	`+ TransItem::Static(..) \|`
	`345`	`+ TransItem::GlobalAsm(..) => llvm::ExternalLinkage,`
`342`	`346`	`}`
`343`	`347`	`}`
`344`	`348`	`};`
`@@ -483,7 +487,8 @@ fn characteristic_def_id_of_trans_item<'a, 'tcx>(scx: &SharedCrateContext<'a, 't`
`483`	`487`
`484`	`488`	`Some(def_id)`
`485`	`489`	`}`
`486`		`- TransItem::Static(node_id) => Some(tcx.hir.local_def_id(node_id)),`
	`490`	`+ TransItem::Static(node_id) \|`
	`491`	`+ TransItem::GlobalAsm(node_id) => Some(tcx.hir.local_def_id(node_id)),`
`487`	`492`	`}`
`488`	`493`	`}`
`489`	`494`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`//! item-path. This is used for unit testing the code that generates`
`15`	`15`	`//! paths etc in all kinds of annoying scenarios.`
`16`	`16`
	`17`	`+use asm;`
`17`	`18`	`use attributes;`
`18`	`19`	`use base;`
`19`	`20`	`use consts;`
`@@ -38,7 +39,8 @@ use std::iter;`
`38`	`39`	`#[derive(PartialEq, Eq, Clone, Copy, Debug, Hash)]`
`39`	`40`	`pub enum TransItem<'tcx> {`
`40`	`41`	`Fn(Instance<'tcx>),`
`41`		`- Static(NodeId)`
	`42`	`+ Static(NodeId),`
	`43`	`+ GlobalAsm(NodeId),`
`42`	`44`	`}`
`43`	`45`
`44`	`46`	`/// Describes how a translation item will be instantiated in object files.`
`@@ -89,6 +91,14 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`89`	`91`	`span_bug!(item.span, "Mismatch between hir::Item type and TransItem type")`
`90`	`92`	`}`
`91`	`93`	`}`
	`94`	`+ TransItem::GlobalAsm(node_id) => {`
	`95`	`+ let item = ccx.tcx().hir.expect_item(node_id);`
	`96`	`+ if let hir::ItemGlobalAsm(ref ga) = item.node {`
	`97`	`+ asm::trans_global_asm(ccx, ga);`
	`98`	`+ } else {`
	`99`	`+ span_bug!(item.span, "Mismatch between hir::Item type and TransItem type")`
	`100`	`+ }`
	`101`	`+ }`
`92`	`102`	`TransItem::Fn(instance) => {`
`93`	`103`	`let _task = ccx.tcx().dep_graph.in_task(`
`94`	`104`	`DepNode::TransCrateItem(instance.def_id())); // (*)`
`@@ -123,6 +133,7 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`123`	`133`	`TransItem::Fn(instance) => {`
`124`	`134`	`TransItem::predefine_fn(ccx, instance, linkage, &symbol_name);`
`125`	`135`	`}`
	`136`	`+ TransItem::GlobalAsm(..) => {}`
`126`	`137`	`}`
`127`	`138`
`128`	`139`	`debug!("END PREDEFINING '{} ({})' in cgu {}",`
`@@ -185,6 +196,10 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`185`	`196`	`let def_id = scx.tcx().hir.local_def_id(node_id);`
`186`	`197`	`symbol_names::symbol_name(Instance::mono(scx.tcx(), def_id), scx)`
`187`	`198`	`}`
	`199`	`+ TransItem::GlobalAsm(node_id) => {`
	`200`	`+ let def_id = scx.tcx().hir.local_def_id(node_id);`
	`201`	`+ format!("global_asm_{:?}", def_id)`
	`202`	`+ }`
`188`	`203`	`}`
`189`	`204`	`}`
`190`	`205`
`@@ -202,6 +217,7 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`202`	`217`	`}`
`203`	`218`	`}`
`204`	`219`	`TransItem::Static(..) => InstantiationMode::GloballyShared,`
	`220`	`+ TransItem::GlobalAsm(..) => InstantiationMode::GloballyShared,`
`205`	`221`	`}`
`206`	`222`	`}`
`207`	`223`
`@@ -210,14 +226,16 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`210`	`226`	`TransItem::Fn(ref instance) => {`
`211`	`227`	`instance.substs.types().next().is_some()`
`212`	`228`	`}`
`213`		`- TransItem::Static(..) => false,`
	`229`	`+ TransItem::Static(..) \|`
	`230`	`+ TransItem::GlobalAsm(..) => false,`
`214`	`231`	`}`
`215`	`232`	`}`
`216`	`233`
`217`	`234`	`pub fn explicit_linkage(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Option<llvm::Linkage> {`
`218`	`235`	`let def_id = match *self {`
`219`	`236`	`TransItem::Fn(ref instance) => instance.def_id(),`
`220`	`237`	`TransItem::Static(node_id) => tcx.hir.local_def_id(node_id),`
	`238`	`+ TransItem::GlobalAsm(..) => return None,`
`221`	`239`	`};`
`222`	`240`
`223`	`241`	`let attributes = tcx.get_attrs(def_id);`
`@@ -249,6 +267,9 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`249`	`267`	`let instance = Instance::new(def_id, tcx.intern_substs(&[]));`
`250`	`268`	`to_string_internal(tcx, "static ", instance)`
`251`	`269`	`},`
	`270`	`+ TransItem::GlobalAsm(..) => {`
	`271`	`+ "global_asm".to_string()`
	`272`	`+ }`
`252`	`273`	`};`
`253`	`274`
`254`	`275`	`fn to_string_internal<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,`
`@@ -273,6 +294,9 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`273`	`294`	`TransItem::Static(id) => {`
`274`	`295`	`format!("Static({:?})", id)`
`275`	`296`	`}`
	`297`	`+ TransItem::GlobalAsm(id) => {`
	`298`	`+ format!("GlobalAsm({:?})", id)`
	`299`	`+ }`
`276`	`300`	`}`
`277`	`301`	`}`
`278`	`302`	`}`