1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2017 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * outdbg.c output routines for the Netwide Assembler to produce
60 static unsigned long dbg_max_data_dump
= 128;
62 const struct ofmt of_dbg
;
63 static void dbg_init(void)
66 fprintf(ofile
, "NASM Output format debug dump\n");
69 static void dbg_cleanup(void)
73 struct Section
*tmp
= dbgsect
;
74 dbgsect
= dbgsect
->next
;
80 static int32_t dbg_section_names(char *name
, int pass
, int *bits
)
85 * We must have an initial default: let's make it 16.
91 fprintf(ofile
, "section_name on init: returning %d\n",
94 int n
= strcspn(name
, " \t");
95 char *sname
= nasm_strndup(name
, n
);
99 for (s
= dbgsect
; s
; s
= s
->next
)
100 if (!strcmp(s
->name
, sname
))
104 s
= nasm_malloc(sizeof(*s
));
106 s
->number
= seg
= seg_alloc();
109 fprintf(ofile
, "section_name %s (pass %d): returning %d\n",
116 static void dbg_deflabel(char *name
, int32_t segment
, int64_t offset
,
117 int is_global
, char *special
)
119 fprintf(ofile
, "deflabel %s := %08"PRIx32
":%016"PRIx64
" %s (%d)%s%s\n",
120 name
, segment
, offset
,
121 is_global
== 2 ? "common" : is_global
? "global" : "local",
122 is_global
, special
? ": " : "", special
);
125 static const char *out_type(enum out_type type
)
127 static const char *out_types
[] = {
134 static char invalid_buf
[64];
136 if (type
>= sizeof(out_types
)/sizeof(out_types
[0])) {
137 sprintf(invalid_buf
, "[invalid type %d]", type
);
141 return out_types
[type
];
144 static const char *out_sign(enum out_sign sign
)
146 static const char *out_signs
[] = {
151 static char invalid_buf
[64];
153 if (sign
>= sizeof(out_signs
)/sizeof(out_signs
[0])) {
154 sprintf(invalid_buf
, "[invalid sign %d]", sign
);
158 return out_signs
[sign
];
161 static void dbg_out(const struct out_data
*data
)
164 "out to %"PRIx32
":%"PRIx64
" %s %s bits %d insoffs %d/%d "
166 data
->segment
, data
->offset
,
167 out_type(data
->type
), out_sign(data
->type
),
168 data
->bits
, data
->insoffs
, data
->inslen
, data
->size
);
170 fprintf(ofile
, " ins %s(%d)",
171 nasm_insn_names
[data
->itemp
->opcode
], data
->itemp
->operands
);
173 fprintf(ofile
, " (data)");
176 if (data
->type
== OUT_ADDRESS
|| data
->type
== OUT_RELADDR
||
177 data
->type
== OUT_SEGMENT
) {
178 fprintf(ofile
, " target %"PRIx32
":%"PRIx64
,
179 data
->tsegment
, data
->toffset
);
180 if (data
->twrt
!= NO_SEG
)
181 fprintf(ofile
, " wrt %"PRIx32
, data
->twrt
);
183 if (data
->type
== OUT_RELADDR
)
184 fprintf(ofile
, " relbase %"PRId64
, data
->relbase
);
188 if (data
->type
== OUT_RAWDATA
) {
189 if ((size_t)data
->size
!= data
->size
) {
190 fprintf(ofile
, " data: <error: impossible size>\n");
191 } else if (!data
->data
) {
192 fprintf(ofile
, " data: <error: null pointer>\n");
193 } else if (dbg_max_data_dump
!= -1UL &&
194 data
->size
> dbg_max_data_dump
) {
195 fprintf(ofile
, " data: <%"PRIu64
" bytes>\n", data
->size
);
198 const uint8_t *bytes
= data
->data
;
199 for (i
= 0; i
< data
->size
; i
+= 16) {
200 fprintf(ofile
, " data:");
201 for (j
= 0; j
< 16; j
++) {
202 if (i
+j
>= data
->size
)
205 fprintf(ofile
, "%c%02x",
206 (j
== 8) ? '-' : ' ', bytes
[i
+j
]);
209 for (j
= 0; j
< 16; j
++) {
210 if (i
+j
>= data
->size
) {
213 if (bytes
[i
+j
] >= 32 && bytes
[i
+j
] <= 126)
214 putc(bytes
[i
+j
], ofile
);
224 /* This is probably the only place were we'll call this this way... */
225 nasm_do_legacy_output(data
);
228 static void dbg_legacy_out(int32_t segto
, const void *data
,
229 enum out_type type
, uint64_t size
,
230 int32_t segment
, int32_t wrt
)
234 if (type
== OUT_ADDRESS
)
235 fprintf(ofile
, " legacy: out to %"PRIx32
", len = %d: ",
236 segto
, (int)abs((int)size
));
238 fprintf(ofile
, " legacy: out to %"PRIx32
", len = %"PRIu64
": ",
243 fprintf(ofile
, "reserved.\n");
246 fprintf(ofile
, "rawdata\n"); /* Already have a data dump */
249 ldata
= *(int64_t *)data
;
250 fprintf(ofile
, "addr %08"PRIx32
" (seg %08"PRIx32
", wrt %08"PRIx32
")\n",
251 ldata
, segment
, wrt
);
254 fprintf(ofile
, "rel1adr %02"PRIx8
" (seg %08"PRIx32
")\n",
255 (uint8_t)*(int64_t *)data
, segment
);
258 fprintf(ofile
, "rel2adr %04"PRIx16
" (seg %08"PRIx32
")\n",
259 (uint16_t)*(int64_t *)data
, segment
);
262 fprintf(ofile
, "rel4adr %08"PRIx32
" (seg %08"PRIx32
")\n",
263 (uint32_t)*(int64_t *)data
,
267 fprintf(ofile
, "rel8adr %016"PRIx64
" (seg %08"PRIx32
")\n",
268 (uint64_t)*(int64_t *)data
, segment
);
271 fprintf(ofile
, "unknown\n");
276 static void dbg_sectalign(int32_t seg
, unsigned int value
)
278 fprintf(ofile
, "set alignment (%d) for segment (%u)\n",
282 static int32_t dbg_segbase(int32_t segment
)
287 static const char *directive_name(enum directives directive
)
289 static char invalid_buf
[64];
291 if (directive
>= DIRECTIVE_END
|| !directives
[directive
]) {
292 sprintf(invalid_buf
, "%d", directive
);
296 return directives
[directive
];
299 static enum directive_result
300 dbg_directive(enum directives directive
, char *value
, int pass
)
302 fprintf(ofile
, "directive [%s] value [%s] (pass %d)\n",
303 directive_name(directive
), value
, pass
);
307 static enum directive_result
308 dbg_pragma(const struct pragma
*pragma
)
310 fprintf(ofile
, "pragma %s(%s) %s[%s] %s\n",
311 pragma
->facility_name
,
312 pragma
->facility
->name
? pragma
->facility
->name
: "<default>",
313 pragma
->opname
, directive_name(pragma
->opcode
),
319 static void dbg_filename(char *inname
, char *outname
)
321 standard_extension(inname
, outname
, ".dbg");
324 static const char * const types
[] = {
325 "unknown", "label", "byte", "word", "dword", "float", "qword", "tbyte"
327 static void dbgdbg_init(void)
329 fprintf(ofile
, " With debug info\n");
331 static void dbgdbg_cleanup(void)
335 static void dbgdbg_linnum(const char *lnfname
, int32_t lineno
, int32_t segto
)
337 fprintf(ofile
, "dbglinenum %s(%"PRId32
") segment %"PRIx32
"\n",
338 lnfname
, lineno
, segto
);
340 static void dbgdbg_deflabel(char *name
, int32_t segment
,
341 int64_t offset
, int is_global
, char *special
)
343 fprintf(ofile
, "dbglabel %s := %08"PRIx32
":%016"PRIx64
" %s (%d)%s%s\n",
346 is_global
== 2 ? "common" : is_global
? "global" : "local",
347 is_global
, special
? ": " : "", special
);
349 static void dbgdbg_define(const char *type
, const char *params
)
351 fprintf(ofile
, "dbgdirective [%s] value [%s]\n", type
, params
);
353 static void dbgdbg_output(int output_type
, void *param
)
358 static void dbgdbg_typevalue(int32_t type
)
360 fprintf(ofile
, "new type: %s(%"PRIX32
")\n",
361 types
[TYM_TYPE(type
) >> 3], TYM_ELEMENTS(type
));
364 static const struct pragma_facility dbgdbg_pragma_list
[] = {
365 { "dbgdbg", dbg_pragma
},
366 { NULL
, dbg_pragma
} /* Won't trigger, "debug" is a reserved ns */
369 static const struct dfmt debug_debug_form
= {
370 "Trace of all info passed to debug stage",
382 static const struct dfmt
* const debug_debug_arr
[3] = {
388 static const struct pragma_facility dbg_pragma_list
[] = {
392 const struct ofmt of_dbg
= {
393 "Trace of all info passed to output stage",