From adebadc5732fc632aecec4d83a3402f54fd21c4f Mon Sep 17 00:00:00 2001
From: David Gonzalez Martin <davidgm94.work@protonmail.com>
Date: Sun, 16 Jun 2024 16:38:56 -0500
Subject: [PATCH] Add top-level declaration timers

---
 bootstrap/compiler.zig | 34 ++++++++++++++++++++++++++++++++--
 build.zig              |  5 ++++-
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/bootstrap/compiler.zig b/bootstrap/compiler.zig
index f46097f..e62b6a2 100644
--- a/bootstrap/compiler.zig
+++ b/bootstrap/compiler.zig
@@ -3844,6 +3844,11 @@ const File = struct{
     local_lazy_expressions: PinnedArray(*LocalLazyExpression) = .{},
     timestamp: std.time.Instant,
     timers: Timers = Timers.initFill(.{ .range = std.mem.zeroes(TimeRange) }),
+    top_level_declaration_timers: PinnedArray(struct {
+        name: []const u8,
+        start: std.time.Instant,
+        end: std.time.Instant,
+    }) = .{},
     const Timers = std.EnumArray(Timer, TimeUnion);
     const Timer = enum{
         queue,
@@ -4400,7 +4405,7 @@ pub fn main() void {
     const print_timers = configuration.timers;
     if (print_timers) {
         for (instance.files.slice()) |*file| {
-            std.debug.print("File {s}:\n", .{file.path});
+            std.debug.print("File {s}:\nStages:\n", .{file.path});
             var it = file.timers.iterator();
             while (it.next()) |timer_entry| {
                 const ns = switch (timer_entry.value.*) {
@@ -4410,6 +4415,13 @@ pub fn main() void {
                 const ms = @as(f64, @floatFromInt(ns)) / 1000_000.0;
                 std.debug.print("- {s}: {d} ns ({d:.02} ms)\n", .{@tagName(timer_entry.key), ns, ms});
             }
+
+            std.debug.print("Top level declarations:\n", .{});
+            for (file.top_level_declaration_timers.slice()) |timer| {
+                const ns = timer.end.since(timer.start);
+                const ms = @as(f64, @floatFromInt(ns)) / 1000_000.0;
+                std.debug.print("- {s}: {d} ns ({d:.02} ms)\n", .{timer.name, ns, ms});
+            }
         }
 
         for (instance.threads) |*thread| {
@@ -7742,6 +7754,9 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
         const declaration_line = parser.get_debug_line();
         const declaration_column = parser.get_debug_column();
 
+        var top_level_declaration_name: []const u8 = "anonymous";
+        const top_level_declaration_start = std.time.Instant.now() catch unreachable;
+
         switch (declaration_start_ch) {
             '>' => {
                 parser.i += 1;
@@ -7752,6 +7767,8 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
                     fail_message("discard identifier '_' cannot be used as a global variable name");
                 }
 
+                top_level_declaration_name = thread.identifiers.get(global_name).?;
+
                 if (file.scope.scope.get_global_declaration(global_name)) |existing_global| {
                     _ = existing_global; // autofix
                     fail();
@@ -7826,6 +7843,8 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
                             parser.skip_space(src);
 
                             const bitfield_name = parser.parse_identifier(thread, src);
+                            top_level_declaration_name = thread.identifiers.get(bitfield_name).?;
+
                             const bitfield_type = thread.bitfields.append(.{
                                 .type = .{
                                     .sema = .{
@@ -7991,7 +8010,9 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
                         parser.skip_space(src);
                     }
 
-                    function_declaration_data.global_symbol.global_declaration.declaration.name = parser.parse_identifier(thread, src);
+                    const function_name = parser.parse_identifier(thread, src);
+                    function_declaration_data.global_symbol.global_declaration.declaration.name = function_name;
+                    top_level_declaration_name = thread.identifiers.get(function_name).?;
 
                     parser.skip_space(src);
 
@@ -8871,6 +8892,7 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
                     parser.skip_space(src);
 
                     const string_literal = parser.parse_non_escaped_string_literal_content(src);
+                    top_level_declaration_name = string_literal;
                     parser.skip_space(src);
 
                     parser.expect_character(src, ';');
@@ -8932,6 +8954,7 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
                     parser.skip_space(src);
 
                     const struct_name = parser.parse_identifier(thread, src);
+                    top_level_declaration_name = thread.identifiers.get(struct_name).?;
                     const struct_type = thread.structs.append(.{
                         .type = .{
                             .sema = .{
@@ -8987,6 +9010,13 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
             },
             else => fail(),
         }
+
+        const top_level_declaration_end = std.time.Instant.now() catch unreachable;
+        _ = file.top_level_declaration_timers.append(.{
+            .name = top_level_declaration_name,
+            .start = top_level_declaration_start,
+            .end = top_level_declaration_end,
+        });
     } 
 
     for (file.local_lazy_expressions.slice()) |local_lazy_expression| {
diff --git a/build.zig b/build.zig
index 516c912..30f7b34 100644
--- a/build.zig
+++ b/build.zig
@@ -36,7 +36,10 @@ pub fn build(b: *std.Build) !void {
         .windows => true,
         // .macos => true,
     };
-    const timers = b.option(bool, "timers", "This option enables to make and print timers") orelse !is_ci;
+    const timers = b.option(bool, "timers", "This option enables to make and print timers") orelse !is_ci and switch (optimization) {
+        .Debug => false,
+        else => true,
+    };
 
     const fetcher = b.addExecutable(.{
         .name = "llvm_fetcher",