Adding a bunch of profiling tracers.

src/alloy/compiler/compiler.cc

@@ -49,6 +49,8 @@ void Compiler::Reset() {
 }
 
 int Compiler::Compile(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // TODO(benvanik): sophisticated stuff. Run passes in parallel, run until they
   //                 stop changing things, etc.
   for (auto it = passes_.begin(); it != passes_.end(); ++it) {

src/alloy/compiler/passes/constant_propagation_pass.cc

@@ -23,6 +23,8 @@ ConstantPropagationPass::~ConstantPropagationPass() {
 }
 
 int ConstantPropagationPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // Once ContextPromotion has run there will likely be a whole slew of
   // constants that can be pushed through the function.
   // Example:

src/alloy/compiler/passes/context_promotion_pass.cc

@@ -51,6 +51,8 @@ int ContextPromotionPass::Initialize(Compiler* compiler) {
 }
 
 int ContextPromotionPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // Like mem2reg, but because context memory is unaliasable it's easier to
   // check and convert LoadContext/StoreContext into value operations.
   // Example of load->value promotion:

src/alloy/compiler/passes/control_flow_analysis_pass.cc

@@ -30,6 +30,8 @@ ControlFlowAnalysisPass::~ControlFlowAnalysisPass() {
 }
 
 int ControlFlowAnalysisPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // TODO(benvanik): reset edges for all blocks? Needed to be re-runnable.
 
   // Add edges.

src/alloy/compiler/passes/data_flow_analysis_pass.cc

@@ -36,6 +36,8 @@ DataFlowAnalysisPass::~DataFlowAnalysisPass() {
 }
 
 int DataFlowAnalysisPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // Linearize blocks so that we can detect cycles and propagate dependencies.
   uint32_t block_count = LinearizeBlocks(builder);
 

src/alloy/compiler/passes/dead_code_elimination_pass.cc

@@ -23,6 +23,8 @@ DeadCodeEliminationPass::~DeadCodeEliminationPass() {
 }
 
 int DeadCodeEliminationPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // ContextPromotion/DSE will likely leave around a lot of dead statements.
   // Code generated for comparison/testing produces many unused statements and
   // with proper use analysis it should be possible to remove most of them:

src/alloy/compiler/passes/finalization_pass.cc

@@ -30,6 +30,8 @@ FinalizationPass::~FinalizationPass() {
 }
 
 int FinalizationPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // Process the HIR and prepare it for lowering.
   // After this is done the HIR should be ready for emitting.
 

src/alloy/compiler/passes/register_allocation_pass.cc

@@ -59,6 +59,8 @@ RegisterAllocationPass::~RegisterAllocationPass() {
 }
 
 int RegisterAllocationPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // Simple per-block allocator that operates on SSA form.
   // Registers do not move across blocks, though this could be
   // optimized with some intra-block analysis (dominators/etc).

src/alloy/compiler/passes/simplification_pass.cc

@@ -23,6 +23,8 @@ SimplificationPass::~SimplificationPass() {
 }
 
 int SimplificationPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   EliminateConversions(builder);
   SimplifyAssignments(builder);
   return 0;

src/alloy/compiler/passes/validation_pass.cc

@@ -30,6 +30,8 @@ ValidationPass::~ValidationPass() {
 }
 
 int ValidationPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   StringBuffer str;
   builder->Dump(&str);
   printf(str.GetString());

src/alloy/compiler/passes/value_reduction_pass.cc

@@ -53,6 +53,8 @@ void ValueReductionPass::ComputeLastUse(Value* value) {
 }
 
 int ValueReductionPass::Run(HIRBuilder* builder) {
+  SCOPE_profile_cpu_f("alloy");
+
   // Walk each block and reuse variable ordinals as much as possible.
 
   llvm::BitVector ordinals(builder->max_value_ordinal());