linker

src/linker/lnk_directive.c

@@ -0,0 +1,185 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+internal void
+lnk_alt_name_list_concat_in_place(LNK_AltNameList *list, LNK_AltNameList *to_concat)
+{
+  str8_list_concat_in_place(&list->from_list, &to_concat->from_list);
+  str8_list_concat_in_place(&list->to_list, &to_concat->to_list);
+}
+
+internal LNK_MergeDirectiveNode *
+lnk_merge_directive_list_push(Arena *arena, LNK_MergeDirectiveList *list, LNK_MergeDirective data)
+{
+  LNK_MergeDirectiveNode *node = push_array_no_zero(arena, LNK_MergeDirectiveNode, 1);
+  node->data                   = data;
+  node->next                   = 0;
+  
+  SLLQueuePush(list->first, list->last, node);
+  ++list->count;
+  
+  return node;
+}
+
+////////////////////////////////
+
+internal void
+lnk_parse_directives(Arena *arena, LNK_DirectiveInfo *directive_info, String8 buffer, String8 obj_path)
+{
+  Temp scratch = scratch_begin(&arena, 1);
+  
+  String8 unparsed_directives = buffer;
+  {
+    static const U8 BOM_SIG[] = { 0xEF, 0xBB, 0xBF };
+    B32 is_bom = MemoryMatch(buffer.str, &BOM_SIG[0], sizeof(BOM_SIG));
+    if (is_bom) {
+      unparsed_directives = str8_zero();
+      lnk_not_implemented("TODO: support for BOM encoding");
+    }
+    static const U8 ASCII_SIG[] = { 0x20, 0x20, 0x20 };
+    B32 is_ascii = MemoryMatch(buffer.str, &ASCII_SIG[0], sizeof(ASCII_SIG));
+    if (is_ascii) {
+      unparsed_directives = str8_skip(buffer, sizeof(ASCII_SIG));
+    }
+  }
+  
+  String8List arg_list = lnk_arg_list_parse_windows_rules(scratch.arena, unparsed_directives);
+  LNK_CmdLine cmd_line = lnk_cmd_line_parse_windows_rules(scratch.arena, arg_list);
+
+  for (LNK_CmdOption *opt = cmd_line.first_option; opt != 0; opt = opt->next) {
+    static struct {
+      LNK_DirectiveKind kind;
+      String8           name;
+    } directive_table[LNK_Directive_Count] = {
+      { LNK_Directive_Null,                str8_lit_comp("")                   },
+      { LNK_Directive_DefaultLib,          str8_lit_comp("defaultlib")         },
+      { LNK_Directive_Export,              str8_lit_comp("export" )            },
+      { LNK_Directive_Include,             str8_lit_comp("include")            },
+      { LNK_Directive_ManifestDependency,  str8_lit_comp("manifestdependency") },
+      { LNK_Directive_Merge,               str8_lit_comp("merge")              },
+      { LNK_Directive_Section,             str8_lit_comp("section")            },
+      { LNK_Directive_AlternateName,       str8_lit_comp("alternatename")      },
+      { LNK_Directive_GuardSym,            str8_lit_comp("guardsym")           },
+      { LNK_Directive_DisallowLib,         str8_lit_comp("disallowlib")        },
+      { LNK_Directive_FailIfMismatch,      str8_lit_comp("failifmismatch")     },
+      { LNK_Directive_EditAndContinue,     str8_lit_comp("editandcontinue")    },
+      { LNK_Directive_ThrowingNew,         str8_lit_comp("throwingnew")        },
+    };
+
+    LNK_DirectiveKind kind = LNK_Directive_Null;
+    for (U64 i = 0; i < ArrayCount(directive_table); ++i) {
+      if (str8_match(directive_table[i].name, opt->string, StringMatchFlag_CaseInsensitive)) {
+        kind = directive_table[i].kind;
+        break;
+      }
+    }
+    if (kind == LNK_Directive_Null) {
+      lnk_error(LNK_Warning_UnknownDirective, "%S: unknown directive \"%S\"", obj_path, opt->string);
+    }
+    
+    LNK_Directive *directive = push_array_no_zero(arena, LNK_Directive, 1);
+    directive->next          = 0;
+    directive->id            = push_str8_copy(arena, opt->string);
+    directive->value_list    = str8_list_copy(arena, &opt->value_strings);
+    
+    LNK_DirectiveList *directive_list = &directive_info->v[kind];
+    SLLQueuePush(directive_list->first, directive_list->last, directive);
+    ++directive_list->count;
+  }
+  
+  scratch_end(scratch);
+}
+
+internal String8List
+lnk_parse_default_lib_directive(Arena *arena, LNK_DirectiveList *dir_list)
+{
+  ProfBeginFunction();
+  String8List default_libs = {0};
+  
+  for (LNK_Directive *dir = dir_list->first; dir != 0; dir = dir->next) {
+    for (String8Node *i = dir->value_list.first; i != 0; i = i->next) {
+      String8 lib_path = i->string;
+      
+      // is there lib extension?
+      String8 ext = str8_skip_last_dot(lib_path);
+      if (ext.size == lib_path.size) { // TODO: fix string_extension_from_path, if there is no extension it should return zero
+        lib_path = push_str8f(arena, "%S.lib", lib_path);
+      } else {
+        lib_path = push_str8_copy(arena, lib_path);
+      }
+
+      
+      str8_list_push(arena, &default_libs, lib_path);
+    }
+  }
+  
+  ProfEnd();
+  return default_libs;
+}
+
+internal LNK_ExportParse *
+lnk_parse_export_direcive(Arena *arena, LNK_ExportParseList *list, String8List value_list, LNK_Obj *obj)
+{
+  ProfBeginFunction();
+  Temp scratch = scratch_begin(&arena, 1);
+  LNK_ExportParse *parse = 0;
+
+  // parse directive
+  String8 name  = str8(0,0);
+  String8 alias = str8(0,0);
+  String8 type  = coff_string_from_import_header_type(COFF_ImportHeaderType_CODE);
+  if (value_list.node_count > 0) {
+    String8List dir_split = str8_split_by_string_chars(scratch.arena, value_list.first->string, str8_lit("="), 0);
+    B32 is_export_valid = value_list.node_count <= 2 && value_list.node_count > 0;
+    if (is_export_valid) {
+      if (dir_split.node_count > 0) {
+        name = dir_split.last->string;
+      }
+      if (dir_split.node_count == 2) {
+        alias = dir_split.first->string;
+      }
+      if (value_list.node_count == 2) {
+        type = value_list.last->string;
+      }
+    }
+  }
+  
+  // prase error check
+  if (name.size == 0) {
+    String8 dir = str8_list_join(scratch.arena, &value_list, 0);
+    lnk_error_obj(LNK_Error_IllData, obj, "invalid export directive \"%S\"", dir);
+    goto exit;
+  }
+  
+  parse = push_array_no_zero(arena, LNK_ExportParse, 1);
+  parse->next  = 0;
+  parse->name  = name;
+  parse->alias = alias;
+  parse->type  = type;
+  
+  SLLQueuePush(list->first, list->last, parse);
+  ++list->count;
+  
+exit:;
+  scratch_end(scratch);
+  ProfEnd();
+  return parse;
+}
+
+internal B32
+lnk_parse_merge_directive(String8 string, LNK_MergeDirective *out)
+{
+  Temp scratch = scratch_begin(0, 0);
+  B32 is_parse_ok = 0;
+  
+  String8List list = str8_split_by_string_chars(scratch.arena, string, str8_lit("="), 0);
+  if (list.node_count == 2) {
+    out->src = list.first->string;
+    out->dst = list.last->string;
+    is_parse_ok = 1;
+  }
+  
+  scratch_end(scratch);
+  return is_parse_ok;
+}
+