mirror of
https://github.com/GLEGram/GLEGram-iOS.git
synced 2026-07-12 02:16:38 +02:00
Leeksov
4647310322
Based on Swiftgram 12.5 (Telegram iOS 12.5). All GLEGram features ported and organized in GLEGram/ folder. Features: Ghost Mode, Saved Deleted Messages, Content Protection Bypass, Font Replacement, Fake Profile, Chat Export, Plugin System, and more. See CHANGELOG_12.5.md for full details.
1103 lines
36 KiB
C
1103 lines
36 KiB
C
/*
|
|
* CodeView debugging format - symbol and line information
|
|
*
|
|
* Copyright (C) 2006-2007 Peter Johnson
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the author nor the names of other contributors
|
|
* may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
#include <util.h>
|
|
|
|
#include <libyasm.h>
|
|
|
|
#include "cv-dbgfmt.h"
|
|
|
|
enum cv8_symheadtype {
|
|
CV8_DEBUG_SYMS = 0xF1, /* CV5 symbol information */
|
|
CV8_LINE_NUMS = 0xF2, /* line numbers for a section */
|
|
CV8_FILE_STRTAB = 0xF3, /* filename string table */
|
|
CV8_FILE_INFO = 0xF4 /* source file info */
|
|
};
|
|
|
|
enum cv_symtype {
|
|
/* Non-modal Symbols */
|
|
CV_S_COMPILE = 0x0001, /* Compile Flag */
|
|
CV_S_REGISTER = 0x0002, /* Register */
|
|
CV_S_CONSTANT = 0x0003, /* Constant */
|
|
CV_S_UDT = 0x0004, /* User-defined Type */
|
|
CV_S_SSEARCH = 0x0005, /* Start Search */
|
|
CV_S_END = 0x0006, /* End of Block */
|
|
CV_S_SKIP = 0x0007, /* Skip Record */
|
|
CV_S_OBJNAME = 0x0009, /* Object File Name */
|
|
CV_S_ENDARG = 0x000a, /* End of Arguments */
|
|
CV_S_COBOLUDT = 0x000b, /* COBOL User-defined Type */
|
|
CV_S_MANYREG = 0x000c, /* Many Registers */
|
|
CV_S_RETURN = 0x000d, /* Function Return */
|
|
CV_S_ENTRYTHIS = 0x000e, /* "this" at Method Entry */
|
|
|
|
/* Symbols for 16:16 Segmented Architectures */
|
|
CV_S_BPREL16 = 0x0100, /* BP Relative 16:16 */
|
|
CV_S_LDATA16 = 0x0101, /* Local Data 16:16 */
|
|
CV_S_GDATA16 = 0x0102, /* Global Data Symbol 16:16 */
|
|
CV_S_PUB16 = 0x0103, /* Public Symbol 16:16 */
|
|
CV_S_LPROC16 = 0x0104, /* Local Start 16:16 */
|
|
CV_S_GPROC16 = 0x0105, /* Global Start 16:16 */
|
|
CV_S_THUNK16 = 0x0106, /* Thunk Start 16:16 */
|
|
CV_S_BLOCK16 = 0x0107, /* Block Start 16:16 */
|
|
CV_S_WITH16 = 0x0108, /* With Start 16:16 */
|
|
CV_S_LABEL16 = 0x0109, /* Code Label 16:16 */
|
|
CV_S_CEXMODEL16 = 0x0110, /* Change Execution Model 16:16 */
|
|
CV_S_VFTPATH16 = 0x010b, /* Virtual Function Table Path 16:16 */
|
|
CV_S_REGREL16 = 0x010c, /* Register Relative 16:16 */
|
|
|
|
/* Symbols for 16:32 Segmented Architectures */
|
|
CV_S_BPREL32 = 0x0200, /* BP Relative 16:32 */
|
|
CV_S_LDATA32 = 0x0201, /* Local Data 16:32 */
|
|
CV_S_GDATA32 = 0x0202, /* Global Data Symbol 16:32 */
|
|
CV_S_PUB32 = 0x0203, /* Public Symbol 16:32 */
|
|
CV_S_LPROC32 = 0x0204, /* Local Start 16:32 */
|
|
CV_S_GPROC32 = 0x0205, /* Global Start 16:32 */
|
|
CV_S_THUNK32 = 0x0206, /* Thunk Start 16:32 */
|
|
CV_S_BLOCK32 = 0x0207, /* Block Start 16:32 */
|
|
CV_S_WITH32 = 0x0208, /* With Start 16:32 */
|
|
CV_S_LABEL32 = 0x0209, /* Code Label 16:32 */
|
|
CV_S_CEXMODEL32 = 0x0210, /* Change Execution Model 16:32 */
|
|
CV_S_VFTPATH32 = 0x020b, /* Virtual Function Table Path 16:32 */
|
|
CV_S_REGREL32 = 0x020c, /* Register Relative 16:32 */
|
|
CV_S_LTHREAD32 = 0x020d, /* Local Thread Storage 16:32 */
|
|
CV_S_GTHREAD32 = 0x020e, /* Global Thread Storage 16:32 */
|
|
|
|
/* Symbols for MIPS */
|
|
CV_S_LPROCMIPS = 0x0300, /* Local procedure start MIPS */
|
|
CV_S_GPROCMIPS = 0x0301, /* Global procedure start MIPS */
|
|
|
|
/* Symbols for CV8 - strings are 0 terminated rather than length-prefix.
|
|
* Incomplete and unofficial.
|
|
*/
|
|
CV8_S_OBJNAME = 0x1101, /* Object File Name */
|
|
CV8_S_LABEL32 = 0x1105, /* Code Label 16:32 */
|
|
CV8_S_LDATA32 = 0x110c, /* Local Data 16:32 */
|
|
CV8_S_GDATA32 = 0x110d, /* Global Data 16:32 */
|
|
CV8_S_LPROC32 = 0x1110, /* Local Start 16:32 */
|
|
CV8_S_COMPILE = 0x1116 /* Compile Flag */
|
|
};
|
|
|
|
typedef struct cv8_symhead {
|
|
enum cv8_symheadtype type;
|
|
yasm_bytecode *start_prevbc;
|
|
yasm_bytecode *end_prevbc;
|
|
int first; /* nonzero if first symhead in section */
|
|
} cv8_symhead;
|
|
|
|
typedef struct cv8_fileinfo {
|
|
const cv_filename *fn;
|
|
} cv8_fileinfo;
|
|
|
|
/* Note: each line number group is associated with a file AND a section */
|
|
typedef struct cv8_linepair {
|
|
unsigned long offset;
|
|
unsigned long line;
|
|
} cv8_linepair;
|
|
|
|
/* Decrease linked list overhead a bit doing it this way */
|
|
typedef struct cv8_lineset {
|
|
STAILQ_ENTRY(cv8_lineset) link;
|
|
cv8_linepair pairs[126];
|
|
size_t num_pairs;
|
|
} cv8_lineset;
|
|
|
|
/* Note: Due to line number sorting requirements (by section offset it seems)
|
|
* one file may need more than one record per section. */
|
|
typedef struct cv8_lineinfo {
|
|
STAILQ_ENTRY(cv8_lineinfo) link;
|
|
const cv_filename *fn; /* filename associated with line numbers */
|
|
yasm_section *sect; /* section line numbers are for */
|
|
yasm_symrec *sectsym; /* symbol for beginning of sect */
|
|
unsigned long num_linenums;
|
|
int first_in_sect; /* First lineinfo for this section. */
|
|
STAILQ_HEAD(cv8_lineset_head, cv8_lineset) linesets;
|
|
} cv8_lineinfo;
|
|
|
|
/* Symbols use a bit of meta-programming to encode formats: each character
|
|
* of format represents the output generated, as follows:
|
|
* 'b' : 1 byte value (integer)
|
|
* 'h' : 2 byte value (integer)
|
|
* 'w' : 4 byte value (integer)
|
|
* 'Y' : symrec SECREL+SECTION (pointer)
|
|
* 'T' : type index (integer)
|
|
* 'S' : length-prefixed string (pointer)
|
|
* 'Z' : 0-terminated string (pointer)
|
|
*/
|
|
typedef struct cv_sym {
|
|
enum cv_symtype type;
|
|
const char *format;
|
|
union {
|
|
unsigned long i;
|
|
void *p;
|
|
} args[10];
|
|
} cv_sym;
|
|
|
|
/* Bytecode callback function prototypes */
|
|
static void cv8_symhead_bc_destroy(void *contents);
|
|
static void cv8_symhead_bc_print(const void *contents, FILE *f,
|
|
int indent_level);
|
|
static int cv8_symhead_bc_calc_len
|
|
(yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data);
|
|
static int cv8_symhead_bc_tobytes
|
|
(yasm_bytecode *bc, unsigned char **bufp, unsigned char *bufstart, void *d,
|
|
yasm_output_value_func output_value,
|
|
/*@null@*/ yasm_output_reloc_func output_reloc);
|
|
|
|
static void cv8_fileinfo_bc_destroy(void *contents);
|
|
static void cv8_fileinfo_bc_print(const void *contents, FILE *f,
|
|
int indent_level);
|
|
static int cv8_fileinfo_bc_calc_len
|
|
(yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data);
|
|
static int cv8_fileinfo_bc_tobytes
|
|
(yasm_bytecode *bc, unsigned char **bufp, unsigned char *bufstart, void *d,
|
|
yasm_output_value_func output_value,
|
|
/*@null@*/ yasm_output_reloc_func output_reloc);
|
|
|
|
static void cv8_lineinfo_bc_destroy(void *contents);
|
|
static void cv8_lineinfo_bc_print(const void *contents, FILE *f,
|
|
int indent_level);
|
|
static int cv8_lineinfo_bc_calc_len
|
|
(yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data);
|
|
static int cv8_lineinfo_bc_tobytes
|
|
(yasm_bytecode *bc, unsigned char **bufp, unsigned char *bufstart, void *d,
|
|
yasm_output_value_func output_value,
|
|
/*@null@*/ yasm_output_reloc_func output_reloc);
|
|
|
|
static void cv_sym_bc_destroy(void *contents);
|
|
static void cv_sym_bc_print(const void *contents, FILE *f, int indent_level);
|
|
static int cv_sym_bc_calc_len
|
|
(yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data);
|
|
static int cv_sym_bc_tobytes
|
|
(yasm_bytecode *bc, unsigned char **bufp, unsigned char *bufstart, void *d,
|
|
yasm_output_value_func output_value,
|
|
/*@null@*/ yasm_output_reloc_func output_reloc);
|
|
|
|
/* Bytecode callback structures */
|
|
static const yasm_bytecode_callback cv8_symhead_bc_callback = {
|
|
cv8_symhead_bc_destroy,
|
|
cv8_symhead_bc_print,
|
|
yasm_bc_finalize_common,
|
|
NULL,
|
|
cv8_symhead_bc_calc_len,
|
|
yasm_bc_expand_common,
|
|
cv8_symhead_bc_tobytes,
|
|
0
|
|
};
|
|
|
|
static const yasm_bytecode_callback cv8_fileinfo_bc_callback = {
|
|
cv8_fileinfo_bc_destroy,
|
|
cv8_fileinfo_bc_print,
|
|
yasm_bc_finalize_common,
|
|
NULL,
|
|
cv8_fileinfo_bc_calc_len,
|
|
yasm_bc_expand_common,
|
|
cv8_fileinfo_bc_tobytes,
|
|
0
|
|
};
|
|
|
|
static const yasm_bytecode_callback cv8_lineinfo_bc_callback = {
|
|
cv8_lineinfo_bc_destroy,
|
|
cv8_lineinfo_bc_print,
|
|
yasm_bc_finalize_common,
|
|
NULL,
|
|
cv8_lineinfo_bc_calc_len,
|
|
yasm_bc_expand_common,
|
|
cv8_lineinfo_bc_tobytes,
|
|
0
|
|
};
|
|
|
|
static const yasm_bytecode_callback cv_sym_bc_callback = {
|
|
cv_sym_bc_destroy,
|
|
cv_sym_bc_print,
|
|
yasm_bc_finalize_common,
|
|
NULL,
|
|
cv_sym_bc_calc_len,
|
|
yasm_bc_expand_common,
|
|
cv_sym_bc_tobytes,
|
|
0
|
|
};
|
|
|
|
static cv8_symhead *cv8_add_symhead(yasm_section *sect, unsigned long type,
|
|
int first);
|
|
static void cv8_set_symhead_end(cv8_symhead *head, yasm_bytecode *end_prevbc);
|
|
|
|
static yasm_bytecode *cv8_add_fileinfo
|
|
(yasm_section *sect, const cv_filename *fn);
|
|
|
|
static unsigned long cv_sym_size(const cv_sym *cvs);
|
|
|
|
|
|
static cv_sym *
|
|
cv8_add_sym_objname(yasm_section *sect, /*@keep@*/ char *objname)
|
|
{
|
|
yasm_bytecode *bc;
|
|
cv_sym *cvs = yasm_xmalloc(sizeof(cv_sym));
|
|
cvs->type = CV8_S_OBJNAME;
|
|
cvs->format = "wZ";
|
|
cvs->args[0].i = 0; /* signature (0=asm) */
|
|
cvs->args[1].p = objname; /* object filename */
|
|
|
|
bc = yasm_bc_create_common(&cv_sym_bc_callback, cvs, 0);
|
|
bc->len = cv_sym_size(cvs);
|
|
yasm_cv__append_bc(sect, bc);
|
|
return cvs;
|
|
}
|
|
|
|
static cv_sym *
|
|
cv8_add_sym_compile(yasm_object *object, yasm_section *sect,
|
|
/*@keep@*/ char *creator)
|
|
{
|
|
yasm_bytecode *bc;
|
|
cv_sym *cvs = yasm_xmalloc(sizeof(cv_sym));
|
|
cvs->type = CV8_S_COMPILE;
|
|
cvs->format = "wwwwZh";
|
|
cvs->args[0].i = 3; /* language (3=Masm) */
|
|
|
|
/* target processor; 0xD0 = AMD64 */
|
|
if (strcmp(yasm_arch_keyword(object->arch), "x86") == 0) {
|
|
if (strcmp(yasm_arch_get_machine(object->arch), "amd64") == 0)
|
|
cvs->args[1].i = 0xD0;
|
|
else
|
|
cvs->args[1].i = 0x6; /* 686, FIXME */
|
|
} else
|
|
cvs->args[1].i = 0; /* XXX: unknown */
|
|
|
|
cvs->args[2].i = 0; /* flags (assume 0 for now) */
|
|
cvs->args[3].i = 0; /* creator version number (assume 0 for now) */
|
|
cvs->args[4].p = creator; /* creator string */
|
|
cvs->args[5].i = 0; /* no pairs of key/value */
|
|
|
|
bc = yasm_bc_create_common(&cv_sym_bc_callback, cvs, 0);
|
|
bc->len = cv_sym_size(cvs);
|
|
yasm_cv__append_bc(sect, bc);
|
|
return cvs;
|
|
}
|
|
|
|
static cv_sym *
|
|
cv8_add_sym_label(yasm_section *sect, yasm_symrec *sym)
|
|
{
|
|
yasm_bytecode *bc;
|
|
cv_sym *cvs = yasm_xmalloc(sizeof(cv_sym));
|
|
cvs->type = CV8_S_LABEL32;
|
|
cvs->format = "YbZ";
|
|
cvs->args[0].p = sym; /* symrec for label */
|
|
cvs->args[1].i = 0; /* flags (assume 0 for now) */
|
|
cvs->args[2].p = yasm__xstrdup(yasm_symrec_get_name(sym));
|
|
|
|
bc = yasm_bc_create_common(&cv_sym_bc_callback, cvs, 0);
|
|
bc->len = cv_sym_size(cvs);
|
|
yasm_cv__append_bc(sect, bc);
|
|
return cvs;
|
|
}
|
|
|
|
static cv_sym *
|
|
cv8_add_sym_data(yasm_section *sect, unsigned long type, yasm_symrec *sym,
|
|
int is_global)
|
|
{
|
|
yasm_bytecode *bc;
|
|
cv_sym *cvs = yasm_xmalloc(sizeof(cv_sym));
|
|
cvs->type = is_global ? CV8_S_GDATA32 : CV8_S_LDATA32;
|
|
cvs->format = "wYZ";
|
|
cvs->args[0].i = type; /* type index */
|
|
cvs->args[1].p = sym; /* symrec for label */
|
|
cvs->args[2].p = yasm__xstrdup(yasm_symrec_get_name(sym));
|
|
|
|
bc = yasm_bc_create_common(&cv_sym_bc_callback, cvs, 0);
|
|
bc->len = cv_sym_size(cvs);
|
|
yasm_cv__append_bc(sect, bc);
|
|
return cvs;
|
|
}
|
|
|
|
static size_t
|
|
cv_dbgfmt_add_file(yasm_dbgfmt_cv *dbgfmt_cv, size_t filenum,
|
|
const char *filename)
|
|
{
|
|
char *pathname;
|
|
size_t i;
|
|
yasm_md5_context context;
|
|
FILE *f;
|
|
unsigned char *buf;
|
|
size_t len;
|
|
|
|
/* Put the filename into the filename table */
|
|
if (filenum == 0) {
|
|
/* Look to see if we already have that filename in the table */
|
|
for (; filenum<dbgfmt_cv->filenames_size; filenum++) {
|
|
if (!dbgfmt_cv->filenames[filenum].filename ||
|
|
strcmp(dbgfmt_cv->filenames[filenum].filename, filename) == 0)
|
|
break;
|
|
}
|
|
} else
|
|
filenum--; /* array index is 0-based */
|
|
|
|
/* Realloc table if necessary */
|
|
if (filenum >= dbgfmt_cv->filenames_allocated) {
|
|
size_t old_allocated = dbgfmt_cv->filenames_allocated;
|
|
dbgfmt_cv->filenames_allocated = filenum+32;
|
|
dbgfmt_cv->filenames = yasm_xrealloc(dbgfmt_cv->filenames,
|
|
sizeof(cv_filename)*dbgfmt_cv->filenames_allocated);
|
|
for (i=old_allocated; i<dbgfmt_cv->filenames_allocated; i++) {
|
|
dbgfmt_cv->filenames[i].pathname = NULL;
|
|
dbgfmt_cv->filenames[i].filename = NULL;
|
|
dbgfmt_cv->filenames[i].str_off = 0;
|
|
dbgfmt_cv->filenames[i].info_off = 0;
|
|
}
|
|
}
|
|
|
|
/* Calculate MD5 checksum of file */
|
|
buf = yasm_xmalloc(1024);
|
|
yasm_md5_init(&context);
|
|
f = fopen(filename, "rb");
|
|
if (!f)
|
|
yasm__fatal(N_("codeview: could not open source file"));
|
|
while ((len = fread(buf, 1, 1024, f)) > 0)
|
|
yasm_md5_update(&context, buf, (unsigned long)len);
|
|
yasm_md5_final(dbgfmt_cv->filenames[filenum].digest, &context);
|
|
fclose(f);
|
|
yasm_xfree(buf);
|
|
|
|
/* Actually save in table */
|
|
if (dbgfmt_cv->filenames[filenum].pathname)
|
|
yasm_xfree(dbgfmt_cv->filenames[filenum].pathname);
|
|
if (dbgfmt_cv->filenames[filenum].filename)
|
|
yasm_xfree(dbgfmt_cv->filenames[filenum].filename);
|
|
|
|
pathname = yasm__abspath(filename);
|
|
dbgfmt_cv->filenames[filenum].pathname = pathname;
|
|
dbgfmt_cv->filenames[filenum].filename = yasm__xstrdup(filename);
|
|
|
|
/* Update table size */
|
|
if (filenum >= dbgfmt_cv->filenames_size)
|
|
dbgfmt_cv->filenames_size = filenum + 1;
|
|
|
|
return filenum;
|
|
}
|
|
|
|
static yasm_bytecode *
|
|
cv_append_str(yasm_section *sect, const char *str)
|
|
{
|
|
yasm_datavalhead dvs;
|
|
yasm_bytecode *bc;
|
|
|
|
yasm_dvs_initialize(&dvs);
|
|
yasm_dvs_append(&dvs, yasm_dv_create_string(yasm__xstrdup(str),
|
|
strlen(str)));
|
|
bc = yasm_bc_create_data(&dvs, 1, 1, NULL, 0);
|
|
yasm_bc_finalize(bc, yasm_cv__append_bc(sect, bc));
|
|
yasm_bc_calc_len(bc, NULL, NULL);
|
|
return bc;
|
|
}
|
|
|
|
typedef struct cv_line_info {
|
|
yasm_section *debug_symline;
|
|
yasm_object *object;
|
|
yasm_dbgfmt_cv *dbgfmt_cv;
|
|
yasm_linemap *linemap;
|
|
yasm_errwarns *errwarns;
|
|
unsigned int num_lineinfos;
|
|
STAILQ_HEAD(cv8_lineinfo_head, cv8_lineinfo) cv8_lineinfos;
|
|
/*@null@*/ cv8_lineinfo *cv8_cur_li;
|
|
/*@null@*/ cv8_lineset *cv8_cur_ls;
|
|
} cv_line_info;
|
|
|
|
static int
|
|
cv_generate_line_bc(yasm_bytecode *bc, /*@null@*/ void *d)
|
|
{
|
|
cv_line_info *info = (cv_line_info *)d;
|
|
yasm_dbgfmt_cv *dbgfmt_cv = info->dbgfmt_cv;
|
|
size_t i;
|
|
const char *filename;
|
|
unsigned long line;
|
|
/*@null@*/ yasm_bytecode *nextbc = yasm_bc__next(bc);
|
|
yasm_section *sect = yasm_bc_get_section(bc);
|
|
|
|
if (nextbc && bc->offset == nextbc->offset)
|
|
return 0;
|
|
|
|
yasm_linemap_lookup(info->linemap, bc->line, &filename, &line);
|
|
|
|
if (!info->cv8_cur_li
|
|
|| strcmp(filename, info->cv8_cur_li->fn->filename) != 0) {
|
|
yasm_bytecode *sectbc;
|
|
char symname[8];
|
|
int first_in_sect = !info->cv8_cur_li;
|
|
|
|
/* Find file */
|
|
for (i=0; i<dbgfmt_cv->filenames_size; i++) {
|
|
if (strcmp(filename, dbgfmt_cv->filenames[i].filename) == 0)
|
|
break;
|
|
}
|
|
if (i >= dbgfmt_cv->filenames_size)
|
|
yasm_internal_error(N_("could not find filename in table"));
|
|
|
|
/* and create new lineinfo structure */
|
|
info->cv8_cur_li = yasm_xmalloc(sizeof(cv8_lineinfo));
|
|
info->cv8_cur_li->fn = &dbgfmt_cv->filenames[i];
|
|
info->cv8_cur_li->sect = sect;
|
|
info->cv8_cur_li->first_in_sect = first_in_sect;
|
|
sectbc = yasm_section_bcs_first(sect);
|
|
if (sectbc->symrecs && sectbc->symrecs[0])
|
|
info->cv8_cur_li->sectsym = sectbc->symrecs[0];
|
|
else {
|
|
sprintf(symname, ".%06u", info->num_lineinfos++);
|
|
info->cv8_cur_li->sectsym =
|
|
yasm_symtab_define_label(info->object->symtab, symname, sectbc,
|
|
1, 0);
|
|
}
|
|
info->cv8_cur_li->num_linenums = 0;
|
|
STAILQ_INIT(&info->cv8_cur_li->linesets);
|
|
STAILQ_INSERT_TAIL(&info->cv8_lineinfos, info->cv8_cur_li, link);
|
|
info->cv8_cur_ls = NULL;
|
|
}
|
|
|
|
/* build new lineset if necessary */
|
|
if (!info->cv8_cur_ls || info->cv8_cur_ls->num_pairs >= 126) {
|
|
info->cv8_cur_ls = yasm_xmalloc(sizeof(cv8_lineset));
|
|
info->cv8_cur_ls->num_pairs = 0;
|
|
STAILQ_INSERT_TAIL(&info->cv8_cur_li->linesets, info->cv8_cur_ls, link);
|
|
}
|
|
|
|
/* add linepair for this bytecode */
|
|
info->cv8_cur_ls->pairs[info->cv8_cur_ls->num_pairs].offset = bc->offset;
|
|
info->cv8_cur_ls->pairs[info->cv8_cur_ls->num_pairs].line =
|
|
0x80000000 | line;
|
|
info->cv8_cur_ls->num_pairs++;
|
|
info->cv8_cur_li->num_linenums++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cv_generate_line_section(yasm_section *sect, /*@null@*/ void *d)
|
|
{
|
|
cv_line_info *info = (cv_line_info *)d;
|
|
|
|
if (!yasm_section_is_code(sect))
|
|
return 0; /* not code, so no line data for this section */
|
|
|
|
info->cv8_cur_li = NULL;
|
|
info->cv8_cur_ls = NULL;
|
|
|
|
yasm_section_bcs_traverse(sect, info->errwarns, info, cv_generate_line_bc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cv_generate_filename(const char *filename, void *d)
|
|
{
|
|
cv_dbgfmt_add_file((yasm_dbgfmt_cv *)d, 0, filename);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cv_generate_sym(yasm_symrec *sym, void *d)
|
|
{
|
|
cv_line_info *info = (cv_line_info *)d;
|
|
yasm_bytecode *precbc;
|
|
const char *name = yasm_symrec_get_name(sym);
|
|
|
|
/* only care about labels (for now). Don't put in symbols starting with
|
|
* ".", as these are typically internally generated ones (like section
|
|
* symbols).
|
|
*/
|
|
if (name[0] == '.' || !yasm_symrec_get_label(sym, &precbc))
|
|
return 0;
|
|
|
|
/* TODO: add data types; until then, just mark everything as UBYTE */
|
|
if (yasm_section_is_code(yasm_bc_get_section(precbc)))
|
|
cv8_add_sym_label(info->debug_symline, sym);
|
|
else
|
|
cv8_add_sym_data(info->debug_symline, 0x20, sym,
|
|
yasm_symrec_get_visibility(sym) & YASM_SYM_GLOBAL?1:0);
|
|
return 0;
|
|
}
|
|
|
|
yasm_section *
|
|
yasm_cv__generate_symline(yasm_object *object, yasm_linemap *linemap,
|
|
yasm_errwarns *errwarns)
|
|
{
|
|
yasm_dbgfmt_cv *dbgfmt_cv = (yasm_dbgfmt_cv *)object->dbgfmt;
|
|
cv_line_info info;
|
|
int new;
|
|
size_t i;
|
|
cv8_symhead *head;
|
|
cv8_lineinfo *li;
|
|
yasm_bytecode *bc;
|
|
unsigned long off;
|
|
|
|
/* Generate filenames based on linemap */
|
|
yasm_linemap_traverse_filenames(linemap, dbgfmt_cv,
|
|
cv_generate_filename);
|
|
|
|
info.object = object;
|
|
info.dbgfmt_cv = dbgfmt_cv;
|
|
info.linemap = linemap;
|
|
info.errwarns = errwarns;
|
|
info.debug_symline =
|
|
yasm_object_get_general(object, ".debug$S", 1, 0, 0, &new, 0);
|
|
info.num_lineinfos = 0;
|
|
STAILQ_INIT(&info.cv8_lineinfos);
|
|
info.cv8_cur_li = NULL;
|
|
info.cv8_cur_ls = NULL;
|
|
|
|
/* source filenames string table */
|
|
head = cv8_add_symhead(info.debug_symline, CV8_FILE_STRTAB, 1);
|
|
cv_append_str(info.debug_symline, "");
|
|
off = 1;
|
|
for (i=0; i<dbgfmt_cv->filenames_size; i++) {
|
|
if (!dbgfmt_cv->filenames[i].pathname) {
|
|
yasm_error_set(YASM_ERROR_GENERAL,
|
|
N_("codeview file number %d unassigned"), i+1);
|
|
yasm_errwarn_propagate(errwarns, 0);
|
|
continue;
|
|
}
|
|
bc = cv_append_str(info.debug_symline,
|
|
dbgfmt_cv->filenames[i].pathname);
|
|
dbgfmt_cv->filenames[i].str_off = off;
|
|
off += bc->len;
|
|
}
|
|
cv8_set_symhead_end(head, yasm_section_bcs_last(info.debug_symline));
|
|
|
|
/* Align 4 */
|
|
bc = yasm_bc_create_align
|
|
(yasm_expr_create_ident(yasm_expr_int(yasm_intnum_create_uint(4)), 0),
|
|
NULL, NULL, NULL, 0);
|
|
yasm_bc_finalize(bc, yasm_cv__append_bc(info.debug_symline, bc));
|
|
yasm_bc_calc_len(bc, NULL, NULL);
|
|
|
|
/* source file info table */
|
|
head = cv8_add_symhead(info.debug_symline, CV8_FILE_INFO, 0);
|
|
off = 0;
|
|
for (i=0; i<dbgfmt_cv->filenames_size; i++) {
|
|
if (!dbgfmt_cv->filenames[i].pathname)
|
|
continue;
|
|
bc = cv8_add_fileinfo(info.debug_symline, &dbgfmt_cv->filenames[i]);
|
|
dbgfmt_cv->filenames[i].info_off = off;
|
|
off += bc->len;
|
|
}
|
|
cv8_set_symhead_end(head, yasm_section_bcs_last(info.debug_symline));
|
|
|
|
/* Already aligned 4 */
|
|
|
|
/* Generate line numbers for sections */
|
|
yasm_object_sections_traverse(object, (void *)&info,
|
|
cv_generate_line_section);
|
|
|
|
/* Output line numbers for sections */
|
|
head = NULL;
|
|
STAILQ_FOREACH(li, &info.cv8_lineinfos, link) {
|
|
if (li->first_in_sect) {
|
|
if (head)
|
|
cv8_set_symhead_end(head, yasm_section_bcs_last(info.debug_symline));
|
|
head = cv8_add_symhead(info.debug_symline, CV8_LINE_NUMS, 0);
|
|
}
|
|
bc = yasm_bc_create_common(&cv8_lineinfo_bc_callback, li, 0);
|
|
bc->len = (li->first_in_sect ? 24 : 12) + li->num_linenums*8;
|
|
yasm_cv__append_bc(info.debug_symline, bc);
|
|
}
|
|
if (head)
|
|
cv8_set_symhead_end(head, yasm_section_bcs_last(info.debug_symline));
|
|
|
|
/* Already aligned 4 */
|
|
|
|
/* Output debugging symbols */
|
|
head = cv8_add_symhead(info.debug_symline, CV8_DEBUG_SYMS, 0);
|
|
/* add object and compile flag first */
|
|
cv8_add_sym_objname(info.debug_symline,
|
|
yasm__abspath(object->obj_filename));
|
|
if (getenv("YASM_TEST_SUITE"))
|
|
cv8_add_sym_compile(object, info.debug_symline,
|
|
yasm__xstrdup("yasm HEAD"));
|
|
else
|
|
cv8_add_sym_compile(object, info.debug_symline,
|
|
yasm__xstrdup(PACKAGE_STRING));
|
|
/* then iterate through symbol table */
|
|
yasm_symtab_traverse(object->symtab, &info, cv_generate_sym);
|
|
cv8_set_symhead_end(head, yasm_section_bcs_last(info.debug_symline));
|
|
|
|
/* Align 4 at end */
|
|
bc = yasm_bc_create_align
|
|
(yasm_expr_create_ident(yasm_expr_int(yasm_intnum_create_uint(4)), 0),
|
|
NULL, NULL, NULL, 0);
|
|
yasm_bc_finalize(bc, yasm_cv__append_bc(info.debug_symline, bc));
|
|
yasm_bc_calc_len(bc, NULL, NULL);
|
|
|
|
return info.debug_symline;
|
|
}
|
|
|
|
static void
|
|
cv_out_sym(yasm_symrec *sym, unsigned long off, yasm_bytecode *bc,
|
|
unsigned char **bufp, void *d, yasm_output_value_func output_value)
|
|
{
|
|
yasm_value val;
|
|
|
|
/* sym in its section */
|
|
yasm_value_init_sym(&val, sym, 32);
|
|
val.section_rel = 1;
|
|
output_value(&val, *bufp, 4, off, bc, 0, d);
|
|
*bufp += 4;
|
|
|
|
/* section index */
|
|
yasm_value_init_sym(&val, sym, 16);
|
|
val.seg_of = 1;
|
|
output_value(&val, *bufp, 2, off+4, bc, 0, d);
|
|
*bufp += 2;
|
|
}
|
|
|
|
static cv8_symhead *
|
|
cv8_add_symhead(yasm_section *sect, unsigned long type, int first)
|
|
{
|
|
cv8_symhead *head;
|
|
yasm_bytecode *bc;
|
|
|
|
head = yasm_xmalloc(sizeof(cv8_symhead));
|
|
head->type = type;
|
|
head->first = first;
|
|
head->start_prevbc = yasm_section_bcs_last(sect);
|
|
|
|
bc = yasm_bc_create_common(&cv8_symhead_bc_callback, head, 0);
|
|
if (first)
|
|
bc->len = 12;
|
|
else
|
|
bc->len = 8;
|
|
|
|
head->end_prevbc = bc;
|
|
yasm_cv__append_bc(sect, bc);
|
|
return head;
|
|
}
|
|
|
|
static void
|
|
cv8_set_symhead_end(cv8_symhead *head, yasm_bytecode *end_prevbc)
|
|
{
|
|
head->end_prevbc = end_prevbc;
|
|
}
|
|
|
|
static void
|
|
cv8_symhead_bc_destroy(void *contents)
|
|
{
|
|
yasm_xfree(contents);
|
|
}
|
|
|
|
static void
|
|
cv8_symhead_bc_print(const void *contents, FILE *f, int indent_level)
|
|
{
|
|
/* TODO */
|
|
}
|
|
|
|
static int
|
|
cv8_symhead_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
|
|
void *add_span_data)
|
|
{
|
|
yasm_internal_error(N_("tried to calc_len a codeview symhead bytecode"));
|
|
/*@notreached@*/
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cv8_symhead_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp,
|
|
unsigned char *bufstart, void *d,
|
|
yasm_output_value_func output_value,
|
|
yasm_output_reloc_func output_reloc)
|
|
{
|
|
yasm_object *object = yasm_section_get_object(bc->section);
|
|
cv8_symhead *head = (cv8_symhead *)bc->contents;
|
|
unsigned char *buf = *bufp;
|
|
yasm_intnum *intn, *cval;
|
|
|
|
cval = yasm_intnum_create_uint(4);
|
|
/* Output "version" if first */
|
|
if (head->first) {
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
}
|
|
|
|
/* Type contained - 4 bytes */
|
|
yasm_intnum_set_uint(cval, head->type);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
|
|
/* Total length of info (following this field) - 4 bytes */
|
|
yasm_intnum_set_uint(cval, bc->len);
|
|
intn = yasm_calc_bc_dist(head->start_prevbc, head->end_prevbc);
|
|
yasm_intnum_calc(intn, YASM_EXPR_SUB, cval);
|
|
yasm_arch_intnum_tobytes(object->arch, intn, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
yasm_intnum_destroy(intn);
|
|
|
|
*bufp = buf;
|
|
|
|
yasm_intnum_destroy(cval);
|
|
return 0;
|
|
}
|
|
|
|
static yasm_bytecode *
|
|
cv8_add_fileinfo(yasm_section *sect, const cv_filename *fn)
|
|
{
|
|
cv8_fileinfo *fi;
|
|
yasm_bytecode *bc;
|
|
|
|
fi = yasm_xmalloc(sizeof(cv8_fileinfo));
|
|
fi->fn = fn;
|
|
|
|
bc = yasm_bc_create_common(&cv8_fileinfo_bc_callback, fi, 0);
|
|
bc->len = 24;
|
|
|
|
yasm_cv__append_bc(sect, bc);
|
|
return bc;
|
|
}
|
|
|
|
static void
|
|
cv8_fileinfo_bc_destroy(void *contents)
|
|
{
|
|
yasm_xfree(contents);
|
|
}
|
|
|
|
static void
|
|
cv8_fileinfo_bc_print(const void *contents, FILE *f, int indent_level)
|
|
{
|
|
/* TODO */
|
|
}
|
|
|
|
static int
|
|
cv8_fileinfo_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
|
|
void *add_span_data)
|
|
{
|
|
yasm_internal_error(N_("tried to calc_len a codeview fileinfo bytecode"));
|
|
/*@notreached@*/
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cv8_fileinfo_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp,
|
|
unsigned char *bufstart, void *d,
|
|
yasm_output_value_func output_value,
|
|
yasm_output_reloc_func output_reloc)
|
|
{
|
|
yasm_object *object = yasm_section_get_object(bc->section);
|
|
cv8_fileinfo *fi = (cv8_fileinfo *)bc->contents;
|
|
unsigned char *buf = *bufp;
|
|
yasm_intnum *cval;
|
|
int i;
|
|
|
|
/* Offset in filename string table */
|
|
cval = yasm_intnum_create_uint(fi->fn->str_off);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
|
|
/* Checksum type/length */
|
|
yasm_intnum_set_uint(cval, 0x0110);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 2, 16, 0, bc, 0);
|
|
buf += 2;
|
|
|
|
/* Checksum */
|
|
for (i=0; i<16; i++)
|
|
YASM_WRITE_8(buf, fi->fn->digest[i]);
|
|
|
|
/* Pad */
|
|
YASM_WRITE_8(buf, 0);
|
|
YASM_WRITE_8(buf, 0);
|
|
|
|
*bufp = buf;
|
|
|
|
yasm_intnum_destroy(cval);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
cv8_lineinfo_bc_destroy(void *contents)
|
|
{
|
|
cv8_lineinfo *li = (cv8_lineinfo *)contents;
|
|
cv8_lineset *ls1, *ls2;
|
|
|
|
/* delete line sets */
|
|
ls1 = STAILQ_FIRST(&li->linesets);
|
|
while (ls1) {
|
|
ls2 = STAILQ_NEXT(ls1, link);
|
|
yasm_xfree(ls1);
|
|
ls1 = ls2;
|
|
}
|
|
|
|
yasm_xfree(contents);
|
|
}
|
|
|
|
static void
|
|
cv8_lineinfo_bc_print(const void *contents, FILE *f, int indent_level)
|
|
{
|
|
/* TODO */
|
|
}
|
|
|
|
static int
|
|
cv8_lineinfo_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
|
|
void *add_span_data)
|
|
{
|
|
yasm_internal_error(N_("tried to calc_len a codeview linehead bytecode"));
|
|
/*@notreached@*/
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cv8_lineinfo_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp,
|
|
unsigned char *bufstart, void *d,
|
|
yasm_output_value_func output_value,
|
|
yasm_output_reloc_func output_reloc)
|
|
{
|
|
yasm_object *object = yasm_section_get_object(bc->section);
|
|
cv8_lineinfo *li = (cv8_lineinfo *)bc->contents;
|
|
unsigned char *buf = *bufp;
|
|
yasm_intnum *cval;
|
|
unsigned long i;
|
|
cv8_lineset *ls;
|
|
|
|
if (li->first_in_sect) {
|
|
/* start offset and section */
|
|
cv_out_sym(li->sectsym, (unsigned long)(buf - bufstart), bc, &buf,
|
|
d, output_value);
|
|
|
|
/* Two bytes of pad/alignment */
|
|
YASM_WRITE_8(buf, 0);
|
|
YASM_WRITE_8(buf, 0);
|
|
|
|
/* Section length covered by line number info */
|
|
cval = yasm_calc_bc_dist(yasm_section_bcs_first(li->sect),
|
|
yasm_section_bcs_last(li->sect));
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
yasm_intnum_destroy(cval);
|
|
buf += 4;
|
|
}
|
|
|
|
/* Offset of source file in info table */
|
|
cval = yasm_intnum_create_uint(li->fn->info_off);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
|
|
/* Number of line number pairs */
|
|
yasm_intnum_set_uint(cval, li->num_linenums);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
|
|
/* Number of bytes of line number pairs + 12 (no, I don't know why) */
|
|
yasm_intnum_set_uint(cval, li->num_linenums*8+12);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
|
|
/* Offset / line number pairs */
|
|
i = 0;
|
|
STAILQ_FOREACH(ls, &li->linesets, link) {
|
|
unsigned long j;
|
|
for (j=0; i<li->num_linenums && j<126; i++, j++) {
|
|
/* offset in section */
|
|
yasm_intnum_set_uint(cval, ls->pairs[j].offset);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
|
|
/* line number in file */
|
|
yasm_intnum_set_uint(cval, ls->pairs[j].line);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0, bc, 0);
|
|
buf += 4;
|
|
}
|
|
}
|
|
|
|
*bufp = buf;
|
|
|
|
yasm_intnum_destroy(cval);
|
|
return 0;
|
|
}
|
|
|
|
static unsigned long
|
|
cv_sym_size(const cv_sym *cvs)
|
|
{
|
|
const char *ch = cvs->format;
|
|
unsigned long len = 4; /* sym length and type */
|
|
unsigned long slen;
|
|
int arg = 0;
|
|
|
|
while (*ch) {
|
|
switch (*ch) {
|
|
case 'b':
|
|
len++;
|
|
arg++;
|
|
break;
|
|
case 'h':
|
|
len += 2;
|
|
arg++;
|
|
break;
|
|
case 'w':
|
|
len += 4;
|
|
arg++;
|
|
break;
|
|
case 'Y':
|
|
len += 6; /* XXX: will be 4 in 16-bit version */
|
|
arg++;
|
|
break;
|
|
case 'T':
|
|
len += 4; /* XXX: will be 2 in CV4 */
|
|
arg++;
|
|
break;
|
|
case 'S':
|
|
len += 1; /* XXX: is this 1 or 2? */
|
|
slen = (unsigned long)strlen((const char *)cvs->args[arg++].p);
|
|
len += slen <= 0xff ? slen : 0xff;
|
|
break;
|
|
case 'Z':
|
|
len +=
|
|
(unsigned long)strlen((const char *)cvs->args[arg++].p) + 1;
|
|
break;
|
|
default:
|
|
yasm_internal_error(N_("unknown sym format character"));
|
|
}
|
|
ch++;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
static void
|
|
cv_sym_bc_destroy(void *contents)
|
|
{
|
|
cv_sym *cvs = (cv_sym *)contents;
|
|
const char *ch = cvs->format;
|
|
int arg = 0;
|
|
|
|
while (*ch) {
|
|
switch (*ch) {
|
|
case 'b':
|
|
case 'h':
|
|
case 'w':
|
|
case 'Y':
|
|
case 'T':
|
|
arg++;
|
|
break; /* nothing to destroy */
|
|
case 'S':
|
|
case 'Z':
|
|
yasm_xfree(cvs->args[arg++].p);
|
|
break;
|
|
default:
|
|
yasm_internal_error(N_("unknown sym format character"));
|
|
}
|
|
ch++;
|
|
}
|
|
|
|
yasm_xfree(contents);
|
|
}
|
|
|
|
static void
|
|
cv_sym_bc_print(const void *contents, FILE *f, int indent_level)
|
|
{
|
|
/* TODO */
|
|
}
|
|
|
|
static int
|
|
cv_sym_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
|
|
void *add_span_data)
|
|
{
|
|
yasm_internal_error(N_("tried to calc_len a codeview sym bytecode"));
|
|
/*@notreached@*/
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cv_sym_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp,
|
|
unsigned char *bufstart, void *d,
|
|
yasm_output_value_func output_value,
|
|
yasm_output_reloc_func output_reloc)
|
|
{
|
|
yasm_object *object = yasm_section_get_object(bc->section);
|
|
cv_sym *cvs = (cv_sym *)bc->contents;
|
|
unsigned char *buf = *bufp;
|
|
yasm_intnum *cval;
|
|
const char *ch = cvs->format;
|
|
size_t len;
|
|
int arg = 0;
|
|
|
|
/* Total length of record (following this field) - 2 bytes */
|
|
cval = yasm_intnum_create_uint(bc->len-2);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 2, 16, 0, bc, 1);
|
|
buf += 2;
|
|
|
|
/* Type contained - 2 bytes */
|
|
yasm_intnum_set_uint(cval, cvs->type);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 2, 16, 0, bc, 0);
|
|
buf += 2;
|
|
|
|
while (*ch) {
|
|
switch (*ch) {
|
|
case 'b':
|
|
YASM_WRITE_8(buf, cvs->args[arg].i);
|
|
arg++;
|
|
break;
|
|
case 'h':
|
|
yasm_intnum_set_uint(cval, cvs->args[arg++].i);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 2, 16, 0,
|
|
bc, 0);
|
|
buf += 2;
|
|
break;
|
|
case 'w':
|
|
yasm_intnum_set_uint(cval, cvs->args[arg++].i);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0,
|
|
bc, 0);
|
|
buf += 4;
|
|
break;
|
|
case 'Y':
|
|
cv_out_sym((yasm_symrec *)cvs->args[arg++].p,
|
|
(unsigned long)(buf-bufstart), bc, &buf, d,
|
|
output_value);
|
|
break;
|
|
case 'T':
|
|
yasm_intnum_set_uint(cval, cvs->args[arg++].i);
|
|
yasm_arch_intnum_tobytes(object->arch, cval, buf, 4, 32, 0,
|
|
bc, 0);
|
|
buf += 4; /* XXX: will be 2 in CV4 */
|
|
break;
|
|
case 'S':
|
|
len = strlen((char *)cvs->args[arg].p);
|
|
len = len <= 0xff ? len : 0xff;
|
|
YASM_WRITE_8(buf, len);
|
|
memcpy(buf, (char *)cvs->args[arg].p, len);
|
|
buf += len;
|
|
arg++;
|
|
break;
|
|
case 'Z':
|
|
len = strlen((char *)cvs->args[arg].p)+1;
|
|
memcpy(buf, (char *)cvs->args[arg].p, len);
|
|
buf += len;
|
|
arg++;
|
|
break;
|
|
default:
|
|
yasm_internal_error(N_("unknown leaf format character"));
|
|
}
|
|
ch++;
|
|
}
|
|
|
|
*bufp = buf;
|
|
|
|
yasm_intnum_destroy(cval);
|
|
return 0;
|
|
}
|