Add new TransItem for global_asm trans

mrhota · mrhota · commit f40985b96163 · 2017-03-21T10:03:52.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
@@ -361,6 +361,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);
@@ -1157,7 +1160,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(..)       |
@@ -1188,6 +1190,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) => {
+                TransItem::Fn(ref instance) => {
                     let node_id = scx.tcx().hir.as_local_node_id(instance.def);
                     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::DropGlue(..) => false,
+                }
+                TransItem::DropGlue(..) => false,
+                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)
                 }
-                TransItem::Static(node_id) => Some(node_id),
+                TransItem::Static(node_id) | TransItem::GlobalAsm(node_id) => {
+                    Some(node_id)
+                }
                 TransItem::DropGlue(_) => None,
             }
         }
@@ -339,7 +342,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,
                         TransItem::DropGlue(..) => unreachable!(),
                     }
                 }
@@ -477,7 +481,8 @@ fn characteristic_def_id_of_trans_item<'a, 'tcx>(scx: &SharedCrateContext<'a, 't
             Some(instance.def)
         }
         TransItem::DropGlue(dg) => characteristic_def_id_of_type(dg.ty()),
-        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)
                 }
-                TransItem::Static(node_id) => Some(node_id),
+                TransItem::Static(node_id) |
+                TransItem::GlobalAsm(node_id) => {
+                    Some(node_id)
+                }
                 TransItem::DropGlue(_) => None,
             }.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;
@@ -42,7 +43,8 @@ use std::iter;
 pub enum TransItem<'tcx> {
     DropGlue(DropGlueKind<'tcx>),
     Fn(Instance<'tcx>),
-    Static(NodeId)
+    Static(NodeId),
+    GlobalAsm(NodeId),
 }
 
 /// Describes how a translation item will be instantiated in object files.
@@ -93,6 +95,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)); // (*)
@@ -133,6 +143,7 @@ impl<'a, 'tcx> TransItem<'tcx> {
             TransItem::DropGlue(dg) => {
                 TransItem::predefine_drop_glue(ccx, dg, linkage, &symbol_name);
             }
+            TransItem::GlobalAsm(..) => {}
         }
 
         debug!("END PREDEFINING '{} ({})' in cgu {}",
@@ -235,14 +246,19 @@ impl<'a, 'tcx> TransItem<'tcx> {
                 };
                 symbol_names::exported_name_from_type_and_prefix(scx, dg.ty(), prefix)
             }
+            TransItem::GlobalAsm(node_id) => {
+                let def_id = scx.tcx().hir.local_def_id(node_id);
+                format!("global_asm_{:?}", def_id)
+            }
         }
     }
 
     pub fn is_from_extern_crate(&self) -> bool {
         match *self {
             TransItem::Fn(ref instance) => !instance.def.is_local(),
             TransItem::DropGlue(..) |
-            TransItem::Static(..)   => false,
+            TransItem::Static(..) |
+            TransItem::GlobalAsm(..) => false,
         }
     }
 
@@ -261,6 +277,7 @@ impl<'a, 'tcx> TransItem<'tcx> {
             }
             TransItem::DropGlue(..) => InstantiationMode::LocalCopy,
             TransItem::Static(..) => InstantiationMode::GloballyShared,
+            TransItem::GlobalAsm(..) => InstantiationMode::GloballyShared,
         }
     }
 
@@ -270,15 +287,16 @@ impl<'a, 'tcx> TransItem<'tcx> {
                 instance.substs.types().next().is_some()
             }
             TransItem::DropGlue(..) |
-            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,
             TransItem::Static(node_id) => tcx.hir.local_def_id(node_id),
-            TransItem::DropGlue(..) => return None,
+            TransItem::DropGlue(..) | TransItem::GlobalAsm(..) => return None,
         };
 
         let attributes = tcx.get_attrs(def_id);
@@ -320,6 +338,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>,
@@ -351,6 +372,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
`@@ -361,6 +361,9 @@ fn collect_items_rec<'a, 'tcx: 'a>(scx: &SharedCrateContext<'a, 'tcx>,`
`361`	`361`
`362`	`362`	`collect_neighbours(scx, instance, &mut neighbors);`
`363`	`363`	`}`
	`364`	`+ TransItem::GlobalAsm(..) => {`
	`365`	`+ recursion_depth_reset = None;`
	`366`	`+ }`
`364`	`367`	`}`
`365`	`368`
`366`	`369`	`record_inlining_canditates(scx.tcx(), starting_point, &neighbors[..], inlining_map);`
`@@ -1157,7 +1160,6 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> {`
`1157`	`1160`	`hir::ItemExternCrate(..) \|`
`1158`	`1161`	`hir::ItemUse(..) \|`
`1159`	`1162`	`hir::ItemForeignMod(..) \|`
`1160`		`- hir::ItemGlobalAsm(..) \|`
`1161`	`1163`	`hir::ItemTy(..) \|`
`1162`	`1164`	`hir::ItemDefaultImpl(..) \|`
`1163`	`1165`	`hir::ItemTrait(..) \|`
`@@ -1188,6 +1190,12 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> {`
`1188`	`1190`	`}`
`1189`	`1191`	`}`
`1190`	`1192`	`}`
	`1193`	`+ hir::ItemGlobalAsm(..) => {`
	`1194`	`+ debug!("RootCollector: ItemGlobalAsm({})",`
	`1195`	`+ def_id_to_string(self.scx.tcx(),`
	`1196`	`+ self.scx.tcx().hir.local_def_id(item.id)));`
	`1197`	`+ self.output.push(TransItem::GlobalAsm(item.id));`
	`1198`	`+ }`
`1191`	`1199`	`hir::ItemStatic(..) => {`
`1192`	`1200`	`debug!("RootCollector: ItemStatic({})",`
`1193`	`1201`	`def_id_to_string(self.scx.tcx(),`
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;`
`@@ -42,7 +43,8 @@ use std::iter;`
`42`	`43`	`pub enum TransItem<'tcx> {`
`43`	`44`	`DropGlue(DropGlueKind<'tcx>),`
`44`	`45`	`Fn(Instance<'tcx>),`
`45`		`- Static(NodeId)`
	`46`	`+ Static(NodeId),`
	`47`	`+ GlobalAsm(NodeId),`
`46`	`48`	`}`
`47`	`49`
`48`	`50`	`/// Describes how a translation item will be instantiated in object files.`
`@@ -93,6 +95,14 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`93`	`95`	`span_bug!(item.span, "Mismatch between hir::Item type and TransItem type")`
`94`	`96`	`}`
`95`	`97`	`}`
	`98`	`+ TransItem::GlobalAsm(node_id) => {`
	`99`	`+ let item = ccx.tcx().hir.expect_item(node_id);`
	`100`	`+ if let hir::ItemGlobalAsm(ref ga) = item.node {`
	`101`	`+ asm::trans_global_asm(ccx, ga);`
	`102`	`+ } else {`
	`103`	`+ span_bug!(item.span, "Mismatch between hir::Item type and TransItem type")`
	`104`	`+ }`
	`105`	`+ }`
`96`	`106`	`TransItem::Fn(instance) => {`
`97`	`107`	`let _task = ccx.tcx().dep_graph.in_task(`
`98`	`108`	`DepNode::TransCrateItem(instance.def)); // (*)`
`@@ -133,6 +143,7 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`133`	`143`	`TransItem::DropGlue(dg) => {`
`134`	`144`	`TransItem::predefine_drop_glue(ccx, dg, linkage, &symbol_name);`
`135`	`145`	`}`
	`146`	`+ TransItem::GlobalAsm(..) => {}`
`136`	`147`	`}`
`137`	`148`
`138`	`149`	`debug!("END PREDEFINING '{} ({})' in cgu {}",`
`@@ -235,14 +246,19 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`235`	`246`	`};`
`236`	`247`	`symbol_names::exported_name_from_type_and_prefix(scx, dg.ty(), prefix)`
`237`	`248`	`}`
	`249`	`+ TransItem::GlobalAsm(node_id) => {`
	`250`	`+ let def_id = scx.tcx().hir.local_def_id(node_id);`
	`251`	`+ format!("global_asm_{:?}", def_id)`
	`252`	`+ }`
`238`	`253`	`}`
`239`	`254`	`}`
`240`	`255`
`241`	`256`	`pub fn is_from_extern_crate(&self) -> bool {`
`242`	`257`	`match *self {`
`243`	`258`	`TransItem::Fn(ref instance) => !instance.def.is_local(),`
`244`	`259`	`TransItem::DropGlue(..) \|`
`245`		`- TransItem::Static(..) => false,`
	`260`	`+ TransItem::Static(..) \|`
	`261`	`+ TransItem::GlobalAsm(..) => false,`
`246`	`262`	`}`
`247`	`263`	`}`
`248`	`264`
`@@ -261,6 +277,7 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`261`	`277`	`}`
`262`	`278`	`TransItem::DropGlue(..) => InstantiationMode::LocalCopy,`
`263`	`279`	`TransItem::Static(..) => InstantiationMode::GloballyShared,`
	`280`	`+ TransItem::GlobalAsm(..) => InstantiationMode::GloballyShared,`
`264`	`281`	`}`
`265`	`282`	`}`
`266`	`283`
`@@ -270,15 +287,16 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`270`	`287`	`instance.substs.types().next().is_some()`
`271`	`288`	`}`
`272`	`289`	`TransItem::DropGlue(..) \|`
`273`		`- TransItem::Static(..) => false,`
	`290`	`+ TransItem::Static(..) \|`
	`291`	`+ TransItem::GlobalAsm(..) => false,`
`274`	`292`	`}`
`275`	`293`	`}`
`276`	`294`
`277`	`295`	`pub fn explicit_linkage(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Option<llvm::Linkage> {`
`278`	`296`	`let def_id = match *self {`
`279`	`297`	`TransItem::Fn(ref instance) => instance.def,`
`280`	`298`	`TransItem::Static(node_id) => tcx.hir.local_def_id(node_id),`
`281`		`- TransItem::DropGlue(..) => return None,`
	`299`	`+ TransItem::DropGlue(..) \| TransItem::GlobalAsm(..) => return None,`
`282`	`300`	`};`
`283`	`301`
`284`	`302`	`let attributes = tcx.get_attrs(def_id);`
`@@ -320,6 +338,9 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`320`	`338`	`let instance = Instance::new(def_id, tcx.intern_substs(&[]));`
`321`	`339`	`to_string_internal(tcx, "static ", instance)`
`322`	`340`	`},`
	`341`	`+ TransItem::GlobalAsm(..) => {`
	`342`	`+ "global_asm".to_string()`
	`343`	`+ }`
`323`	`344`	`};`
`324`	`345`
`325`	`346`	`fn to_string_internal<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,`
`@@ -351,6 +372,9 @@ impl<'a, 'tcx> TransItem<'tcx> {`
`351`	`372`	`TransItem::Static(id) => {`
`352`	`373`	`format!("Static({:?})", id)`
`353`	`374`	`}`
	`375`	`+ TransItem::GlobalAsm(id) => {`
	`376`	`+ format!("GlobalAsm({:?})", id)`
	`377`	`+ }`
`354`	`378`	`}`
`355`	`379`	`}`
`356`	`380`	`}`