---

yaml
---
r: 155107
b: refs/heads/try2
c: ad9a1da
h: refs/heads/master
i:
  155105: d6c2595
  155103: c748b25
v: v3

Author: Keegan McAllister

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 225353d8bbad5730c941fc88e854627004e74f2c
+refs/heads/try2: ad9a1daa819bbeb8e643a01167b3b69055b88d57
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/back/write.rs

@@ -11,11 +11,11 @@
 use back::lto;
 use back::link::{get_cc_prog, remove};
 use driver::driver::{CrateTranslation, ModuleTranslation, OutputFilenames};
-use driver::config::NoDebugInfo;
+use driver::config::{NoDebugInfo, Passes, AllPasses};
 use driver::session::Session;
 use driver::config;
 use llvm;
-use llvm::{ModuleRef, TargetMachineRef, PassManagerRef};
+use llvm::{ModuleRef, TargetMachineRef, PassManagerRef, DiagnosticInfoRef, ContextRef};
 use util::common::time;
 use syntax::abi;
 use syntax::codemap;
@@ -28,9 +28,10 @@ use std::io::fs;
 use std::iter::Unfold;
 use std::ptr;
 use std::str;
+use std::mem;
 use std::sync::{Arc, Mutex};
 use std::task::TaskBuilder;
-use libc::{c_uint, c_int};
+use libc::{c_uint, c_int, c_void};
 
 
 #[deriving(Clone, PartialEq, PartialOrd, Ord, Eq)]
@@ -311,21 +312,49 @@ struct CodegenContext<'a> {
     lto_ctxt: Option<(&'a Session, &'a [String])>,
     // Handler to use for diagnostics produced during codegen.
     handler: &'a Handler,
+    // LLVM optimizations for which we want to print remarks.
+    remark: Passes,
 }
 
 impl<'a> CodegenContext<'a> {
-    fn new(handler: &'a Handler) -> CodegenContext<'a> {
-        CodegenContext {
-            lto_ctxt: None,
-            handler: handler,
-        }
-    }
-
     fn new_with_session(sess: &'a Session, reachable: &'a [String]) -> CodegenContext<'a> {
         CodegenContext {
             lto_ctxt: Some((sess, reachable)),
             handler: sess.diagnostic().handler(),
+            remark: sess.opts.cg.remark.clone(),
+        }
+    }
+}
+
+struct DiagHandlerFreeVars<'a> {
+    llcx: ContextRef,
+    cgcx: &'a CodegenContext<'a>,
+}
+
+unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_void) {
+    let DiagHandlerFreeVars { llcx, cgcx }
+        = *mem::transmute::<_, *const DiagHandlerFreeVars>(user);
+
+    match llvm::diagnostic::Diagnostic::unpack(info) {
+        llvm::diagnostic::Optimization(opt) => {
+            let pass_name = CString::new(opt.pass_name, false);
+            let pass_name = pass_name.as_str().expect("got a non-UTF8 pass name from LLVM");
+            let enabled = match cgcx.remark {
+                AllPasses => true,
+                Passes(ref v) => v.iter().any(|s| s.as_slice() == pass_name),
+            };
+
+            if enabled {
+                let loc = llvm::debug_loc_to_string(llcx, opt.debug_loc);
+                cgcx.handler.note(format!("optimization {:s} for {:s} at {:s}: {:s}",
+                                          opt.kind.describe(),
+                                          pass_name,
+                                          if loc.is_empty() { "[unknown]" } else { loc.as_slice() },
+                                          llvm::twine_to_string(opt.message)).as_slice());
+            }
         }
+
+        _ => (),
     }
 }
 
@@ -338,6 +367,17 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext,
     let ModuleTranslation { llmod, llcx } = mtrans;
     let tm = config.tm;
 
+    // llcx doesn't outlive this function, so we can put this on the stack.
+    let fv = DiagHandlerFreeVars {
+        llcx: llcx,
+        cgcx: cgcx,
+    };
+    if !cgcx.remark.is_empty() {
+        llvm::LLVMContextSetDiagnosticHandler(llcx, diagnostic_handler,
+                                              &fv as *const DiagHandlerFreeVars
+                                                  as *mut c_void);
+    }
+
     if config.emit_no_opt_bc {
         let ext = format!("{}.no-opt.bc", name_extra);
         output_names.with_extension(ext.as_slice()).with_c_str(|buf| {
@@ -785,13 +825,18 @@ fn run_work_multithreaded(sess: &Session,
     for i in range(0, num_workers) {
         let work_items_arc = work_items_arc.clone();
         let diag_emitter = diag_emitter.clone();
+        let remark = sess.opts.cg.remark.clone();
 
         let future = TaskBuilder::new().named(format!("codegen-{}", i)).try_future(proc() {
             let diag_handler = mk_handler(box diag_emitter);
 
             // Must construct cgcx inside the proc because it has non-Send
             // fields.
-            let cgcx = CodegenContext::new(&diag_handler);
+            let cgcx = CodegenContext {
+                lto_ctxt: None,
+                handler: &diag_handler,
+                remark: remark,
+            };
 
             loop {
                 // Avoid holding the lock for the entire duration of the match.

branches/try2/src/librustc/driver/config.rs

@@ -235,6 +235,21 @@ pub fn debugging_opts_map() -> Vec<(&'static str, &'static str, u64)> {
                        --pretty flowgraph output", FLOWGRAPH_PRINT_ALL))
 }
 
+#[deriving(Clone)]
+pub enum Passes {
+    Passes(Vec<String>),
+    AllPasses,
+}
+
+impl Passes {
+    pub fn is_empty(&self) -> bool {
+        match *self {
+            Passes(ref v) => v.is_empty(),
+            AllPasses => false,
+        }
+    }
+}
+
 /// Declare a macro that will define all CodegenOptions fields and parsers all
 /// at once. The goal of this macro is to define an interface that can be
 /// programmatically used by the option parser in order to initialize the struct
@@ -261,7 +276,7 @@ macro_rules! cgoptions(
         &[ $( (stringify!($opt), cgsetters::$opt, $desc) ),* ];
 
     mod cgsetters {
-        use super::CodegenOptions;
+        use super::{CodegenOptions, Passes, AllPasses};
 
         $(
             pub fn $opt(cg: &mut CodegenOptions, v: Option<&str>) -> bool {
@@ -310,6 +325,24 @@ macro_rules! cgoptions(
                 None => false
             }
         }
+
+        fn parse_passes(slot: &mut Passes, v: Option<&str>) -> bool {
+            match v {
+                Some("all") => {
+                    *slot = AllPasses;
+                    true
+                }
+                v => {
+                    let mut passes = vec!();
+                    if parse_list(&mut passes, v) {
+                        *slot = Passes(passes);
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+        }
     }
 ) )
 
@@ -356,6 +389,8 @@ cgoptions!(
          "extra data to put in each output filename"),
     codegen_units: uint = (1, parse_uint,
         "divide crate into N units to optimize in parallel"),
+    remark: Passes = (Passes(Vec::new()), parse_passes,
+        "print remarks for these optimization passes (space separated, or \"all\")"),
 )
 
 pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions
@@ -744,6 +779,10 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
     }
     let cg = build_codegen_options(matches);
 
+    if !cg.remark.is_empty() && debuginfo == NoDebugInfo {
+        early_warn("-C remark will not show source locations without --debuginfo");
+    }
+
     let color = match matches.opt_str("color").as_ref().map(|s| s.as_slice()) {
         Some("auto")   => Auto,
         Some("always") => Always,

branches/try2/src/librustc_llvm/diagnostic.rs

@@ -0,0 +1,92 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! LLVM diagnostic reports.
+
+use libc::c_char;
+
+use {ValueRef, TwineRef, DebugLocRef, DiagnosticInfoRef};
+
+pub enum OptimizationDiagnosticKind {
+    OptimizationRemark,
+    OptimizationMissed,
+    OptimizationAnalysis,
+    OptimizationFailure,
+}
+
+impl OptimizationDiagnosticKind {
+    pub fn describe(self) -> &'static str {
+        match self {
+            OptimizationRemark => "remark",
+            OptimizationMissed => "missed",
+            OptimizationAnalysis => "analysis",
+            OptimizationFailure => "failure",
+        }
+    }
+}
+
+pub struct OptimizationDiagnostic {
+    pub kind: OptimizationDiagnosticKind,
+    pub pass_name: *const c_char,
+    pub function: ValueRef,
+    pub debug_loc: DebugLocRef,
+    pub message: TwineRef,
+}
+
+impl OptimizationDiagnostic {
+    unsafe fn unpack(kind: OptimizationDiagnosticKind, di: DiagnosticInfoRef)
+            -> OptimizationDiagnostic {
+
+        let mut opt = OptimizationDiagnostic {
+            kind: kind,
+            pass_name: 0 as *const c_char,
+            function: 0 as ValueRef,
+            debug_loc: 0 as DebugLocRef,
+            message: 0 as TwineRef,
+        };
+
+        super::LLVMUnpackOptimizationDiagnostic(di,
+            &mut opt.pass_name,
+            &mut opt.function,
+            &mut opt.debug_loc,
+            &mut opt.message);
+
+        opt
+    }
+}
+
+pub enum Diagnostic {
+    Optimization(OptimizationDiagnostic),
+
+    /// LLVM has other types that we do not wrap here.
+    UnknownDiagnostic(DiagnosticInfoRef),
+}
+
+impl Diagnostic {
+    pub unsafe fn unpack(di: DiagnosticInfoRef) -> Diagnostic {
+        let kind = super::LLVMGetDiagInfoKind(di);
+
+        match kind {
+            super::DK_OptimizationRemark
+                => Optimization(OptimizationDiagnostic::unpack(OptimizationRemark, di)),
+
+            super::DK_OptimizationRemarkMissed
+                => Optimization(OptimizationDiagnostic::unpack(OptimizationMissed, di)),
+
+            super::DK_OptimizationRemarkAnalysis
+                => Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysis, di)),
+
+            super::DK_OptimizationFailure
+                => Optimization(OptimizationDiagnostic::unpack(OptimizationFailure, di)),
+
+            _ => UnknownDiagnostic(di)
+        }
+    }
+}