Mercurial > repos > blastem

comparison vos_program_module.c @ 744:fc68992cf18d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge windows branch with latest changes
author Michael Pavone <pavone@retrodev.com>
date Thu, 28 May 2015 21:19:55 -0700
parents de6f00204fa2
children
comparison
equal deleted inserted replaced
743:cf78cb045fa4 744:fc68992cf18d
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stddef.h>
4 #include <string.h>
5 #include "vos_program_module.h"
6
7 static uint16_t big16(uint8_t ** src)
8 {
9 uint16_t ret = *((*src)++) << 8;
10 ret |= *((*src)++);
11 return ret;
12 }
13
14 static uint32_t big32(uint8_t ** src)
15 {
16 uint32_t ret = *((*src)++) << 24;
17 ret |= *((*src)++) << 16;
18 ret |= *((*src)++) << 8;
19 ret |= *((*src)++);
20 return ret;
21 }
22
23 static void string_(uint8_t ** src, uint16_t *len, char * str, uint32_t storage)
24 {
25 *len = big16(src);
26 memcpy(str, *src, storage);
27 *src += storage;
28 if (*len >= storage)
29 {
30 *len = storage;
31 } else {
32 str[*len] = 0;
33 }
34 if (storage & 1)
35 {
36 (*src)++;
37 }
38 }
39
40 #define string(src, field) string_(src, &(field).len, (field).str, sizeof((field).str))
41
42
43 int vos_read_header(FILE * f, vos_program_module *out)
44 {
45 uint8_t buffer[4096];
46 if (fread(buffer, 1, sizeof(buffer), f) != sizeof(buffer))
47 {
48 return 0;
49 }
50 uint8_t *cur = buffer;
51 out->version = big16(&cur);
52 string(&cur, out->binder_version);
53 string(&cur, out->binder_options);
54 string(&cur, out->system_name);
55 string(&cur, out->user_name);
56 out->date_bound = big32(&cur);
57 out->main_entry_link.code_address = big32(&cur);
58 out->main_entry_link.static_address = big32(&cur);
59 out->user_boundary = big32(&cur);
60 out->n_modules = big16(&cur);
61 out->n_external_vars = big16(&cur);
62 out->n_link_names = big16(&cur);
63 out->n_unsnapped_links = big16(&cur);
64 out->n_vm_pages = big16(&cur);
65 out->n_header_pages = big16(&cur);
66 for (int i = 0; i < 3; i++)
67 {
68 for (int j = 0; j < 4; j++)
69 {
70 out->info[i][j].address = big32(&cur);
71 out->info[i][j].len = big32(&cur);
72 }
73 }
74 out->module_map_address = big32(&cur);
75 out->module_map_len = big32(&cur);
76 out->external_vars_map_address = big32(&cur);
77 out->external_vars_map_len = big32(&cur);
78 out->link_names_map_address = big32(&cur);
79 out->link_names_map_len = big32(&cur);
80 out->link_map_address = big32(&cur);
81 out->link_map_len = big32(&cur);
82 out->header_address = big32(&cur);
83 out->header_len = big32(&cur);
84 memcpy(out->access_info, cur, sizeof(out->access_info));
85 cur += sizeof(out->access_info);
86 out->flags = big32(&cur);
87 out->n_tasks = big16(&cur);
88 for (int i = 0; i < 3; i++)
89 {
90 out->task_static_len[i] = big32(&cur);
91 }
92 out->stack_len = big32(&cur);
93 out->n_entries = big16(&cur);
94 out->entry_map_address = big32(&cur);
95 out->entry_map_len = big32(&cur);
96 out->pop_version = big16(&cur);
97 out->processor = big16(&cur);
98 string(&cur, out->release_name);
99 out->relocation_info.map_address = big32(&cur);
100 out->relocation_info.map_len = big32(&cur);
101 out->relocation_info.n_relocations = big32(&cur);
102 out->high_water_mark = big32(&cur);
103 string(&cur, out->copyright_notice);
104 for (int i = 0; i < 14; i++)
105 {
106 out->module_origins[i] = big32(&cur);
107 }
108 out->processor_family = big16(&cur);
109 string(&cur, out->program_name);
110 out->string_pool_address = big32(&cur);
111 out->string_pool_len = big32(&cur);
112 out->obj_dir_map_address = big32(&cur);
113 out->obj_dir_map_len = big32(&cur);
114 for (int i = 0; i < 3; i++)
115 {
116 out->global_offset_table_address[i] = big32(&cur);
117 }
118 for (int i = 0; i < 3; i++)
119 {
120 out->block_map_info[i].address = big32(&cur);
121 out->block_map_info[i].len = big32(&cur);
122 }
123 out->section_map_file_address = big32(&cur);
124 out->section_map_address = big32(&cur);
125 out->section_map_len = big32(&cur);
126 out->n_sections = big16(&cur);
127 out->max_heap_size = big32(&cur);
128 out->max_program_size = big32(&cur);
129 out->max_stack_size = big32(&cur);
130 out->stack_fence_size = big32(&cur);
131
132 out->module_map_entries = NULL;
133 out->external_vars = NULL;
134 return 1;
135 }
136
137 #define MODULE_MAP_ENTRY_SIZE 74
138
139 int vos_read_alloc_module_map(FILE * f, vos_program_module *header)
140 {
141 if (header->module_map_len != header->n_modules * MODULE_MAP_ENTRY_SIZE)
142 {
143 return 0;
144 }
145 uint8_t * buf = malloc(header->module_map_len);
146 fseek(f, header->module_map_address + 0x1000 - header->user_boundary, SEEK_SET);
147 if (fread(buf, 1, header->module_map_len, f) != header->module_map_len)
148 {
149 free(buf);
150 return 0;
151 }
152 uint8_t * cur = buf;
153 header->module_map_entries = malloc(sizeof(vos_module_map_entry) * header->n_modules);
154 for (int i = 0; i < header->n_modules; i++)
155 {
156 string(&cur, header->module_map_entries[i].name);
157 for (int j = 0; j < 5; j++)
158 {
159 header->module_map_entries[i].unknown[j] = big16(&cur);
160 }
161 header->module_map_entries[i].code_address = big32(&cur);
162 header->module_map_entries[i].code_length = big32(&cur);
163 header->module_map_entries[i].foo_address = big32(&cur);
164 header->module_map_entries[i].foo_length = big32(&cur);
165 header->module_map_entries[i].bar_address = big32(&cur);
166 header->module_map_entries[i].bar_length = big32(&cur);
167 for (int j = 0; j < 3; j++)
168 {
169 header->module_map_entries[i].unknown2[j] = big16(&cur);
170 }
171 }
172 return 1;
173 }
174
175 #define EXTERNAL_VAR_ENTRY_SIZE 44
176
177 int vos_read_alloc_external_vars(FILE * f, vos_program_module *header)
178 {
179 if (header->external_vars_map_len != header->n_external_vars * EXTERNAL_VAR_ENTRY_SIZE)
180 {
181 return 0;
182 }
183 uint8_t * buf = malloc(header->external_vars_map_len);
184 fseek(f, header->external_vars_map_address + 0x1000 - header->user_boundary, SEEK_SET);
185 if (fread(buf, 1, header->external_vars_map_len, f) != header->external_vars_map_len)
186 {
187 free(buf);
188 return 0;
189 }
190 uint8_t * cur = buf;
191 header->external_vars = malloc(sizeof(vos_external_var_entry) * header->n_external_vars);
192 for (int i = 0; i < header->n_external_vars; i++)
193 {
194 string(&cur, header->external_vars[i].name);
195 header->external_vars[i].address = big32(&cur);
196 for (int j = 0; j < 3; j++)
197 {
198 header->external_vars[i].unknown[j] = big16(&cur);
199 }
200 }
201 return 1;
202 }
203
204 void vos_header_cleanup(vos_program_module *header)
205 {
206 free(header->module_map_entries);
207 free(header->external_vars);
208 }