text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>struct(section_data__maybe_compressed, 0, &chdr32);
if(chdr_size == sizeof(chdr32))
{
chdr64 = elf_chdr64_from_chdr32(chdr32);
}
}
// rjf: decompress
{
String8 section_data__compressed_contents = str8_skip(section_data__maybe_compressed, c... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DWARF_PARSE_ELF_H
#define DWARF_PARSE_ELF_H
internal B32 dw_is_dwarf_present_from_elf_bin(String8 raw_image, ELF_Bin *bin);
internal DW_Raw dw_raw_from_elf_bin(Arena *arena, String8 raw_image, ELF_Bin *bin);
#endif // DWARF_PA... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>ensource.org/license/mit/)
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed <|fim_middle|>under the MIT license (https://op<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed u<|fim_suffix|> DW_UnwindRuleCode_ValExpr,
DW_UnwindRuleCode_Architectural,
}
DW_UnwindRuleCode;
typedef struct DW_UnwindRule DW_UnwindRule;
struct DW_UnwindRule
{
DW_UnwindRuleCode code;
DW_RegCode reg_code;
S64 s64;
String8 expr;
};
typedef struc... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
// TODO(rjf): this uses concepts from the old parser
internal DW_IntEnc
dw_int_enc_from_sint(S64 v)
{
if ((S8)v == v) return DW_IntEnc_1Byte;
if ((S16)v == v) return DW_IntEnc_2Byte;
if ((S32... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DWARF_WRITER_H
#define DWARF_WRITER_H
// TODO(rjf): this uses concepts from the old parser
////////////////////////////////
typedef enum
{
DW_IntEnc_Null,
DW_IntEnc_1Byte,
DW_IntEnc_... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
C_LINKAGE_BEGIN
String8 dw_regular_name_from_section_kind_table[18] =
{
str8_lit_comp(""),
str8_lit_comp(".debug_abbrev"),
str8_lit_comp(".debug_aranges"),
str8_lit_comp(".debug_frame"),
str8_l... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
#ifndef DWARF_META_H
#define DWARF_META_H
typedef U16 DW_Version;
typedef enum DW_VersionEnum
{
DW_Version_Null,
DW_Version_1,
DW_Version_2,
DW_Version_3,
DW_Version_4,
DW_Version_5,
DW_Versio... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#if 0 // TODO(rjf): this uses concepts from the old parser
internal U64
t_dw_test_uleb128(U64 v, U64 expected_length)
{
Temp scratch = scratch_begin(0, 0);
B32 is_ok = 0;
U64 v0 = v;
Stri... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>64.meta.c"
<|fim_prefix|>// Copyright (c) Epic Games <|fim_middle|>Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#include "dwarf/x64/generated/dwarf_x<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Too<|fim_suffix|>H
<|fim_middle|>ls
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DWARF_X64_H
#define DWARF_X64_H
#include "dwarf/x64/generated/dwarf_x64.meta.h"
#endif // DWARF_X64_<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
C_LINKAGE_BEGIN
U8 dw_reg_code_from_x64_table[189] =
{
0,
DW_RegCodeX64_rax,
DW_Re<|fim_suffix|>0,
0,
0,
0,
DW_RegCodeX64_ss,
DW_RegCodeX64_cs,
DW_RegCodeX64_ds,
DW_RegCodeX64_es,... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://openso<|fim_suffix|>F_X64_META_H
C_LINKAGE_BEGIN
extern U8 dw_reg_code_from_x64_table[189];
C_LINKAGE_END
#endif // DWARF_X64_META_H
<|fim_middle|>urce.org/license/mit/)
//- GENERATED CODE
#ifndef DWARF_X64_META_H
#define DW... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: .eh_frame Parsing Functions
internal EH_FrameHdr
eh_parse_frame_hdr(String8 data, U64 address_size, EH_PtrCtx *ptr_ctx)
{
EH_FrameHdr header = {0};
U64 ... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef EH_FRAME_H
#define EH_FRAME_H
////////////////////////////////
//~ Format
typedef U8 EH_PtrEnc;
enum
{
EH_PtrEnc_Ptr = 0x00, // Pointer sized unsigned value
EH_PtrEnc_ULEB128 = 0x01... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal String8List
eh_dump_list_from_data(Arena *arena, Arch arch, U64 eh_frame_hdr_vaddr, U64 eh_frame_vaddr, String8 eh_frame_hdr, String8 eh_frame, EH_DumpSubsetFlags subset_flags)
{
Temp scra... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>title) EH_DumpSubsetFlag_##name = (1<<EH_DumpSubset_##name),
EH_DumpSubset_XList
#undef X
EH_DumpSubsetFlag_All = 0xffffffff,
};
read_only global String8 eh_name_lowercase_from_dump_subset_table[] =
{
#define X(name, name_lower, title) str8_lit_comp(#name_lower),
EH_DumpSubset_XList
#undef X
};
re... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal UWND_StepResult
eh_uwnd_step(Arch arch, MemoryMap *memory_map, UWND_ModuleInfo *module_info, U64 tls_vaddr, void *regs, U64 *cfa_out)
{
Temp scratch = scratch_begin(0, 0);
B32 done = 0;
... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>/////////////////////////
//~ rjf: Unwinding Abstraction Implementation
internal UWND_StepResult eh_uwnd_step(Arch arch, MemoryMap *memory_map, UWND_ModuleInfo *module_info, U64 tls_vaddr, void *regs, U64 *cfa_out);
#endif // EH_FRAME_UNWIND_H
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed ... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: 32 => 64 bit conversions
internal ELF_Hdr64
elf_hdr64_from_hdr32(ELF_Hdr32 h32)
{
ELF_Hdr64 h64 = {0};
MemoryCopy(h64.e_ident, h32.e_ident, sizeof(h64.... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef ELF_H
#define ELF_H
typedef U8 ELF_Class;
enum
{
ELF_Class_None = 0,
ELF_Class_32 = 1,
ELF_Class_64 = 2,
ELF_Class_Count = 3
};
typedef U8 ELF_OsAbi;
enum
{
ELF_OsAbi_None,... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>offset + shdr->sh_size));
String8 shdr_name = elf_name_from_shdr64(raw_elf, &elf, shdr);
str8_list_pushf(scratch.arena, &strings, "//");
str8_list_pushf(scratch.arena, &strings, "// %S", shdr_name);
str8_list_pushf(scratch.arena, &strings, "//");
String8List note_st... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef ELF_DUMP_H
#define ELF_DUMP_H
#define ELF_DumpSubset_XList \
X(Note, note, "NOTE")
typedef U32 ELF_DumpSubset;
enum
{
#define X(name, name_lower, title) ELF_DumpSubset_##name,
ELF_DumpS... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>h_name, &name);
return name;
}
internal U64
elf_base_addr_from_bin(ELF_Bin *bin)
{
U64 base_vaddr = 0;
if(bin->hdr.e_type != ELF_Type_Dyn)
{
for EachIndex(phdr_idx, bin->phdrs.count)
{
ELF_Phdr64 *phdr = &bin->phdrs.v[phdr_idx];
if(phdr->p_type == ELF_PType_Load &&
(b... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef ELF_PARSE_H
#define ELF_PARSE_H
////////////////////////////////
//~ rjf: Parsed Structure Types
typedef struct ELF_Shdr64Array ELF_Shdr64Array;
struct ELF_Shdr64Array
{
U64 count;
ELF_... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>first_part; part != 0 && fits_this_type_string; part = part->next)
{
String8 pattern_string = part->string;
//- rjf: skip whitespace
for(;scan_pos < type_string.size;)
{
if(char_is_space(type_string.str[scan_pos]))
... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>puted.
//
// One wrinkle here is that the IR tree generation stage is implicitly
// parameterized by the "overridden" IR tree - this is to enable "parent
// expressions", e.g. `$.x`, or simply `x` assuming `foo` has such a member,
// in the context of some struct `foo` evaluates to the same thing as `foo.... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#include "eval/eval_core.c"
#include "eval/eval_types.c"
#include "eval/eval_parse.c"
#include "eval/eval_ir.c"
#include "eval/eval_interpret.c"
<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef EVAL_INC_H
#define EVAL_INC_H
#include "eval/eval_core.h"
#include "eval/eval_types.h"
#include "eval/eval_parse.h<|fim_suffix|>val_interpret.h"
#endif // EVAL_INC_H
<|fim_middle|>"
#includ... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|> else
{
result.code = E_InterpretationCode_BadOpTypes;
goto done;
}
}break;
case RDI_EvalOp_GrEq:
{
if(type_group == RDI_EvalTypeGroup_F32)
{
nval.u64 = (svals[0].f32 >= svals[1].f32);
}
else if(type_... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>retation e_interpret(String8 bytecode);
#endif // EVAL_INTERPRET_H
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef EVAL_INTERPRET_H
#define EVAL_INTERPRET_H
////////////////////////////////
//~ rjf: Interpretation Context
... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>_paths),
};
////////////////////////////////
//~ rjf: IR-ization Functions
//- rjf: op list functions
internal void e_oplist_push_op(Arena *arena, E_OpList *list, RDI_EvalOp opcode, E_Value value);
internal void e_oplist_push_uconst(Arena *arena, E_OpList *list, U64 x);
internal void e_oplist_push_scons... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Lexing/Parsing Data Tables
global read_only String8 e_multichar_symbol_strings[] =
{
str8_lit_comp("<<"),
str8_lit_comp(">>"),
str8_lit_comp("->"),
... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>(Arena *arena, E_ExprKind kind, Rng1U64 range);
internal void e_expr_insert_child(E_Expr *parent, E_Expr *prev, E_Expr *child);
internal void e_expr_push_child(E_Expr *parent, E_Expr *child);
internal void e_expr_remove_child(E_Expr *parent, E_Expr *child);
internal E_Expr *e_expr_ref(Arena *arena, E_Expr... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef EVAL_TYPES_H
#define EVAL_TYPES_H
////////////////////////////////
//~ rjf: Type Unwrapping
typedef U32 E_TypeUnwrapFlags;
enum
{
E_TypeUnwrapFlag_Modifiers = (1<<0),
E_TypeUnwrapFlag_Pointers ... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
C_LINKAGE_BEGIN
String8 e_token_kind_strings[7] =
{
str8_lit_comp("Null"),
str8_lit_comp("Identifier"),
str8_lit_comp("Numeric"),
str8_lit_comp("StringLiteral"),
str8_lit_comp("CharLiteral"),
s... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
#ifndef EVAL_META_H
#define EVAL_META_H
typedef enum E_TokenKind
{
E_TokenKind_Null,
E_TokenKind_Identifier,
E_TokenKind_Numeric,
E_TokenKind_StringLiteral,
E_TokenKind_CharLiter... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>ase E2_EvalOp_SetCtxID:{ctrlbits = RDI_EVAL_CTRLBITS(8, 0, 0);}break;
}
//- rjf: ctrlbits -> push/pop/decode count
U64 decode_size = RDI_DECODEN_FROM_CTRLBITS(ctrlbits);
U64 push_count = RDI_PUSHN_FROM_CTRLBITS(ctrlbits);
U64 pop_count = RDI_POPN_FROM_CTRLBITS(ctrlbits... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>gs flags;
U64 frame_base_addr;
U64 cfa_addr;
U64 module_base_addr;
U64 tls_base_addr;
};
////////////////////////////////
//~ rjf: Expression Tree Building
typedef struct E2_Expr E2_Expr;
struct E2_Expr
{
E2_Expr *first;
E2_Expr *last;
E2_Expr *next;
String8 string;
RDI_EvalOp op;
E2... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MI<|fim_suffix|>g/license/mit/)
//- GENERATED CODE
<|fim_middle|>T license (https://opensource.or<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>2_TypeKind_Modifier,
E2_TypeKind_Ptr,
E2_TypeKind_LRef,
E2_TypeKind_RRef,
E2_TypeKind_Array,
E2_TypeKind_Function,
E2_TypeKind_Method,
E2_TypeKind_MemberPtr,
E2_TypeKind_Struct,
E2_TypeKind_Class,
E2_TypeKind_Union,
E2_TypeKind_Enum,
E2_TypeKind_Alias,
E2_TypeKind_IncompleteStruct,
E2_TypeKind_IncompleteU... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Nil/Identity View Rule Hooks
EV_EXPAND_RULE_INFO_FUNCTION_DEF(nil)
{
EV_ExpandInfo info = {0};
return info;
}
////////////////////////////////
//~ rjf:... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|> EV_EXPAND_RULE_INFO_FUNCTION_NAME(nil),
};
thread_static EV_ExpandRuleTable *ev_view_rule_info_table = 0;
global read_only EV_Block ev_nil_block =
{
&ev_nil_block,
&ev_nil_block,
&ev_nil_block,
&ev_nil_block,
&ev_nil_block,
{0},
0,
{0},
{{0}, {0}, {0}, &e_expr_nil, &e_irnode_nil},
{0}... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>c"
<|fim_prefix|>// Copyright (c) Epic Games Tools
// License<|fim_middle|>d under the MIT license (https://opensource.org/license/mit/)
#include "eval_visualization_core.<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>"
#endif // EVAL_VISUALIZATION_INC_H
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef EVAL_VI<|fim_middle|>SUALIZATION_INC_H
#define EVAL_VISUALIZATION_INC_H
#include "eval_visualization_core.h<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#undef LAYER_COLOR
#define LAYER_COLOR 0xfffa00ff
////////////////////////////////
//~ rjf: Top-Level API
internal void
fs_init(void)
{
Arena *arena = arena_alloc();
fs_shared = push_array(aren... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef FILE_STREAM_H
#define FILE_STREAM_H
////////////////////////////////
//~ rjf: Path Cache
typedef struct FS_Node FS_Node;
struct FS_Node
{
FS_Node *next;
String8 path;
U64 gen;
U64 last_modified_t... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|> B32 is_first_byte_of_word = 0;
B32 is_first_space_after_word = 0;
if(!seeking_word_end && !char_is_space(byte))
{
seeking_word_end = 1;
is_first_byte_of_word = 1;
last_word_start_off_bytes = off_bytes;
last_word_start_piece = piece;
word_start_o... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>nal FP_Handle fnt_handle_from_tag(FNT_Tag tag);
internal FP_Metrics fnt_fp_metrics_from_tag(FNT_Tag tag);
internal FNT_Tag fnt_tag_from_path(String8 path);
internal FNT_Tag fnt_tag_from_static_data_string(String8 *data_ptr);
internal String8 fnt_path_from_tag(FNT_Tag tag);
///////////////////////////////... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Globals
global FP_DWrite_State *fp_dwrite_state = 0;
global FP_DWrite_FontFileLoaderVTable fp_dwrite_static_data_font_file_loader__vtable =
{
fp_dwrite_iu... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef FONT_PROVIDER_DWRITE_H
#define FONT_PROVIDER_DWRITE_H
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "dwrite.lib")
// #include <dwrite.h>
////////////////////////////////
//~ rjf: ... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>4[1]);
}
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Basic Type Functions
internal FP_Handle
fp_handle_zero(void)
{
FP_Handle result = {0};
return result;
}
internal B32
fp_handle_m... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef FONT_PROVIDER_H
#define FONT_PROVIDER_H
#define fp_hook C_LINKAGE
////////////////////////////////
//~ rjf: Types
typedef U32 FP_RasterFlags;
enum
{
FP_RasterFlag_Smooth = (1<<0),
FP_RasterFlag_Hin... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#include "font_provider.c"
#if FP_BACKEND == FP_BACKEND_DWRITE
# include "dwrite<|fim_suffix|>font_provider_dwrite.c"
#elif FP_BACKEND == FP_BACKEND_FREETYPE
# include "freetype/font_provider_freety... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef FONT_PROVIDER_INC_H
#define FONT_PROVIDER_INC_H
////////////////////////////////
//~ rjf: Backend Constants
#define FP_BACKEND_DWRITE 1
#define FP_BACKEND_FREETYPE 2
////////////////////////////////
//~... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Helpers
internal FP_FT_Font
fp_ft_font_from_handle(FP_Handle handle)
{
FP_FT_Font result = {(FT_Face)handle.u64[0]};
return result;
}
internal FP_Handl... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>T_State FP_FT_State;
struct FP_FT_State
{
Arena *arena;
FT_Library library;
};
////////////////////////////////
//~ rjf: Globals
global FP_FT_State *fp_ft_state = 0;
////////////////////////////////
//~ rjf: Helpers
internal FP_FT_Font fp_ft_font_from_handle(FP_Handle handle);
internal FP_Handle f... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal GNU_LinkMap64
gnu_linkmap64_from_linkmap32(GNU_LinkMap32 linkmap32)
{
GNU_LinkMap64 linkmap64 = {0};
linkmap64.addr_vaddr = linkmap32.addr_vaddr;
linkmap64.name_vaddr = linkmap32.name_... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef GNU_H
#define GNU_H
typedef ELF_NoteType GNU_NoteType;
enum
{
GNU_NoteType_Abi = 1,
GNU_NoteType_HwCap = 2,
GNU_NoteType_BuildId = 3,
GNU_NoteType_GoldVersion... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>p_vaddr = first_link_map_vaddr; link_map_vaddr != 0; link_map_vaddr = link_map.next_vaddr) {
if (is_64bit) {
MachineOpResult read_result = mem_read_func(link_map_vaddr, &link_map, sizeof(link_map), mem_read_ud);
if (read_result != MachineOpResult_Ok) { goto exit; }
} else {
GNU_L... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef GNU_PARSE_H
#define GNU_PARSE_H
typedef struct GNU_LinkMapNode
{
GNU_LinkMap64 v;
struct GN<|fim_suffix|>e_rdebug(Arena *arena, B32 is_64bit, U64 first_rdebug_vaddr, MachineOp_MemRead *m... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>ormational;
}
else if(HTTP_StatusCode_FirstSuccessful <= code && code <= HTTP_StatusCode_LastSuccessful)
{
kind = HTTP_StatusKind_Successful;
}
else if(HTTP_StatusCode_FirstRedirection <= code && code <= HTTP_StatusCode_LastRedirection)
{
kind = HTTP_StatusKind_Redirection;
}
else ... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef HTTP_H
#define HTTP_H
////////////////////////////////////////////////////////////////
//~ rjf: Status Codes
typedef enum HTTP_StatusKind
{
HTTP_StatusKind_Null,
HTTP_StatusKind_Informational,
HTTP... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/<|fim_suffix|>NDOWS
# include "win32/http/win32_http.c"
#else
# include "http_stub.c"
#endif
<|fim_middle|>mit/)
#include "http.c"
#if OS_WI<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef HTTP_INC_H
#def<|fim_suffix|>_http.h"
#else
# include "http_stub.h"
#endif
#endif // HTTP_INC_H
<|fim_middle|>ine HTTP_INC_H
#include "http.h"
#if OS_WINDOWS
# include "win32/http/win32<|en... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>sync_tick(void){}
////////////////////////////////////////////////////////////////
//~ rjf: @per_os_impl I/O Ring Functions
internal B32
http_push_request(GuardedRing *out_ring, HTTP_RequestParams *params, U64 endt_us)
{
return 0;
}
internal B32
http_pop_response(Arena *arena, GuardedRing *out_ring, ... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|> // HTTP_STUB_H
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT licens<|fim_middle|>e (https://opensource.org/license/mit/)
#ifndef HTTP_STUB_H
#define HTTP_STUB_H
#endif<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef RADDBG_MARKUP_H
#define RADDBG_MARKUP_H
////////////////////////////////
//~ Implementation Overrides
#if !defined(RADDBG_MARKUP_VSNPRINTF)
# define RADDBG_MARKUP_DEFAULT_VSNPRINTF 1
# defi... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////////////////////////////////////
//~ (R)AD (D)ebug (I)nfo Format Library
//
// Defines standard RDI debug information format types and
// functions.
#ifndef RDI_C
#de... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////////////////////////////////////
//~ (R)AD (D)ebug (I)nfo Format Library
//
// Defines standard RDI debug information format types and
// functions.
#ifndef RDI_H
#define RDI_H
//... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>ms_count);
if(set_opl_idx > all_elems_count)
{
set_opl_idx = all_elems_count;
}
RDI_LocationSetElement *set_first = all_elems + set_first_idx;
RDI_LocationSetElement *set_opl = all_elems + set_opl_idx;
for(RDI_LocationSetElement *e = set_first; e < set_opl; e += 1)
{
... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>I_Parsed *rdi, RDI_Unit *unit);
//- line tables
RDI_PROC RDI_Line rdi_line_from_voff(RDI_Parsed *rdi, RDI_U64 voff);
RDI_PROC RDI_Line rdi_line_from_line_table_voff(RDI_Parsed *rdi, RDI_LineTable *line_table, RDI_U64 voff);
RDI_PROC RDI_SourceFile *rdi_source_file_from_line(RDI_Parsed *rdi, RDI_Line *lin... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: API Implementation Helper Macros
#define RDIM_IdxedChunkListPush(arena, list, chunk_type, element_type, cap_value, result, ...) \
element_type *result = 0; ... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////////////////////////////////////
// RAD Debug Info Make, (R)AD(D)BG(I) (M)ake Library
//
// Library for building loose data structures which contain
// RDI debug infor... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal U64 *
push_u64(Arena *arena, U64 value)
{
U64 *result = push_array_no_zero(arena, U64, 1);
*result = value;
return result;
}
internal U32 *
push_array_copy_u32(Arena *arena, U32 *v, U... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>of(T))
<|fim_prefix|>// Copyright (c) Epic <|fim_middle|>Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#pragma once
internal U64 * push_u64 (Arena *arena, U64 value);
internal U32 * push_array_copy_u32(Arena *arena, U32 *v, U64 count);
internal U64 ... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal U64
void_list_count_nodes(VoidNode *head)
{
U64 node_count = 0;
for EachNode(curr, VoidNode, head) { node_count += 1; }
return node_count;
}
internal void
void_node_concat(VoidNode **head, VoidNode... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>list, U64 v);
internal void u64_list_concat_in_place(U64List *list, U64List *to_concat);
internal B32 u32_array_compare (U32Array a, U32Array b);
internal U32 * u32_array_offsets_from_counts(Arena *arena, U32 *v, U64 count);
internal void u32_array_counts_to_offsets (U64 count, U32 *a... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>idx % 32;
if (state) {
bit_array.v[word_idx] |= (1u << bit_idx);
} else {
bit_array.v[word_idx] &= ~(1u << bit_idx);
}
}
internal U32
bit_array_get_bit32(U32Array bit_array, U64 idx)
{
Assert(idx < bit_array.count*32);
U64 word_idx = idx / 32;
U64 bit_idx = idx % 32;
U32 bit = (bit_... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed unde<|fim_suffix|>license/mit/)
#pragma once
internal U32Array bit_array_init32 (Arena *arena, U64 word_count);
internal U64 bit_array_scan_left_to_right32(U32Array bit_array, U64 lo, U64 hi, B32 state);
internal U64 bit_array_scan_... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmacro-redefined"
#pragma clang diagnostic ignored "-Wsign-conversion"
#elif defined(_MSC_VER)
#pragma warning ... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>("__AVX512VL__")
# define __AVX__ 1
# define __AVX2__ 1
# define __SSE4_1__ 1
# define __AVX512F__ 1
# define __AVX512VL__ 1
# include <immintrin.h>
# pragma pop_macro("__AVX512VL__")
# pragma pop_macro("__AVX512F__")
# pragma pop_macro("__SSE4_1__")
# pragma pop_macro("__AVX2__")
# pragma pop_... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal U16
safe_cast_u16x(U64 x)
{
AssertAlways(x <= max_U16);
return (U16)x;
}
internal U64
u128_mod64(U128 a, U64 b)
{
return a.u64[1] % b;
}
internal Version
make_version(U64 major, U64 ... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|> \
(list)->first = (to_concat)->first; \
(list)->last = (to_concat)->last; \
} \
(list)->count += (to_concat)->count; \
MemoryZeroStruct(to_concat); \
} \
} while... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268,
0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0,
0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8,
0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>rom_string(String8 string);
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under <|fim_middle|>the MIT license (https://opensource.org/license/mit/)
#pragma once
internal U32 update_crc32(U32 crc, U8 *ptr, U64 size);
internal U32 crc32_f<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) E<|fim_suffix|>e "base_bit_array.c"
#include "base_crc32.c"
<|fim_middle|>pic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#include "base_core.c"
#include "base_strings.c"
#include "base_arena.c"
#include "base_arrays.c"
#includ<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#pragma once
#include "base_core.h"
#include "base_strings.h"
#include "base_arena.h"
#include "base_arrays.h"
#include "base_blake3.h"
#include "base_bit_array.h"
#include "base_crc32.h"
<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Co<|fim_suffix|> }
}
} else if (arr.count == 1 && str8_match(arr.v[0], value, 0)) {
return 0;
}
return max_U64;
}
<|fim_middle|>pyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal U64
str8_array_bsearch(String8Array arr, Strin... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#pragma once
internal U64 str8_array_bsearch(String8Array arr, Stri<|fim_suffix|>);
<|fim_middle|>ng8 value<|endoftext|> | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
internal U64
hash_from_cv_symbol(CV_Symbol *symbol)
{
XXH3_state_t hasher;
XXH3_64bits_reset(&hasher);
XXH3_64bits_update(&hasher, &symbol->kind, sizeof(symbol... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>cv_make_const(Arena *arena, CV_SymConstant v, U16 value, String8 name);
internal String8 cv_make_udt(Arena *arena, CV_SymUDT v, String8 name);
internal CV_Symbol cv_make_proc_ref(Arena *arena, CV_ModIndex imod, U32 stream_offset, String8 name, B32 is_local);
internal CV_Symbol cv_make_pub32(Arena *arena... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal void
bucket_list_concat_in_place(BucketList *list, BucketList *to_concat)
{
if (to_concat->first) {
if (list->first) {
list->last->next = to_concat->first;
list->last = to_... | fim | EpicGamesExt/raddebugger | c |
// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#pragma once
typedef struct KeyValuePair
{
union {
String8 key_string;
void *key_raw;
U32 key_u32;
U64 key_u64;
};
union {
String8 value_string;
void *value_raw;
U3... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal B<|fim_suffix|>c->count = 0;
c->v = push_array_no_zero(arena, LFHT_Node, 1024);
SLLQueuePush(node_chunks->first, node_chunks->last, c);
node_chunks->chunk_count ... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>kList *node_chunks, LFHT_Node **root_ptr, U64 hash, void *data, LFHT_IsKeyEqualFunc *is_key_equal, void *is_key_equal_ud);
internal void ** lfht_data_from_node_chunk_lists(Arena *arena, U64 total_count, U64 list_count, LFHT_NodeChunkList *lists);
#endif // LF_HASH_TABLE_H
<|fim_prefix|>// Copyright (c) ... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|> U64 chunk_count, String8 data);
// --- Manifest ----------------------------------------------------------------
internal String8 lnk_make_linker_manifest(Arena *arena, B32 manifest_uac, String8 manifest_level, String8 manifest_ui_access, String8List manifest_dependency_list);
internal void lnk_merg... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>rena, LNK_EnvVar *env_var)
{
return str8_split_by_string_chars(arena, env_var->raw_value, lnk_env_var_chain_separator_from_rule(env_var->rule), 0);
}
internal B32
lnk_env_var_to_u64(HashMap *env_vars, LNK_EnvVar *env_var, U64 *value_out)
{
String8 value = str8_skip_chop_whitespace(env_var->raw_value)... | fim | EpicGamesExt/raddebugger | c |
<|fim_prefix|>// Copyright (c) Epic Games Tools
// Lic<|fim_suffix|>LNK_CmdOption *last_option;
String8List input_list;
String8List raw_cmd_line;
} LNK_CmdLine;
typedef enum LNK_EnvVarRule
{
LNK_EnvVarRule_Null,
LNK_EnvVarRule_Batch,
LNK_EnvVarRule_Bash,
#if OS_WINDOWS
LNK_EnvVarRule_Current,
#elif O... | fim | EpicGamesExt/raddebugger | c |
<|fim_suffix|>lnk_get_image_name (LNK_Config *config);
internal String8 lnk_get_pdb_name (LNK_Config *config);
internal U64 lnk_get_default_function_pad_min (COFF_MachineType machine);
internal U64 lnk_get_base_addr (LNK_Config *config);
internal Version lnk_get_defa... | fim | EpicGamesExt/raddebugger | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.