void
dump_control(const LaneControl_t *c)
{
dump_printf(EL_DEBUG, "\tMarker:\t0x%4.4hx\n\tProtocol:\t0x%2.2x\n\tVersion:\t0x%2.2x",
ntohs(c->marker), c->protocol, c->version);
dump_printf(EL_CONT, "\tOpcode:\t\t%s\n\tStatus:\t\t%s\n\tTransactionID:\t0x%8.8x\n\t"
"LECID:\t\t0x%4.4hx\n\tFlags:\t\t0x%4.4hx\n",
dump_opcode_text(ntohs(c->opcode)),
dump_status_text(ntohs(c->status)),
ntohl(c->transaction_id), ntohs(c->lecid), ntohs(c->flags));
switch(ntohs(c->opcode)) {
case LE_CONFIGURE_REQUEST:
case LE_CONFIGURE_RESPONSE:
case LE_JOIN_REQUEST:
case LE_JOIN_RESPONSE:
dump_printf(EL_CONT,"\tSource LAN:\t");
dump_addr(&c->source);
dump_printf(EL_CONT,"\n\tSource ATM:\t");
dump_atmtext(c->source_addr);
dump_printf(EL_CONT,"\n\tLan type:\t%s\n",dump_lantype(c->lan_type));
dump_printf(EL_CONT,"\tMax frame:\t%s\n",dump_maxframe(c->max_frame));
dump_printf(EL_CONT,"\tELAN name size:\t%d\n",c->elan_name_size);
if (c->elan_name_size>0) {
dump_printf(EL_CONT,"\nELAN name:\t%s\n",c->elan_name);
}
break;
case LE_ARP_REQUEST:
case LE_ARP_RESPONSE:
dump_printf(EL_CONT,"\tSource LAN:\t");
dump_addr(&c->source);
dump_printf(EL_CONT,"\n\tTarget LAN:\t");
dump_addr(&c->target);
dump_printf(EL_CONT,"\n\tSource ATM:\t");
dump_atmtext(c->source_addr);
dump_printf(EL_CONT,"\n\tTarget ATM:\t");
dump_atmtext(c->target_addr);
dump_printf(EL_CONT,"\n");
break;
case LE_FLUSH_REQUEST:
case LE_FLUSH_RESPONSE:
dump_printf(EL_CONT,"\tSource ATM:\t");
dump_atmtext(c->source_addr);
dump_printf(EL_CONT,"\n\tTarget ATM:\t");
dump_atmtext(c->target_addr);
dump_printf(EL_CONT,"\n");
break;
case LE_REGISTER_REQUEST:
case LE_REGISTER_RESPONSE:
case LE_UNREGISTER_REQUEST:
case LE_UNREGISTER_RESPONSE:
dump_printf(EL_CONT,"\tSource LAN:\t");
dump_addr(&c->source);
dump_printf(EL_CONT,"\n\tSource ATM:\t");
dump_atmtext(c->source_addr);
dump_printf(EL_CONT,"\n");
break;
}
}
void dump_asm(
std::ostream& out,
sasm::disas::disas* disas,
const sasm::elf::elf& e,
const std::string& section_name
)
{
auto sect = e.sections[section_name];
out << std::endl << "Section " << sect.name << ":" << std::endl;
disas->set_addr(sect.vaddr);
while (disas->get_addr() < sect.vaddr + sect.size)
{
dump_addr(out, disas, e);
auto ins = disas->next_instr();
ins->dump_asm(out);
out << std::endl;
delete ins;
}
}
static int internal_dump_operand(struct STREAM *stream, struct INSTRUCTION *instr, int op_index)
{
struct OPERAND *op;
if (op_index > 3 || op_index < 0)
return -1;
op = instr ->ops + op_index;
if (op ->flags & OPERAND_FLAG_PRESENT)
{
switch (op ->flags & OPERAND_TYPE_MASK)
{
case OPERAND_TYPE_REG:
dump_reg(stream, op ->value.reg.type, op ->value.reg.code, op ->size);
break;
case OPERAND_TYPE_MEM:
dump_addr(stream, instr, op);
break;
case OPERAND_TYPE_IMM:
dump_imm(stream, op);
break;
case OPERAND_TYPE_DIR:
dump_dir(stream, op);
break;
default:
safe_unistrncpy(stream, _UT("internal error"));
break;
}
}
return stream ->reallen;
}
static void* reconn_fun(void* arg){
conn_t* conn;
queue_t* q = &g_ctx.reconn_q;
rval_t rval;
int times = 1;
while(1){
conn = list_entry(deque(q), conn_t, reconn_link);
assert(conn->conn_state == CONNECTING);
assert(conn->conn_type == ACTIVE);
debug_info("start reconn conn[%d], fd[%d],%s \n",
conn->id, conn->sockfd, dump_addr(conn->addr));
rval = re_connect(conn);
if(success(rval)){
debug_info("reconn conn[%d], fd[%d] success! \n", conn->id, conn->sockfd);
set_conn_state(conn, CONNECTED);
add_event(conn);
}else{
debug_warn("reconn conn[%d], fd[%d] failed! errno[%d]\n",
conn->id, conn->sockfd, rval.err);
enque(q, &conn->reconn_link); //continue reconn
}
sleep(times);
}
}
int find_node_from_addr1(struct sockaddr_in addr){
int i;
for(i=0; i<MAX_NODE; i++){
if(cmp_ip(g_ctx.conf.node[i].addr ,addr))
return i;
}
debug_err("can't find this server! server_addr:%s\n", dump_addr(addr) );
return -1;
}
bool kXAudioEngine::init(kx_hw *hw_)
{
bool result = false;
dump_addr();
debug("kXAudioEngine[%p]::init\n", this);
hw = hw_;
if (!super::init(NULL))
{
goto Done;
}
hw->initialized|=KX_ENGINE_INITED;
result = true;
sampling_rate=48000;
if(hw->is_10k2)
bps=32;
else
bps=16;
n_channels=8; // should be <= MAX_CHANNELS_
n_frames = (int)(hw->mtr_buffer.size * 8 / bps / n_channels);
is_running=0;
bzero(out_streams, sizeof(out_streams));
bzero(in_streams, sizeof(in_streams));
// configure kX to ASIO-style I/O
if(hw)
{
hw->asio_notification_krnl.pb_buf=-1;
hw->asio_notification_krnl.rec_buf=-1;
hw->asio_notification_krnl.toggle=-1;
hw->asio_notification_krnl.asio_method=KXASIO_METHOD_SEND_EVENT; // notify via deferred, but catch up directly in the OSX IRQ handler
hw->asio_notification_krnl.n_voice=-1;
hw->asio_notification_krnl.semi_buff=0;
hw->asio_notification_krnl.active=0;
hw->asio_notification_krnl.cur_pos=0;
hw->asio_notification_krnl.kevent=this;
hw->cur_asio_in_bps=bps;
}
Done:
return result;
}
static void dump_mac(const u8 *r)
{
u8 id;
printf("\nMAC Addresses\n");
printf("---------------\n");
dump_addr(1, r + 0x100);
dump_addr(2, r + 0x108);
dump_addr(3, r + 0x110);
printf("\n");
printf("Connector type 0x%02X (%c)\n",
r[0x118], (char)r[0x118]);
printf("PMD type 0x%02X (%c)\n",
r[0x119], (char)r[0x119]);
printf("PHY type 0x%02X\n", r[0x11d]);
id = r[0x11b];
printf("Chip Id 0x%02X ", id);
switch (id) {
case 0x0a: printf("Genesis"); break;
case 0xb0: printf("Yukon"); break;
case 0xb1: printf("Yukon-Lite"); break;
case 0xb2: printf("Yukon-LP"); break;
case 0xb3: printf("Yukon-2 XL"); break;
case 0xb5: printf("Yukon Extreme"); break;
case 0xb4: printf("Yukon-2 EC Ultra"); break;
case 0xb6: printf("Yukon-2 EC"); break;
case 0xb7: printf("Yukon-2 FE"); break;
case 0xb8: printf("Yukon-2 FE Plus"); break;
case 0xb9: printf("Yukon Supreme"); break;
case 0xba: printf("Yukon Ultra 2"); break;
case 0xbc: printf("Yukon Optima"); break;
default: printf("(Unknown)"); break;
}
printf(" (rev %d)\n", (r[0x11a] & 0xf0) >> 4);
printf("Ram Buffer 0x%02X\n", r[0x11c]);
}
static void ct_dump_tuples(struct nfnl_ct *ct, struct nl_dump_params *p)
{
struct nl_addr *orig_src, *orig_dst, *reply_src, *reply_dst;
int orig_sport = 0, orig_dport = 0, reply_sport = 0, reply_dport = 0;
int sync = 0;
orig_src = nfnl_ct_get_src(ct, 0);
orig_dst = nfnl_ct_get_dst(ct, 0);
reply_src = nfnl_ct_get_src(ct, 1);
reply_dst = nfnl_ct_get_dst(ct, 1);
if (nfnl_ct_test_src_port(ct, 0))
orig_sport = nfnl_ct_get_src_port(ct, 0);
if (nfnl_ct_test_dst_port(ct, 0))
orig_dport = nfnl_ct_get_dst_port(ct, 0);
if (nfnl_ct_test_src_port(ct, 1))
reply_sport = nfnl_ct_get_src_port(ct, 1);
if (nfnl_ct_test_dst_port(ct, 1))
reply_dport = nfnl_ct_get_dst_port(ct, 1);
if (orig_src && orig_dst && reply_src && reply_dst &&
orig_sport == reply_dport && orig_dport == reply_sport &&
!nl_addr_cmp(orig_src, reply_dst) &&
!nl_addr_cmp(orig_dst, reply_src))
sync = 1;
dump_addr(p, orig_src, orig_sport);
nl_dump(p, sync ? "<-> " : "-> ");
dump_addr(p, orig_dst, orig_dport);
dump_icmp(p, ct, 0);
if (!sync) {
dump_addr(p, reply_src, reply_sport);
nl_dump(p, "<- ");
dump_addr(p, reply_dst, reply_dport);
dump_icmp(p, ct, 1);
}
}
static void exp_dump_tuples(struct nfnl_exp *exp, struct nl_dump_params *p)
{
struct nl_addr *tuple_src, *tuple_dst;
int tuple_sport, tuple_dport;
int i = 0;
char buf[64];
for (i = NFNL_EXP_TUPLE_EXPECT; i < NFNL_EXP_TUPLE_MAX; i++) {
tuple_src = NULL;
tuple_dst = NULL;
tuple_sport = 0;
tuple_dport = 0;
// Test needed for NAT case
if (nfnl_exp_test_src(exp, i))
tuple_src = nfnl_exp_get_src(exp, i);
if (nfnl_exp_test_dst(exp, i))
tuple_dst = nfnl_exp_get_dst(exp, i);
// Don't have tests for individual ports/types/codes/ids,
if (nfnl_exp_test_l4protonum(exp, i)) {
nl_dump(p, "%s ",
nl_ip_proto2str(nfnl_exp_get_l4protonum(exp, i), buf, sizeof(buf)));
}
if (nfnl_exp_test_ports(exp, i)) {
tuple_sport = nfnl_exp_get_src_port(exp, i);
tuple_dport = nfnl_exp_get_dst_port(exp, i);
}
dump_addr(p, tuple_src, tuple_sport);
dump_addr(p, tuple_dst, tuple_dport);
dump_icmp(p, exp, 0);
}
if (nfnl_exp_test_nat_dir(exp))
nl_dump(p, "nat dir %s ", exp->exp_nat_dir);
}
unsigned int my_hook(unsigned int hooknum,
struct sk_buff *skb,
const struct net_device *in,
const struct net_device *out,
int (*okfn)(struct sk_buff *))
{
printk("Hello packet! ");
//printk("from %s to %s\n", in->name, out->name);
unsigned char *iphdr = skb_network_header(skb);
if(iphdr){
dump_addr(iphdr);
}
return NF_ACCEPT;
}
IOReturn kXAudioEngine::performAudioEngineStop()
{
dump_addr();
// debug("kXAudioEngine[%p]::performAudioEngineStop() - %d\n", this,is_running);
hw->asio_notification_krnl.active=0;
dword low=0,high=0;
int first=-1;
for(int i=0;i<KX_NUMBER_OF_VOICES;i++)
{
if(hw->voicetable[i].usage&VOICE_USAGE_ASIO && hw->voicetable[i].asio_id==this)
{
if(i>=32)
high|=(1<<(i-32));
else
low|=(1<<i);
if(first==-1)
first=i;
}
}
if(first!=-1)
{
// debug("kXAudioEngine[%p]::performAudioEngineStop: stop audio [%d; %x %x]\n",this,first,(unsigned)low,(unsigned)high);
kx_wave_stop_multiple(hw,first,low,high);
// zero sample position, too
for(int i=0;i<32;i++)
{
if(low&(1<<i))
kx_wave_set_position(hw,i,0);
if(high&(1<<i))
kx_wave_set_position(hw,i+32,0);
}
}
// recording
//debug("performAudioEngineStop FXBS:\n");
//kx_writeptr_prof(hw, FXBS, 0, 0);
kx_writeptr(hw, FXBS, 0, 0);
is_running=0;
return kIOReturnSuccess;
}
void
dump_vars(const Unit_t *unit)
{
const VarList_t *tmp;
LaneDestList_t *ltmp;
Debug_unit(&load_unit, "Dumping variables");
for (tmp = varlist; tmp != NULL; tmp = tmp->next) {
assert(tmp->var != NULL);
assert(tmp->var->unit != NULL);
assert(tmp->var->unit->name != NULL);
assert(tmp->var->name != NULL);
if (unit == NULL || strcmp(unit->name, tmp->var->unit->name) == 0) {
switch (tmp->var->type) {
case VT_INT:
Debug_unit(&load_unit, "%s/%s = %d", tmp->var->unit->name, tmp->var->name, tmp->var->val_u.intval);
break;
case VT_STR:
Debug_unit(&load_unit, "%s/%s = \"%s\"", tmp->var->unit->name, tmp->var->name, tmp->var->val_u.strval);
break;
case VT_BOOL:
Debug_unit(&load_unit, "%s/%s = %s", tmp->var->unit->name, tmp->var->name, tmp->var->val_u.boolval == BL_TRUE? "True" : "False" );
break;
case VT_ADDR:
Debug_unit(&load_unit, "%s/%s =", tmp->var->unit->name, tmp->var->name);
dump_atmaddr(tmp->var->val_u.addrval);
break;
case VT_PVC:
Debug_unit(&load_unit,"%s/%s = %d,%d,%d with lecid:%d ",
tmp->var->unit->name,
tmp->var->name,
tmp->var->val_u.init->pvc->port,
tmp->var->val_u.init->pvc->vpi,
tmp->var->val_u.init->pvc->vci,
tmp->var->val_u.init->lecid);
dump_atmaddr(tmp->var->val_u.init->address);
ltmp = tmp->var->val_u.init->destinations;
while(ltmp) {
dump_printf(EL_CONT,"\t");
dump_addr(ltmp->addr);
dump_printf(EL_CONT,"\n");
ltmp = ltmp->next;
}
break;
}
}
}
}
static int
register_req(Conn_t *conn)
{
Reg_t *tmp;
Lecdb_t *ltmp;
Debug_unit(&conn_unit, "Register_req called");
dump_conn(conn);
assert(control_packet != NULL);
/* If trying to register a multicast or broadcast address, reject */
if (is_multicast(&control_packet->source)) {
send_register_response(conn->sfd, control_packet,
LE_STATUS_BAD_DEST, 1);
return 1;
}
/* Check lecid */
ltmp = leciddb_find(control_packet->lecid);
if (!ltmp) {
send_register_response(conn->sfd, control_packet,
LE_STATUS_BAD_LECID, 1);
return 1;
}
tmp = regdb_find_mac(control_packet->source);
if (tmp == NULL) {
/* Unregistered MAC, registering... */
dump_addr(&control_packet->source);
dump_printf(EL_CONT,"\n");
regdb_add(control_packet->source_addr, control_packet->source);
send_register_response(conn->sfd, control_packet,
LE_STATUS_SUCCESS, 1);
} else {
if (memcmp(&tmp->atm_address,&control_packet->source_addr,
sizeof(AtmAddr_t)) != 0) {
Debug_unit(&conn_unit, "MAC Address is bound to another ATM address");
send_register_response(conn->sfd, control_packet,
LE_STATUS_DUPLICATE_REG, 1);
} else {
Debug_unit(&conn_unit,"Duplicate registeration");
send_register_response(conn->sfd, control_packet,
LE_STATUS_SUCCESS, 1);
}
}
return 1;
}
int
test_parse_ipaddr_invalid_data(void)
{
cmdline_parse_token_ipaddr_t token;
char buf[CMDLINE_TEST_BUFSIZE];
cmdline_ipaddr_t result;
unsigned i;
uint8_t flags;
int ret;
memset(&result, 0, sizeof(result));
/* test invalid strings */
for (i = 0; i < IPADDR_INVALID_STRS_SIZE; i++) {
/* test each valid string against different flags */
for (flags = 1; flags < 0x8; flags++) {
/* skip bad flag */
if (flags == CMDLINE_IPADDR_NETWORK)
continue;
/* clear out everything */
memset(buf, 0, sizeof(buf));
memset(&token, 0, sizeof(token));
token.ipaddr_data.flags = flags;
cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
buf, sizeof(buf));
ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
ipaddr_invalid_strs[i], (void*)&result);
if (ret != -1) {
printf("Error: parsing %s as %s succeeded!\n",
ipaddr_invalid_strs[i], buf);
printf("Parsed result: ");
dump_addr(result);
return -1;
}
}
}
return 0;
}
static int
arp_find(Conn_t *conn)
{
Reg_t *tmp;
Lecdb_t *ltmp;
Debug_unit(&conn_unit, "Arp_find called");
dump_conn(conn);
Debug_unit(&conn_unit,"Arping for:");
dump_addr(&control_packet->target);
dump_printf(EL_CONT,"\n");
/* If requested multicast /broadcast address, respond with BUS address */
if (is_multicast(&control_packet->target)) {
tmp = mem_alloc(&conn_unit, sizeof(Reg_t));
memcpy(&tmp->atm_address, get_var_addr(&conn_unit, "S6"),
sizeof(AtmAddr_t));
Debug_unit(&conn_unit,"Arp for multicast address");
send_arp_response(conn->sfd, control_packet,
LE_STATUS_SUCCESS, tmp);
return 1;
}
/* Check lecid */
ltmp = leciddb_find(control_packet->lecid);
if (!ltmp) {
send_arp_response(conn->sfd, control_packet,
LE_STATUS_BAD_LECID, NULL);
return 1;
}
tmp = regdb_find_mac(control_packet->target);
if (tmp) {
Debug_unit(&conn_unit,"Address in databases");
/* Send response */
send_arp_response(conn->sfd, control_packet,
LE_STATUS_SUCCESS,
tmp);
return 1;
}
forward_arp_request(control_packet, proxylist);
return 1;
}
IOReturn kXAudioEngine::performFormatChange(IOAudioStream *audioStream, const IOAudioStreamFormat *newFormat, const IOAudioSampleRate *newSampleRate)
{
debug("kXAudioEngine[%p]::peformFormatChange(%p, %p, %p)\n", this, audioStream, newFormat, newSampleRate);
if (newSampleRate)
{
switch (newSampleRate->whole) {
case 48000:
debug("\t-> 48kHz selected\n");
// Add code to switch hardware to 48kHz
break;
default:
// This should not be possible since we only specified 44100 and 48000 as valid sample rates
debug("\t Internal Error - unknown sample rate selected.\n");
break;
}
}
dump_addr();
return kIOReturnSuccess;
}
static void
test(int bind_type)
{
LOGINREC *login;
DBPROCESS *dbproc;
DBNUMERIC *num = NULL, *num2 = NULL;
RETCODE ret;
int i;
sql_rewind();
login = dblogin();
DBSETLUSER(login, USER);
DBSETLPWD(login, PASSWORD);
DBSETLAPP(login, "numeric");
dbsetmaxprocs(25);
DBSETLHOST(login, SERVER);
dbproc = dbopen(login, SERVER);
dbloginfree(login);
login = NULL;
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (DBTDS_5_0 < DBTDS(dbproc)) {
ret = dbcmd(dbproc,
"SET ARITHABORT ON;"
"SET CONCAT_NULL_YIELDS_NULL ON;"
"SET ANSI_NULLS ON;"
"SET ANSI_NULL_DFLT_ON ON;"
"SET ANSI_PADDING ON;"
"SET ANSI_WARNINGS ON;"
"SET ANSI_NULL_DFLT_ON ON;"
"SET CURSOR_CLOSE_ON_COMMIT ON;"
"SET QUOTED_IDENTIFIER ON");
chk(ret, "dbcmd");
ret = dbsqlexec(dbproc);
chk(ret, "dbsqlexec");
ret = dbcancel(dbproc);
chk(ret, "dbcancel");
}
ret = dbrpcinit(dbproc, "testDecimal", 0);
chk(ret, "dbrpcinit");
num = (DBDECIMAL *) calloc(1, sizeof(DBDECIMAL));
num->scale = 5;
num->precision = 16;
dbconvert(dbproc, SYBVARCHAR, (const BYTE *) "123.45", -1, SYBDECIMAL, (BYTE *) num, sizeof(*num));
ret = dbrpcparam(dbproc, "@idecimal", 0, SYBDECIMAL, -1, sizeof(DBDECIMAL), (BYTE *) num);
chk(ret, "dbrpcparam");
ret = dbrpcsend(dbproc);
chk(ret, "dbrpcsend");
ret = dbsqlok(dbproc);
chk(ret, "dbsqlok");
/* TODO check MS/Sybase format */
num2 = (DBDECIMAL *) calloc(1, sizeof(DBDECIMAL));
num2->precision = 20;
num2->scale = 10;
dbconvert(dbproc, SYBVARCHAR, (const BYTE *) "246.9", -1, SYBDECIMAL, (BYTE *) num2, sizeof(*num2));
for (i=0; (ret = dbresults(dbproc)) != NO_MORE_RESULTS; ++i) {
RETCODE row_code;
switch (ret) {
case SUCCEED:
if (DBROWS(dbproc) == FAIL)
continue;
assert(DBROWS(dbproc) == SUCCEED);
printf("dbrows() returned SUCCEED, processing rows\n");
memset(num, 0, sizeof(*num));
num->precision = num2->precision;
num->scale = num2->scale;
dbbind(dbproc, 1, bind_type, 0, (BYTE *) num);
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
if (row_code == REG_ROW) {
if (memcmp(num, num2, sizeof(*num)) != 0) {
fprintf(stderr, "Failed. Output results does not match\n");
dump_addr(stderr, "numeric: ", num, sizeof(*num));
dump_addr(stderr, "numeric2:", num2, sizeof(*num2));
exit(1);
}
} else {
/* not supporting computed rows in this unit test */
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
}
break;
case FAIL:
fprintf(stderr, "dbresults returned FAIL\n");
exit(1);
default:
fprintf(stderr, "unexpected return code %d from dbresults\n", ret);
exit(1);
}
} /* while dbresults */
sql_cmd(dbproc);
free(num2);
free(num);
dbclose(dbproc);
}
void
dump_symtab_base (FILE *f, symtab_node node)
{
static const char * const visibility_types[] = {
"default", "protected", "hidden", "internal"
};
fprintf (f, "%s/%i (%s)",
symtab_node_asm_name (node),
node->symbol.order,
symtab_node_name (node));
dump_addr (f, " @", (void *)node);
fprintf (f, "\n Type: %s\n", symtab_type_names[node->symbol.type]);
fprintf (f, " Visibility:");
if (node->symbol.in_other_partition)
fprintf (f, " in_other_partition");
if (node->symbol.used_from_other_partition)
fprintf (f, " used_from_other_partition");
if (node->symbol.force_output)
fprintf (f, " force_output");
if (node->symbol.resolution != LDPR_UNKNOWN)
fprintf (f, " %s",
ld_plugin_symbol_resolution_names[(int)node->symbol.resolution]);
if (TREE_ASM_WRITTEN (node->symbol.decl))
fprintf (f, " asm_written");
if (DECL_EXTERNAL (node->symbol.decl))
fprintf (f, " external");
if (TREE_PUBLIC (node->symbol.decl))
fprintf (f, " public");
if (DECL_COMMON (node->symbol.decl))
fprintf (f, " common");
if (DECL_WEAK (node->symbol.decl))
fprintf (f, " weak");
if (DECL_DLLIMPORT_P (node->symbol.decl))
fprintf (f, " dll_import");
if (DECL_COMDAT (node->symbol.decl))
fprintf (f, " comdat");
if (DECL_COMDAT_GROUP (node->symbol.decl))
fprintf (f, " comdat_group:%s",
IDENTIFIER_POINTER (DECL_COMDAT_GROUP (node->symbol.decl)));
if (DECL_ONE_ONLY (node->symbol.decl))
fprintf (f, " one_only");
if (DECL_SECTION_NAME (node->symbol.decl))
fprintf (f, " section_name:%s",
TREE_STRING_POINTER (DECL_SECTION_NAME (node->symbol.decl)));
if (DECL_VISIBILITY_SPECIFIED (node->symbol.decl))
fprintf (f, " visibility_specified");
if (DECL_VISIBILITY (node->symbol.decl))
fprintf (f, " visibility:%s",
visibility_types [DECL_VISIBILITY (node->symbol.decl)]);
if (DECL_VIRTUAL_P (node->symbol.decl))
fprintf (f, " virtual");
if (DECL_ARTIFICIAL (node->symbol.decl))
fprintf (f, " artificial");
if (TREE_CODE (node->symbol.decl) == FUNCTION_DECL)
{
if (DECL_STATIC_CONSTRUCTOR (node->symbol.decl))
fprintf (f, " constructor");
if (DECL_STATIC_DESTRUCTOR (node->symbol.decl))
fprintf (f, " destructor");
}
fprintf (f, "\n");
if (node->symbol.same_comdat_group)
fprintf (f, " Same comdat group as: %s/%i\n",
symtab_node_asm_name (node->symbol.same_comdat_group),
node->symbol.same_comdat_group->symbol.order);
if (node->symbol.next_sharing_asm_name)
fprintf (f, " next sharing asm name: %i\n",
node->symbol.next_sharing_asm_name->symbol.order);
if (node->symbol.previous_sharing_asm_name)
fprintf (f, " previous sharing asm name: %i\n",
node->symbol.previous_sharing_asm_name->symbol.order);
if (node->symbol.address_taken)
fprintf (f, " Address is taken.\n");
if (node->symbol.aux)
{
fprintf (f, " Aux:");
dump_addr (f, " @", (void *)node->symbol.aux);
}
fprintf (f, " References: ");
ipa_dump_references (f, &node->symbol.ref_list);
fprintf (f, " Referring: ");
ipa_dump_referring (f, &node->symbol.ref_list);
}
static void
print_rtx (const_rtx in_rtx)
{
int i = 0;
int j;
const char *format_ptr;
int is_insn;
if (sawclose)
{
if (flag_simple)
fputc (' ', outfile);
else
fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
sawclose = 0;
}
if (in_rtx == 0)
{
fputs ("(nil)", outfile);
sawclose = 1;
return;
}
else if (GET_CODE (in_rtx) > NUM_RTX_CODE)
{
fprintf (outfile, "(??? bad code %d\n%s%*s)", GET_CODE (in_rtx),
print_rtx_head, indent * 2, "");
sawclose = 1;
return;
}
is_insn = INSN_P (in_rtx);
/* Print name of expression code. */
if (flag_simple && CONST_INT_P (in_rtx))
fputc ('(', outfile);
else
fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));
if (! flag_simple)
{
if (RTX_FLAG (in_rtx, in_struct))
fputs ("/s", outfile);
if (RTX_FLAG (in_rtx, volatil))
fputs ("/v", outfile);
if (RTX_FLAG (in_rtx, unchanging))
fputs ("/u", outfile);
if (RTX_FLAG (in_rtx, frame_related))
fputs ("/f", outfile);
if (RTX_FLAG (in_rtx, jump))
fputs ("/j", outfile);
if (RTX_FLAG (in_rtx, call))
fputs ("/c", outfile);
if (RTX_FLAG (in_rtx, return_val))
fputs ("/i", outfile);
/* Print REG_NOTE names for EXPR_LIST and INSN_LIST. */
if ((GET_CODE (in_rtx) == EXPR_LIST
|| GET_CODE (in_rtx) == INSN_LIST
|| GET_CODE (in_rtx) == INT_LIST)
&& (int)GET_MODE (in_rtx) < REG_NOTE_MAX)
fprintf (outfile, ":%s",
GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
/* For other rtl, print the mode if it's not VOID. */
else if (GET_MODE (in_rtx) != VOIDmode)
fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
#ifndef GENERATOR_FILE
if (GET_CODE (in_rtx) == VAR_LOCATION)
{
if (TREE_CODE (PAT_VAR_LOCATION_DECL (in_rtx)) == STRING_CST)
fputs (" <debug string placeholder>", outfile);
else
print_mem_expr (outfile, PAT_VAR_LOCATION_DECL (in_rtx));
fputc (' ', outfile);
print_rtx (PAT_VAR_LOCATION_LOC (in_rtx));
if (PAT_VAR_LOCATION_STATUS (in_rtx)
== VAR_INIT_STATUS_UNINITIALIZED)
fprintf (outfile, " [uninit]");
sawclose = 1;
i = GET_RTX_LENGTH (VAR_LOCATION);
}
#endif
}
#ifndef GENERATOR_FILE
if (CONST_DOUBLE_AS_FLOAT_P (in_rtx))
i = 5;
#endif
/* Get the format string and skip the first elements if we have handled
them already. */
format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)) + i;
for (; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
switch (*format_ptr++)
{
const char *str;
case 'T':
str = XTMPL (in_rtx, i);
goto string;
case 'S':
case 's':
str = XSTR (in_rtx, i);
string:
if (str == 0)
fputs (" \"\"", outfile);
else
fprintf (outfile, " (\"%s\")", str);
sawclose = 1;
break;
/* 0 indicates a field for internal use that should not be printed.
An exception is the third field of a NOTE, where it indicates
that the field has several different valid contents. */
case '0':
if (i == 1 && REG_P (in_rtx))
{
if (REGNO (in_rtx) != ORIGINAL_REGNO (in_rtx))
fprintf (outfile, " [%d]", ORIGINAL_REGNO (in_rtx));
}
#ifndef GENERATOR_FILE
else if (i == 1 && GET_CODE (in_rtx) == SYMBOL_REF)
{
int flags = SYMBOL_REF_FLAGS (in_rtx);
if (flags)
fprintf (outfile, " [flags %#x]", flags);
}
else if (i == 2 && GET_CODE (in_rtx) == SYMBOL_REF)
{
tree decl = SYMBOL_REF_DECL (in_rtx);
if (decl)
print_node_brief (outfile, "", decl, dump_flags);
}
#endif
else if (i == 4 && NOTE_P (in_rtx))
{
switch (NOTE_KIND (in_rtx))
{
case NOTE_INSN_EH_REGION_BEG:
case NOTE_INSN_EH_REGION_END:
if (flag_dump_unnumbered)
fprintf (outfile, " #");
else
fprintf (outfile, " %d", NOTE_EH_HANDLER (in_rtx));
sawclose = 1;
break;
case NOTE_INSN_BLOCK_BEG:
case NOTE_INSN_BLOCK_END:
#ifndef GENERATOR_FILE
dump_addr (outfile, " ", NOTE_BLOCK (in_rtx));
#endif
sawclose = 1;
break;
case NOTE_INSN_BASIC_BLOCK:
{
#ifndef GENERATOR_FILE
basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
if (bb != 0)
fprintf (outfile, " [bb %d]", bb->index);
#endif
break;
}
case NOTE_INSN_DELETED_LABEL:
case NOTE_INSN_DELETED_DEBUG_LABEL:
{
const char *label = NOTE_DELETED_LABEL_NAME (in_rtx);
if (label)
fprintf (outfile, " (\"%s\")", label);
else
fprintf (outfile, " \"\"");
}
break;
case NOTE_INSN_SWITCH_TEXT_SECTIONS:
{
#ifndef GENERATOR_FILE
basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
if (bb != 0)
fprintf (outfile, " [bb %d]", bb->index);
#endif
break;
}
case NOTE_INSN_VAR_LOCATION:
case NOTE_INSN_CALL_ARG_LOCATION:
#ifndef GENERATOR_FILE
fputc (' ', outfile);
print_rtx (NOTE_VAR_LOCATION (in_rtx));
#endif
break;
case NOTE_INSN_CFI:
#ifndef GENERATOR_FILE
fputc ('\n', outfile);
output_cfi_directive (outfile, NOTE_CFI (in_rtx));
fputc ('\t', outfile);
#endif
break;
default:
break;
}
}
else if (i == 8 && JUMP_P (in_rtx) && JUMP_LABEL (in_rtx) != NULL)
{
/* Output the JUMP_LABEL reference. */
fprintf (outfile, "\n%s%*s -> ", print_rtx_head, indent * 2, "");
if (GET_CODE (JUMP_LABEL (in_rtx)) == RETURN)
fprintf (outfile, "return");
else if (GET_CODE (JUMP_LABEL (in_rtx)) == SIMPLE_RETURN)
fprintf (outfile, "simple_return");
else
fprintf (outfile, "%d", INSN_UID (JUMP_LABEL (in_rtx)));
}
else if (i == 0 && GET_CODE (in_rtx) == VALUE)
{
#ifndef GENERATOR_FILE
cselib_val *val = CSELIB_VAL_PTR (in_rtx);
fprintf (outfile, " %u:%u", val->uid, val->hash);
dump_addr (outfile, " @", in_rtx);
dump_addr (outfile, "/", (void*)val);
#endif
}
else if (i == 0 && GET_CODE (in_rtx) == DEBUG_EXPR)
{
#ifndef GENERATOR_FILE
fprintf (outfile, " D#%i",
DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (in_rtx)));
#endif
}
else if (i == 0 && GET_CODE (in_rtx) == ENTRY_VALUE)
{
indent += 2;
if (!sawclose)
fprintf (outfile, " ");
print_rtx (ENTRY_VALUE_EXP (in_rtx));
indent -= 2;
}
break;
case 'e':
do_e:
indent += 2;
if (i == 7 && INSN_P (in_rtx))
/* Put REG_NOTES on their own line. */
fprintf (outfile, "\n%s%*s",
print_rtx_head, indent * 2, "");
if (!sawclose)
fprintf (outfile, " ");
print_rtx (XEXP (in_rtx, i));
indent -= 2;
break;
case 'E':
case 'V':
indent += 2;
if (sawclose)
{
fprintf (outfile, "\n%s%*s",
print_rtx_head, indent * 2, "");
sawclose = 0;
}
fputs (" [", outfile);
if (NULL != XVEC (in_rtx, i))
{
indent += 2;
if (XVECLEN (in_rtx, i))
sawclose = 1;
for (j = 0; j < XVECLEN (in_rtx, i); j++)
print_rtx (XVECEXP (in_rtx, i, j));
indent -= 2;
}
if (sawclose)
fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
fputs ("]", outfile);
sawclose = 1;
indent -= 2;
break;
case 'w':
if (! flag_simple)
fprintf (outfile, " ");
fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
if (! flag_simple)
fprintf (outfile, " [" HOST_WIDE_INT_PRINT_HEX "]",
(unsigned HOST_WIDE_INT) XWINT (in_rtx, i));
break;
case 'i':
if (i == 5 && INSN_P (in_rtx))
{
#ifndef GENERATOR_FILE
/* Pretty-print insn locations. Ignore scoping as it is mostly
redundant with line number information and do not print anything
when there is no location information available. */
if (INSN_LOCATION (in_rtx) && insn_file (in_rtx))
fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx));
#endif
}
else if (i == 6 && GET_CODE (in_rtx) == ASM_OPERANDS)
{
#ifndef GENERATOR_FILE
fprintf (outfile, " %s:%i",
LOCATION_FILE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx)),
LOCATION_LINE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx)));
#endif
}
else if (i == 1 && GET_CODE (in_rtx) == ASM_INPUT)
{
#ifndef GENERATOR_FILE
fprintf (outfile, " %s:%i",
LOCATION_FILE (ASM_INPUT_SOURCE_LOCATION (in_rtx)),
LOCATION_LINE (ASM_INPUT_SOURCE_LOCATION (in_rtx)));
#endif
}
else if (i == 6 && NOTE_P (in_rtx))
{
/* This field is only used for NOTE_INSN_DELETED_LABEL, and
other times often contains garbage from INSN->NOTE death. */
if (NOTE_KIND (in_rtx) == NOTE_INSN_DELETED_LABEL
|| NOTE_KIND (in_rtx) == NOTE_INSN_DELETED_DEBUG_LABEL)
fprintf (outfile, " %d", XINT (in_rtx, i));
}
#if !defined(GENERATOR_FILE) && NUM_UNSPECV_VALUES > 0
else if (i == 1
&& GET_CODE (in_rtx) == UNSPEC_VOLATILE
&& XINT (in_rtx, 1) >= 0
&& XINT (in_rtx, 1) < NUM_UNSPECV_VALUES)
fprintf (outfile, " %s", unspecv_strings[XINT (in_rtx, 1)]);
#endif
#if !defined(GENERATOR_FILE) && NUM_UNSPEC_VALUES > 0
else if (i == 1
&& (GET_CODE (in_rtx) == UNSPEC
|| GET_CODE (in_rtx) == UNSPEC_VOLATILE)
&& XINT (in_rtx, 1) >= 0
&& XINT (in_rtx, 1) < NUM_UNSPEC_VALUES)
fprintf (outfile, " %s", unspec_strings[XINT (in_rtx, 1)]);
#endif
else
{
int value = XINT (in_rtx, i);
const char *name;
#ifndef GENERATOR_FILE
if (REG_P (in_rtx) && (unsigned) value < FIRST_PSEUDO_REGISTER)
fprintf (outfile, " %d %s", value, reg_names[value]);
else if (REG_P (in_rtx)
&& (unsigned) value <= LAST_VIRTUAL_REGISTER)
{
if (value == VIRTUAL_INCOMING_ARGS_REGNUM)
fprintf (outfile, " %d virtual-incoming-args", value);
else if (value == VIRTUAL_STACK_VARS_REGNUM)
fprintf (outfile, " %d virtual-stack-vars", value);
else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM)
fprintf (outfile, " %d virtual-stack-dynamic", value);
else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM)
fprintf (outfile, " %d virtual-outgoing-args", value);
else if (value == VIRTUAL_CFA_REGNUM)
fprintf (outfile, " %d virtual-cfa", value);
else if (value == VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM)
fprintf (outfile, " %d virtual-preferred-stack-boundary",
value);
else
fprintf (outfile, " %d virtual-reg-%d", value,
value-FIRST_VIRTUAL_REGISTER);
}
else
#endif
if (flag_dump_unnumbered
&& (is_insn || NOTE_P (in_rtx)))
fputc ('#', outfile);
else
fprintf (outfile, " %d", value);
#ifndef GENERATOR_FILE
if (REG_P (in_rtx) && REG_ATTRS (in_rtx))
{
fputs (" [", outfile);
if (ORIGINAL_REGNO (in_rtx) != REGNO (in_rtx))
fprintf (outfile, "orig:%i", ORIGINAL_REGNO (in_rtx));
if (REG_EXPR (in_rtx))
print_mem_expr (outfile, REG_EXPR (in_rtx));
if (REG_OFFSET (in_rtx))
fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
REG_OFFSET (in_rtx));
fputs (" ]", outfile);
}
#endif
if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
&& XINT (in_rtx, i) >= 0
&& (name = get_insn_name (XINT (in_rtx, i))) != NULL)
fprintf (outfile, " {%s}", name);
sawclose = 0;
}
break;
/* Print NOTE_INSN names rather than integer codes. */
case 'n':
fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i)));
sawclose = 0;
break;
case 'u':
if (XEXP (in_rtx, i) != NULL)
{
rtx sub = XEXP (in_rtx, i);
enum rtx_code subc = GET_CODE (sub);
if (GET_CODE (in_rtx) == LABEL_REF)
{
if (subc == NOTE
&& NOTE_KIND (sub) == NOTE_INSN_DELETED_LABEL)
{
if (flag_dump_unnumbered)
fprintf (outfile, " [# deleted]");
else
fprintf (outfile, " [%d deleted]", INSN_UID (sub));
sawclose = 0;
break;
}
if (subc != CODE_LABEL)
goto do_e;
}
if (flag_dump_unnumbered
|| (flag_dump_unnumbered_links && (i == 1 || i == 2)
&& (INSN_P (in_rtx) || NOTE_P (in_rtx)
|| LABEL_P (in_rtx) || BARRIER_P (in_rtx))))
fputs (" #", outfile);
else
fprintf (outfile, " %d", INSN_UID (sub));
}
else
fputs (" 0", outfile);
sawclose = 0;
break;
case 't':
#ifndef GENERATOR_FILE
if (i == 0 && GET_CODE (in_rtx) == DEBUG_IMPLICIT_PTR)
print_mem_expr (outfile, DEBUG_IMPLICIT_PTR_DECL (in_rtx));
else if (i == 0 && GET_CODE (in_rtx) == DEBUG_PARAMETER_REF)
print_mem_expr (outfile, DEBUG_PARAMETER_REF_DECL (in_rtx));
else
dump_addr (outfile, " ", XTREE (in_rtx, i));
#endif
break;
case '*':
fputs (" Unknown", outfile);
sawclose = 0;
break;
case 'B':
#ifndef GENERATOR_FILE
if (XBBDEF (in_rtx, i))
fprintf (outfile, " %i", XBBDEF (in_rtx, i)->index);
#endif
break;
default:
gcc_unreachable ();
}
switch (GET_CODE (in_rtx))
{
#ifndef GENERATOR_FILE
case MEM:
if (__builtin_expect (final_insns_dump_p, false))
fprintf (outfile, " [");
else
fprintf (outfile, " [" HOST_WIDE_INT_PRINT_DEC,
(HOST_WIDE_INT) MEM_ALIAS_SET (in_rtx));
if (MEM_EXPR (in_rtx))
print_mem_expr (outfile, MEM_EXPR (in_rtx));
if (MEM_OFFSET_KNOWN_P (in_rtx))
fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC, MEM_OFFSET (in_rtx));
if (MEM_SIZE_KNOWN_P (in_rtx))
fprintf (outfile, " S" HOST_WIDE_INT_PRINT_DEC, MEM_SIZE (in_rtx));
if (MEM_ALIGN (in_rtx) != 1)
fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));
if (!ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (in_rtx)))
fprintf (outfile, " AS%u", MEM_ADDR_SPACE (in_rtx));
fputc (']', outfile);
break;
case CONST_DOUBLE:
if (FLOAT_MODE_P (GET_MODE (in_rtx)))
{
char s[60];
real_to_decimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
sizeof (s), 0, 1);
fprintf (outfile, " %s", s);
real_to_hexadecimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
sizeof (s), 0, 1);
fprintf (outfile, " [%s]", s);
}
break;
#endif
case CODE_LABEL:
fprintf (outfile, " [%d uses]", LABEL_NUSES (in_rtx));
switch (LABEL_KIND (in_rtx))
{
case LABEL_NORMAL: break;
case LABEL_STATIC_ENTRY: fputs (" [entry]", outfile); break;
case LABEL_GLOBAL_ENTRY: fputs (" [global entry]", outfile); break;
case LABEL_WEAK_ENTRY: fputs (" [weak entry]", outfile); break;
default: gcc_unreachable ();
}
break;
default:
break;
}
fputc (')', outfile);
sawclose = 1;
}
int main(int argc, char *argv[])
{
FILE * fp;
Img40 m;
uint8_t v;
int nw,i,j;
Actx gc;
char buf[100];
fp=fopen("gi","rt");
assert(fp);
img40Init(&m,16,16);
v=byte_read(fp);
assert(0==v);
v=byte_read(fp);
assert(v==0xb7);
for(i=0;i<4;i++)
{
m.cr[i]=byte_read(fp);
}
// bs->idunno=byte_read(fp);
// assert(get_cr(28)==0);//reserved==0
nw=0;
nw=(byte_read(fp)&0x0ff)<<8;
nw|=(byte_read(fp)&0x0ff);
for(i=0;i<nw;i++)
{
uint8_t sa[3],ea[3];
sa[0]=byte_read(fp);
sa[1]=byte_read(fp);
sa[2]=byte_read(fp);
ea[0]=byte_read(fp);
ea[1]=byte_read(fp);
ea[2]=byte_read(fp);
printf("Window %d of %d\n",i,nw-1);
printf("at line: %d\n",line_idx+1);
printf("start: ");
dump_addr(sa);
printf("\n");
printf("end: ");
dump_addr(ea);
printf("\n");
img40SA(&m,sa,ea);
while(!img40Put(&m,byte_read(fp)));
}
v=byte_read(fp);
assert(v==0xe7);
fclose(fp);
sprintf(buf,"cells");
for(i=0;i<m.rows;i++)
{
for(j=0;j<m.cols;j++)
{
char nbf[20];
actxInit(&gc,64,40);
cellDraw(&gc,0,0,0,get_cell(&m,j,i));
if((i==0)&&(j==0))
{
drawOffs(&gc,0,0);
drawStr(&gc,0,0,buf);
}
sprintf(buf,"cell %.2d %.2d",j,i);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
csetDraw(&gc,20,0,0,get_cset(&m,j,i));
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,!((i==0)&&(j==0)));
actxClear(&gc);
}
}
sprintf(buf,"sectorsh(vert repeaters)");
for(i=0;i<(m.rows/4+1);i++)
{
for(j=0;j<m.cols;j++)
{
char nbf[20];
actxInit(&gc,20,48);
sectorDraw(&gc,0,0,0,1,get_hsector(&m,j,i));
if((i==0)&&(j==0))
{
drawOffs(&gc,0,0);
drawStr(&gc,0,0,buf);
}
sprintf(buf,"sector %.2d %.2d",j,i);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
}
}
sprintf(buf,"sectorsv(hrz repeaters)");
for(i=0;i<m.rows;i++)
{
for(j=0;j<(m.cols/4+1);j++)
{
char nbf[20];
actxInit(&gc,20,48);
sectorDraw(&gc,0,0,0,0,get_vsector(&m,j,i));
if((i==0)&&(j==0))
{
drawOffs(&gc,0,0);
drawStr(&gc,0,0,buf);
}
sprintf(buf,"sector %.2d %.2d",j,i);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
}
}
sprintf(buf,"ioh");
for(i=0;i<m.rows;i++)
{
for(j=0;j<2;j++)
{
char nbf[20];
int k;
uint8_t *p=get_ioh(&m,j,i);
for(k=0;k<2;k++)
{
actxInit(&gc,80,14);
ioDraw(&gc,0,0,0,p+k*4,k==1);
if((i==0)&&(j==0)&&(k==0))
{
drawOffs(&gc,0,0);
drawStr(&gc,0,0,buf);
}
sprintf(buf,"ioh_%c %.2d %.2d",(k==0)?'p':'s',j,i);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
}
}
}
sprintf(buf,"iov");
for(i=0;i<2;i++)
{
for(j=0;j<m.cols;j++)
{
char nbf[20];
int k;
uint8_t *p=get_iov(&m,j,i);
for(k=0;k<2;k++)
{
actxInit(&gc,80,14);
ioDraw(&gc,0,0,0,p+k*4,k==1);
if((i==0)&&(j==0)&&(k==0))
{
drawOffs(&gc,0,0);
drawStr(&gc,0,0,buf);
}
sprintf(buf,"iov_%c %.2d %.2d",(k==0)?'p':'s',j,i);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
}
}
}
sprintf(buf,"mem");
for(i=0;i<(m.rows/4);i++)
{
for(j=0;j<(m.cols/4);j++)
{
char nbf[20];
uint8_t *p=get_mem(&m,j,i);
actxInit(&gc,20,8);
memDraw(&gc,0,0,0,p);
if((i==0)&&(j==0))
{
drawOffs(&gc,0,0);
drawStr(&gc,0,0,buf);
}
sprintf(buf,"mem %.2d %.2d",j,i);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
}
}
sprintf(buf,"cols");
for(j=0;j<m.cols;j++)
{
char nbf[20];
uint8_t *p=get_col(&m,j);
actxInit(&gc,20,10);
colDraw(&gc,0,0,0,p,0);
if(j==0)
{
drawOffs(&gc,0,0);
drawStr(&gc,0,0,buf);
}
sprintf(buf,"col %.2d",j);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
if(j==(m.cols-1))
{//fclock
actxInit(&gc,20,10);
colDraw(&gc,0,0,0,p+1,2);
sprintf(buf,"auxcol %.2d (fck)",j);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
// assert((p[1]&0x0fc)==0x0fc);
}
else if(j==0)
{//fclock
actxInit(&gc,20,10);
colDraw(&gc,0,0,0,p+1,1);
sprintf(buf,"auxcol %.2d (fck)",j);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
// assert((p[1]&0x0fc)==0x0fc);
}
else if(j==((m.cols/2)-1))
{//reset input
actxInit(&gc,20,10);
colDraw(&gc,0,0,0,p+1,3);
sprintf(buf,"auxcol %.2d (rst)",j);
drawOffs(&gc,0,0);
drawStr(&gc,0,1,buf);
sprintf(nbf,"c_dmp");
actxDump(&gc,nbf,1);
actxClear(&gc);
// assert((p[1]&0x0f0)==0x0f0);
}
// else
// assert(p[1]==0xff);
}
img40Dump(&m);
img40Clear(&m);
return 0;
}
void
print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
{
enum tree_code_class tclass;
if (node == 0)
return;
tclass = TREE_CODE_CLASS (TREE_CODE (node));
/* Always print the slot this node is in, and its code, address and
name if any. */
if (indent > 0)
fprintf (file, " ");
fprintf (file, "%s <%s", prefix, get_tree_code_name (TREE_CODE (node)));
dump_addr (file, " ", node);
if (tclass == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
else if (TREE_CODE (node) == LABEL_DECL
&& LABEL_DECL_UID (node) != -1)
{
if (dump_flags & TDF_NOUID)
fprintf (file, " L.xxxx");
else
fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
}
else
{
if (dump_flags & TDF_NOUID)
fprintf (file, " %c.xxxx",
TREE_CODE (node) == CONST_DECL ? 'C' : 'D');
else
fprintf (file, " %c.%u",
TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
DECL_UID (node));
}
}
else if (tclass == tcc_type)
{
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
fprintf (file, " %s",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
}
if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
}
if (TREE_CODE (node) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (node));
/* We might as well always print the value of an integer or real. */
if (TREE_CODE (node) == INTEGER_CST)
{
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
fprintf (file, " ");
print_dec (node, file, TYPE_SIGN (TREE_TYPE (node)));
}
if (TREE_CODE (node) == REAL_CST)
{
REAL_VALUE_TYPE d;
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
d = TREE_REAL_CST (node);
if (REAL_VALUE_ISINF (d))
fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
else if (REAL_VALUE_ISNAN (d))
fprintf (file, " Nan");
else
{
char string[60];
real_to_decimal (string, &d, sizeof (string), 0, 1);
fprintf (file, " %s", string);
}
}
if (TREE_CODE (node) == FIXED_CST)
{
FIXED_VALUE_TYPE f;
char string[60];
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
f = TREE_FIXED_CST (node);
fixed_to_decimal (string, &f, sizeof (string));
fprintf (file, " %s", string);
}
fprintf (file, ">");
}
int main (int argc, char **argv)
{
int c;
unsigned short port = 0;
binding_t *source = 0;
binding_t *dest = 0;
binding_t *s, *d;
char packet[8192];
int n;
int i;
int nsource;
int soopts;
int verbose = 0;
int source_set = 0;
int dest_set = 0;
struct pollfd *fds;
while ((c = getopt (argc, argv, "vp:s:d:")) >= 0)
{
switch (c) {
case 'p':
port = atoi (optarg);
if (port <= 0)
usage (argv[0]);
break;
case 's':
s = make_binding (optarg);
s->next = source;
source = s;
break;
case 'd':
d = make_binding (optarg);
d->next = dest;
dest = d;
break;
case 'v':
verbose++;
break;
default:
usage (argv[0]);
break;
}
}
if (!port || !source || !dest)
usage (argv[0]);
nsource = 0;
for (s = source; s; s = s->next)
{
set_source (s, port);
if (verbose)
dump_addr (s->fd, "source", 0);
nsource++;
}
if (nsource > 1)
{
fds = malloc (nsource * sizeof (struct pollfd));
if (!fds)
losing (argv[0], "malloc fds");
i = 0;
for (s = source; s; s = s->next)
{
fds[i].fd = s->fd;
fds[i].events = POLLIN;
fds[i].revents = 0;
}
}
else
fds = 0;
for (d = dest; d; d = d->next)
{
set_dest (d, port);
if (verbose)
dump_addr (d->fd, "dest", 1);
}
/* spend a while shipping packets around */
for (;;)
{
if (fds)
{
i = poll (fds, nsource, -1);
if (i < 0)
break;
}
i = 0;
for (s = source, i = 0; s; s = s->next, i++)
{
if (!fds || fds[i].revents & POLLIN)
{
n = read (s->fd, packet, sizeof (packet));
if (n < 0)
losing (argv[0], "read");
if (verbose)
fprintf (stderr, "%d\n", n );
for (d = dest; d; d = d->next)
{
if (write (d->fd, packet, n) < n)
losing (argv[0], "write");
}
}
}
}
}
bool kXAudioEngine::initHardware(IOService *provider)
{
bool result = false;
IOAudioSampleRate initialSampleRate;
IOAudioStream *audioStream;
debug("kXAudioEngine[%p]::initHardware(%p)\n", this, provider);
if (!super::initHardware(provider)) {
goto Done;
}
// Setup the initial sample rate for the audio engine
initialSampleRate.whole = sampling_rate;
initialSampleRate.fraction = 0;
char device_name[KX_MAX_STRING];
strncpy(device_name,"kX ",KX_MAX_STRING);
strncat(device_name,hw->card_name,KX_MAX_STRING);
setDescription(device_name);
setSampleRate(&initialSampleRate);
setClockDomain(); // =kIOAudioNewClockDomain
// calculate kx_sample_offset
if(hw->is_10k2)
{
// setSampleOffset(28); // 28 samples
setSampleLatency(28+1);
}
else
{
// setSampleOffset(32); // 32 samples
setSampleLatency(32+1);
}
// Allocate our input and output buffers
for(int i=0;i<n_channels;i++)
{
// Create an IOAudioStream for each buffer and add it to this audio engine
audioStream = createNewAudioStream(i,kIOAudioStreamDirectionOutput, 1*n_frames*bps/8);
if (!audioStream) {
goto Done;
}
addAudioStream(audioStream);
out_streams[i]=audioStream;
}
// recording
audioStream = createNewAudioStream(0,kIOAudioStreamDirectionInput, n_channels*n_frames*bps/8);
if (!audioStream) {
goto Done;
}
addAudioStream(audioStream);
in_streams[0]=audioStream;
dump_addr();
// Set the number of sample frames in each buffer
setNumSampleFramesPerBuffer(n_frames);
result = true;
Done:
if(result==false)
free_all();
return result;
}
void
print_node (FILE *file, const char *prefix, tree node, int indent)
{
int hash;
struct bucket *b;
machine_mode mode;
enum tree_code_class tclass;
int len;
int i;
expanded_location xloc;
enum tree_code code;
if (node == 0)
return;
code = TREE_CODE (node);
tclass = TREE_CODE_CLASS (code);
/* Don't get too deep in nesting. If the user wants to see deeper,
it is easy to use the address of a lowest-level node
as an argument in another call to debug_tree. */
if (indent > 24)
{
print_node_brief (file, prefix, node, indent);
return;
}
if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration))
{
print_node_brief (file, prefix, node, indent);
return;
}
/* It is unsafe to look at any other fields of an ERROR_MARK node. */
if (code == ERROR_MARK)
{
print_node_brief (file, prefix, node, indent);
return;
}
/* Allow this function to be called if the table is not there. */
if (table)
{
hash = ((uintptr_t) node) % HASH_SIZE;
/* If node is in the table, just mention its address. */
for (b = table[hash]; b; b = b->next)
if (b->node == node)
{
print_node_brief (file, prefix, node, indent);
return;
}
/* Add this node to the table. */
b = XNEW (struct bucket);
b->node = node;
b->next = table[hash];
table[hash] = b;
}
/* Indent to the specified column, since this is the long form. */
indent_to (file, indent);
/* Print the slot this node is in, and its code, and address. */
fprintf (file, "%s <%s", prefix, get_tree_code_name (code));
dump_addr (file, " ", node);
/* Print the name, if any. */
if (tclass == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
else if (code == LABEL_DECL
&& LABEL_DECL_UID (node) != -1)
{
if (dump_flags & TDF_NOUID)
fprintf (file, " L.xxxx");
else
fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
}
else
{
if (dump_flags & TDF_NOUID)
fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D');
else
fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D',
DECL_UID (node));
}
}
else if (tclass == tcc_type)
{
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
fprintf (file, " %s",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
}
}
if (code == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (node));
if (code == INTEGER_CST)
{
if (indent <= 4)
print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
}
else if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
{
print_node (file, "type", TREE_TYPE (node), indent + 4);
if (TREE_TYPE (node))
indent_to (file, indent + 3);
}
if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
fputs (" side-effects", file);
if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
fputs (" readonly", file);
if (TYPE_P (node) && TYPE_ATOMIC (node))
fputs (" atomic", file);
if (!TYPE_P (node) && TREE_CONSTANT (node))
fputs (" constant", file);
else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
fputs (" sizes-gimplified", file);
if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
if (TREE_ADDRESSABLE (node))
fputs (" addressable", file);
if (TREE_THIS_VOLATILE (node))
fputs (" volatile", file);
if (TREE_ASM_WRITTEN (node))
fputs (" asm_written", file);
if (TREE_USED (node))
fputs (" used", file);
if (TREE_NOTHROW (node))
fputs (" nothrow", file);
if (TREE_PUBLIC (node))
fputs (" public", file);
if (TREE_PRIVATE (node))
fputs (" private", file);
if (TREE_PROTECTED (node))
fputs (" protected", file);
if (TREE_STATIC (node))
fputs (code == CALL_EXPR ? " must-tail-call" : " static", file);
if (TREE_DEPRECATED (node))
fputs (" deprecated", file);
if (TREE_VISITED (node))
fputs (" visited", file);
if (code != TREE_VEC && code != INTEGER_CST && code != SSA_NAME)
{
if (TREE_LANG_FLAG_0 (node))
fputs (" tree_0", file);
if (TREE_LANG_FLAG_1 (node))
fputs (" tree_1", file);
if (TREE_LANG_FLAG_2 (node))
fputs (" tree_2", file);
if (TREE_LANG_FLAG_3 (node))
fputs (" tree_3", file);
if (TREE_LANG_FLAG_4 (node))
fputs (" tree_4", file);
if (TREE_LANG_FLAG_5 (node))
fputs (" tree_5", file);
if (TREE_LANG_FLAG_6 (node))
fputs (" tree_6", file);
}
/* DECL_ nodes have additional attributes. */
switch (TREE_CODE_CLASS (code))
{
case tcc_declaration:
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
if (DECL_UNSIGNED (node))
fputs (" unsigned", file);
if (DECL_IGNORED_P (node))
fputs (" ignored", file);
if (DECL_ABSTRACT_P (node))
fputs (" abstract", file);
if (DECL_EXTERNAL (node))
fputs (" external", file);
if (DECL_NONLOCAL (node))
fputs (" nonlocal", file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
{
if (DECL_WEAK (node))
fputs (" weak", file);
if (DECL_IN_SYSTEM_HEADER (node))
fputs (" in_system_header", file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
&& code != LABEL_DECL
&& code != FUNCTION_DECL
&& DECL_REGISTER (node))
fputs (" regdecl", file);
if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
fputs (" suppress-debug", file);
if (code == FUNCTION_DECL
&& DECL_FUNCTION_SPECIFIC_TARGET (node))
fputs (" function-specific-target", file);
if (code == FUNCTION_DECL
&& DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node))
fputs (" function-specific-opt", file);
if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node))
fputs (" autoinline", file);
if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
fputs (" built-in", file);
if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node))
fputs (" static-chain", file);
if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node))
fputs (" tm-clone", file);
if (code == FIELD_DECL && DECL_PACKED (node))
fputs (" packed", file);
if (code == FIELD_DECL && DECL_BIT_FIELD (node))
fputs (" bit-field", file);
if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
fputs (" nonaddressable", file);
if (code == LABEL_DECL && EH_LANDING_PAD_NR (node))
fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node));
if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node))
fputs (" in-text-section", file);
if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node))
fputs (" in-constant-pool", file);
if (code == VAR_DECL && DECL_COMMON (node))
fputs (" common", file);
if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node))
{
fputs (" ", file);
fputs (tls_model_names[DECL_TLS_MODEL (node)], file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
if (DECL_VIRTUAL_P (node))
fputs (" virtual", file);
if (DECL_PRESERVE_P (node))
fputs (" preserve", file);
if (DECL_LANG_FLAG_0 (node))
fputs (" decl_0", file);
if (DECL_LANG_FLAG_1 (node))
fputs (" decl_1", file);
if (DECL_LANG_FLAG_2 (node))
fputs (" decl_2", file);
if (DECL_LANG_FLAG_3 (node))
fputs (" decl_3", file);
if (DECL_LANG_FLAG_4 (node))
fputs (" decl_4", file);
if (DECL_LANG_FLAG_5 (node))
fputs (" decl_5", file);
if (DECL_LANG_FLAG_6 (node))
fputs (" decl_6", file);
if (DECL_LANG_FLAG_7 (node))
fputs (" decl_7", file);
mode = DECL_MODE (node);
fprintf (file, " %s", GET_MODE_NAME (mode));
}
if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
&& DECL_BY_REFERENCE (node))
fputs (" passed-by-reference", file);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node))
fputs (" defer-output", file);
xloc = expand_location (DECL_SOURCE_LOCATION (node));
fprintf (file, " file %s line %d col %d", xloc.file, xloc.line,
xloc.column);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
print_node (file, "size", DECL_SIZE (node), indent + 4);
print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);
if (code != FUNCTION_DECL || DECL_BUILT_IN (node))
indent_to (file, indent + 3);
if (DECL_USER_ALIGN (node))
fprintf (file, " user");
fprintf (file, " align %d", DECL_ALIGN (node));
if (code == FIELD_DECL)
fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
DECL_OFFSET_ALIGN (node));
if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
{
if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
else
fprintf (file, " built-in %s:%s",
built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
built_in_names[(int) DECL_FUNCTION_CODE (node)]);
}
}
if (code == FIELD_DECL)
{
print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
indent + 4);
if (DECL_BIT_FIELD_TYPE (node))
print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
indent + 4);
}
print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
print_node_brief (file, "attributes",
DECL_ATTRIBUTES (node), indent + 4);
if (code != PARM_DECL)
print_node_brief (file, "initial", DECL_INITIAL (node),
indent + 4);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
{
print_node_brief (file, "abstract_origin",
DECL_ABSTRACT_ORIGIN (node), indent + 4);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
{
print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
}
lang_hooks.print_decl (file, node, indent);
if (DECL_RTL_SET_P (node))
{
indent_to (file, indent + 4);
print_rtl (file, DECL_RTL (node));
}
if (code == PARM_DECL)
{
print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
if (DECL_INCOMING_RTL (node) != 0)
{
indent_to (file, indent + 4);
fprintf (file, "incoming-rtl ");
print_rtl (file, DECL_INCOMING_RTL (node));
}
}
else if (code == FUNCTION_DECL
&& DECL_STRUCT_FUNCTION (node) != 0)
{
print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
indent_to (file, indent + 4);
dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node));
}
if ((code == VAR_DECL || code == PARM_DECL)
&& DECL_HAS_VALUE_EXPR_P (node))
print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
/* Print the decl chain only if decl is at second level. */
if (indent == 4)
print_node (file, "chain", TREE_CHAIN (node), indent + 4);
else
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case tcc_type:
if (TYPE_UNSIGNED (node))
fputs (" unsigned", file);
if (TYPE_NO_FORCE_BLK (node))
fputs (" no-force-blk", file);
if (TYPE_STRING_FLAG (node))
fputs (" string-flag", file);
if (TYPE_NEEDS_CONSTRUCTING (node))
fputs (" needs-constructing", file);
if ((code == RECORD_TYPE
|| code == UNION_TYPE
|| code == QUAL_UNION_TYPE
|| code == ARRAY_TYPE)
&& TYPE_REVERSE_STORAGE_ORDER (node))
fputs (" reverse-storage-order", file);
/* The transparent-union flag is used for different things in
different nodes. */
if ((code == UNION_TYPE || code == RECORD_TYPE)
&& TYPE_TRANSPARENT_AGGR (node))
fputs (" transparent-aggr", file);
else if (code == ARRAY_TYPE
&& TYPE_NONALIASED_COMPONENT (node))
fputs (" nonaliased-component", file);
if (TYPE_PACKED (node))
fputs (" packed", file);
if (TYPE_RESTRICT (node))
fputs (" restrict", file);
if (TYPE_LANG_FLAG_0 (node))
fputs (" type_0", file);
if (TYPE_LANG_FLAG_1 (node))
fputs (" type_1", file);
if (TYPE_LANG_FLAG_2 (node))
fputs (" type_2", file);
if (TYPE_LANG_FLAG_3 (node))
fputs (" type_3", file);
if (TYPE_LANG_FLAG_4 (node))
fputs (" type_4", file);
if (TYPE_LANG_FLAG_5 (node))
fputs (" type_5", file);
if (TYPE_LANG_FLAG_6 (node))
fputs (" type_6", file);
if (TYPE_LANG_FLAG_7 (node))
fputs (" type_7", file);
mode = TYPE_MODE (node);
fprintf (file, " %s", GET_MODE_NAME (mode));
print_node (file, "size", TYPE_SIZE (node), indent + 4);
print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4);
indent_to (file, indent + 3);
if (TYPE_USER_ALIGN (node))
fprintf (file, " user");
fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC,
TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node),
(HOST_WIDE_INT) TYPE_ALIAS_SET (node));
if (TYPE_STRUCTURAL_EQUALITY_P (node))
fprintf (file, " structural equality");
else
dump_addr (file, " canonical type ", TYPE_CANONICAL (node));
print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE
|| code == FIXED_POINT_TYPE)
{
fprintf (file, " precision %d", TYPE_PRECISION (node));
print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
}
if (code == ENUMERAL_TYPE)
print_node (file, "values", TYPE_VALUES (node), indent + 4);
else if (code == ARRAY_TYPE)
print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
else if (code == VECTOR_TYPE)
fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node));
else if (code == RECORD_TYPE
|| code == UNION_TYPE
|| code == QUAL_UNION_TYPE)
print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
else if (code == FUNCTION_TYPE
|| code == METHOD_TYPE)
{
if (TYPE_METHOD_BASETYPE (node))
print_node_brief (file, "method basetype",
TYPE_METHOD_BASETYPE (node), indent + 4);
print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
}
else if (code == OFFSET_TYPE)
print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
indent + 4);
if (TYPE_CONTEXT (node))
print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
lang_hooks.print_type (file, node, indent);
if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
indent_to (file, indent + 3);
print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
indent + 4);
print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
indent + 4);
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case tcc_expression:
case tcc_comparison:
case tcc_unary:
case tcc_binary:
case tcc_reference:
case tcc_statement:
case tcc_vl_exp:
if (code == BIND_EXPR)
{
print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
break;
}
if (code == CALL_EXPR)
{
call_expr_arg_iterator iter;
tree arg;
print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
indent + 4);
i = 0;
FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
{
char temp[10];
sprintf (temp, "arg %d", i);
print_node (file, temp, arg, indent + 4);
i++;
}
}
static void
print_rtx (rtx in_rtx)
{
int i = 0;
int j;
const char *format_ptr;
int is_insn;
if (sawclose)
{
if (flag_simple)
fputc (' ', outfile);
else
fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
sawclose = 0;
}
if (in_rtx == 0)
{
fputs ("(nil)", outfile);
sawclose = 1;
return;
}
else if (GET_CODE (in_rtx) > NUM_RTX_CODE)
{
fprintf (outfile, "(??? bad code %d\n)", GET_CODE (in_rtx));
sawclose = 1;
return;
}
is_insn = INSN_P (in_rtx);
/* When printing in VCG format we write INSNs, NOTE, LABEL, and BARRIER
in separate nodes and therefore have to handle them special here. */
if (dump_for_graph
&& (is_insn || NOTE_P (in_rtx)
|| LABEL_P (in_rtx) || BARRIER_P (in_rtx)))
{
i = 3;
indent = 0;
}
else
{
/* Print name of expression code. */
if (flag_simple && GET_CODE (in_rtx) == CONST_INT)
fputc ('(', outfile);
else
fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));
if (! flag_simple)
{
if (RTX_FLAG (in_rtx, in_struct))
fputs ("/s", outfile);
if (RTX_FLAG (in_rtx, volatil))
fputs ("/v", outfile);
if (RTX_FLAG (in_rtx, unchanging))
fputs ("/u", outfile);
if (RTX_FLAG (in_rtx, frame_related))
fputs ("/f", outfile);
if (RTX_FLAG (in_rtx, jump))
fputs ("/j", outfile);
if (RTX_FLAG (in_rtx, call))
fputs ("/c", outfile);
if (RTX_FLAG (in_rtx, return_val))
fputs ("/i", outfile);
/* Print REG_NOTE names for EXPR_LIST and INSN_LIST. */
if (GET_CODE (in_rtx) == EXPR_LIST
|| GET_CODE (in_rtx) == INSN_LIST)
fprintf (outfile, ":%s",
GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
/* For other rtl, print the mode if it's not VOID. */
else if (GET_MODE (in_rtx) != VOIDmode)
fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
}
}
#ifndef GENERATOR_FILE
if (GET_CODE (in_rtx) == CONST_DOUBLE && FLOAT_MODE_P (GET_MODE (in_rtx)))
i = 5;
#endif
/* Get the format string and skip the first elements if we have handled
them already. */
format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)) + i;
for (; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
switch (*format_ptr++)
{
const char *str;
case 'T':
str = XTMPL (in_rtx, i);
goto string;
case 'S':
case 's':
str = XSTR (in_rtx, i);
string:
if (str == 0)
fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
else
{
if (dump_for_graph)
fprintf (outfile, " (\\\"%s\\\")", str);
else
fprintf (outfile, " (\"%s\")", str);
}
sawclose = 1;
break;
/* 0 indicates a field for internal use that should not be printed.
An exception is the third field of a NOTE, where it indicates
that the field has several different valid contents. */
case '0':
if (i == 1 && REG_P (in_rtx))
{
if (REGNO (in_rtx) != ORIGINAL_REGNO (in_rtx))
fprintf (outfile, " [%d]", ORIGINAL_REGNO (in_rtx));
}
#ifndef GENERATOR_FILE
else if (i == 1 && GET_CODE (in_rtx) == SYMBOL_REF)
{
int flags = SYMBOL_REF_FLAGS (in_rtx);
if (flags)
fprintf (outfile, " [flags 0x%x]", flags);
}
else if (i == 2 && GET_CODE (in_rtx) == SYMBOL_REF)
{
tree decl = SYMBOL_REF_DECL (in_rtx);
if (decl)
print_node_brief (outfile, "", decl, 0);
}
#endif
else if (i == 4 && NOTE_P (in_rtx))
{
switch (NOTE_LINE_NUMBER (in_rtx))
{
case NOTE_INSN_EH_REGION_BEG:
case NOTE_INSN_EH_REGION_END:
if (flag_dump_unnumbered)
fprintf (outfile, " #");
else
fprintf (outfile, " %d", NOTE_EH_HANDLER (in_rtx));
sawclose = 1;
break;
case NOTE_INSN_BLOCK_BEG:
case NOTE_INSN_BLOCK_END:
#ifndef GENERATOR_FILE
dump_addr (outfile, " ", NOTE_BLOCK (in_rtx));
#endif
sawclose = 1;
break;
case NOTE_INSN_BASIC_BLOCK:
{
#ifndef GENERATOR_FILE
basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
if (bb != 0)
fprintf (outfile, " [bb %d]", bb->index);
#endif
break;
}
case NOTE_INSN_EXPECTED_VALUE:
indent += 2;
if (!sawclose)
fprintf (outfile, " ");
print_rtx (NOTE_EXPECTED_VALUE (in_rtx));
indent -= 2;
break;
case NOTE_INSN_DELETED_LABEL:
{
const char *label = NOTE_DELETED_LABEL_NAME (in_rtx);
if (label)
fprintf (outfile, " (\"%s\")", label);
else
fprintf (outfile, " \"\"");
}
break;
case NOTE_INSN_SWITCH_TEXT_SECTIONS:
{
#ifndef GENERATOR_FILE
basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
if (bb != 0)
fprintf (outfile, " [bb %d]", bb->index);
#endif
break;
}
case NOTE_INSN_VAR_LOCATION:
#ifndef GENERATOR_FILE
fprintf (outfile, " (");
print_mem_expr (outfile, NOTE_VAR_LOCATION_DECL (in_rtx));
fprintf (outfile, " ");
print_rtx (NOTE_VAR_LOCATION_LOC (in_rtx));
fprintf (outfile, ")");
#endif
break;
default:
{
const char * const str = X0STR (in_rtx, i);
if (NOTE_LINE_NUMBER (in_rtx) < 0)
;
else if (str == 0)
fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
else
{
if (dump_for_graph)
fprintf (outfile, " (\\\"%s\\\")", str);
else
fprintf (outfile, " (\"%s\")", str);
}
break;
}
}
}
break;
case 'e':
do_e:
indent += 2;
if (!sawclose)
fprintf (outfile, " ");
print_rtx (XEXP (in_rtx, i));
indent -= 2;
break;
case 'E':
case 'V':
indent += 2;
if (sawclose)
{
fprintf (outfile, "\n%s%*s",
print_rtx_head, indent * 2, "");
sawclose = 0;
}
fputs (" [", outfile);
if (NULL != XVEC (in_rtx, i))
{
indent += 2;
if (XVECLEN (in_rtx, i))
sawclose = 1;
for (j = 0; j < XVECLEN (in_rtx, i); j++)
print_rtx (XVECEXP (in_rtx, i, j));
indent -= 2;
}
if (sawclose)
fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
fputs ("]", outfile);
sawclose = 1;
indent -= 2;
break;
case 'w':
if (! flag_simple)
fprintf (outfile, " ");
fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
if (! flag_simple)
fprintf (outfile, " [" HOST_WIDE_INT_PRINT_HEX "]",
XWINT (in_rtx, i));
break;
case 'i':
if (i == 4 && INSN_P (in_rtx))
{
#ifndef GENERATOR_FILE
/* Pretty-print insn locators. Ignore scoping as it is mostly
redundant with line number information and do not print anything
when there is no location information available. */
if (INSN_LOCATOR (in_rtx) && insn_file (in_rtx))
fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx));
#endif
}
else if (i == 6 && NOTE_P (in_rtx))
{
/* This field is only used for NOTE_INSN_DELETED_LABEL, and
other times often contains garbage from INSN->NOTE death. */
if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_DELETED_LABEL)
fprintf (outfile, " %d", XINT (in_rtx, i));
}
else
{
int value = XINT (in_rtx, i);
const char *name;
#ifndef GENERATOR_FILE
if (REG_P (in_rtx) && value < FIRST_PSEUDO_REGISTER)
fprintf (outfile, " %d %s", REGNO (in_rtx),
reg_names[REGNO (in_rtx)]);
else if (REG_P (in_rtx)
&& value <= LAST_VIRTUAL_REGISTER)
{
if (value == VIRTUAL_INCOMING_ARGS_REGNUM)
fprintf (outfile, " %d virtual-incoming-args", value);
else if (value == VIRTUAL_STACK_VARS_REGNUM)
fprintf (outfile, " %d virtual-stack-vars", value);
else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM)
fprintf (outfile, " %d virtual-stack-dynamic", value);
else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM)
fprintf (outfile, " %d virtual-outgoing-args", value);
else if (value == VIRTUAL_CFA_REGNUM)
fprintf (outfile, " %d virtual-cfa", value);
else
fprintf (outfile, " %d virtual-reg-%d", value,
value-FIRST_VIRTUAL_REGISTER);
}
else
#endif
if (flag_dump_unnumbered
&& (is_insn || NOTE_P (in_rtx)))
fputc ('#', outfile);
else
fprintf (outfile, " %d", value);
#ifndef GENERATOR_FILE
if (REG_P (in_rtx) && REG_ATTRS (in_rtx))
{
fputs (" [", outfile);
if (ORIGINAL_REGNO (in_rtx) != REGNO (in_rtx))
fprintf (outfile, "orig:%i", ORIGINAL_REGNO (in_rtx));
if (REG_EXPR (in_rtx))
print_mem_expr (outfile, REG_EXPR (in_rtx));
if (REG_OFFSET (in_rtx))
fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
REG_OFFSET (in_rtx));
fputs (" ]", outfile);
}
#endif
if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
&& XINT (in_rtx, i) >= 0
&& (name = get_insn_name (XINT (in_rtx, i))) != NULL)
fprintf (outfile, " {%s}", name);
sawclose = 0;
}
break;
/* Print NOTE_INSN names rather than integer codes. */
case 'n':
if (XINT (in_rtx, i) >= (int) NOTE_INSN_BIAS
&& XINT (in_rtx, i) < (int) NOTE_INSN_MAX)
fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i)));
else
fprintf (outfile, " %d", XINT (in_rtx, i));
sawclose = 0;
break;
case 'u':
if (XEXP (in_rtx, i) != NULL)
{
rtx sub = XEXP (in_rtx, i);
enum rtx_code subc = GET_CODE (sub);
if (GET_CODE (in_rtx) == LABEL_REF)
{
if (subc == NOTE
&& NOTE_LINE_NUMBER (sub) == NOTE_INSN_DELETED_LABEL)
{
if (flag_dump_unnumbered)
fprintf (outfile, " [# deleted]");
else
fprintf (outfile, " [%d deleted]", INSN_UID (sub));
sawclose = 0;
break;
}
if (subc != CODE_LABEL)
goto do_e;
}
if (flag_dump_unnumbered)
fputs (" #", outfile);
else
fprintf (outfile, " %d", INSN_UID (sub));
}
else
fputs (" 0", outfile);
sawclose = 0;
break;
case 'b':
#ifndef GENERATOR_FILE
if (XBITMAP (in_rtx, i) == NULL)
fputs (" {null}", outfile);
else
bitmap_print (outfile, XBITMAP (in_rtx, i), " {", "}");
#endif
sawclose = 0;
break;
case 't':
#ifndef GENERATOR_FILE
dump_addr (outfile, " ", XTREE (in_rtx, i));
#endif
break;
case '*':
fputs (" Unknown", outfile);
sawclose = 0;
break;
case 'B':
#ifndef GENERATOR_FILE
if (XBBDEF (in_rtx, i))
fprintf (outfile, " %i", XBBDEF (in_rtx, i)->index);
#endif
break;
default:
gcc_unreachable ();
}
switch (GET_CODE (in_rtx))
{
#ifndef GENERATOR_FILE
case MEM:
fprintf (outfile, " [" HOST_WIDE_INT_PRINT_DEC, MEM_ALIAS_SET (in_rtx));
if (MEM_EXPR (in_rtx))
print_mem_expr (outfile, MEM_EXPR (in_rtx));
if (MEM_OFFSET (in_rtx))
fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
INTVAL (MEM_OFFSET (in_rtx)));
if (MEM_SIZE (in_rtx))
fprintf (outfile, " S" HOST_WIDE_INT_PRINT_DEC,
INTVAL (MEM_SIZE (in_rtx)));
if (MEM_ALIGN (in_rtx) != 1)
fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));
fputc (']', outfile);
break;
case CONST_DOUBLE:
if (FLOAT_MODE_P (GET_MODE (in_rtx)))
{
char s[60];
real_to_decimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
sizeof (s), 0, 1);
fprintf (outfile, " %s", s);
real_to_hexadecimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
sizeof (s), 0, 1);
fprintf (outfile, " [%s]", s);
}
break;
#endif
case CODE_LABEL:
fprintf (outfile, " [%d uses]", LABEL_NUSES (in_rtx));
switch (LABEL_KIND (in_rtx))
{
case LABEL_NORMAL: break;
case LABEL_STATIC_ENTRY: fputs (" [entry]", outfile); break;
case LABEL_GLOBAL_ENTRY: fputs (" [global entry]", outfile); break;
case LABEL_WEAK_ENTRY: fputs (" [weak entry]", outfile); break;
default: gcc_unreachable ();
}
break;
default:
break;
}
if (dump_for_graph
&& (is_insn || NOTE_P (in_rtx)
|| LABEL_P (in_rtx) || BARRIER_P (in_rtx)))
sawclose = 0;
else
{
fputc (')', outfile);
sawclose = 1;
}
}
int
test_parse_ipaddr_valid(void)
{
cmdline_parse_token_ipaddr_t token;
char buf[CMDLINE_TEST_BUFSIZE];
cmdline_ipaddr_t result;
unsigned i;
uint8_t flags;
int ret;
/* cover all cases in help */
for (flags = 0x1; flags < 0x8; flags++) {
token.ipaddr_data.flags = flags;
memset(buf, 0, sizeof(buf));
if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
buf, sizeof(buf)) == -1) {
printf("Error: help rejected valid parameters!\n");
return -1;
}
}
/* test valid strings */
for (i = 0; i < IPADDR_VALID_STRS_SIZE; i++) {
/* test each valid string against different flags */
for (flags = 1; flags < 0x8; flags++) {
/* skip bad flag */
if (flags == CMDLINE_IPADDR_NETWORK)
continue;
/* clear out everything */
memset(buf, 0, sizeof(buf));
memset(&result, 0, sizeof(result));
memset(&token, 0, sizeof(token));
token.ipaddr_data.flags = flags;
cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
buf, sizeof(buf));
ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
ipaddr_valid_strs[i].str, (void*)&result);
/* if should have passed, or should have failed */
if ((ret < 0) ==
(can_parse_addr(ipaddr_valid_strs[i].flags, flags))) {
printf("Error: unexpected behavior when parsing %s as %s!\n",
ipaddr_valid_strs[i].str, buf);
printf("Parsed result: ");
dump_addr(result);
printf("Expected result: ");
dump_addr(ipaddr_valid_strs[i].addr);
return -1;
}
if (ret != -1 &&
is_addr_different(result, ipaddr_valid_strs[i].addr)) {
printf("Error: result mismatch when parsing %s as %s!\n",
ipaddr_valid_strs[i].str, buf);
printf("Parsed result: ");
dump_addr(result);
printf("Expected result: ");
dump_addr(ipaddr_valid_strs[i].addr);
return -1;
}
}
}
/* test garbage ipv4 address strings */
for (i = 0; i < IPADDR_GARBAGE_ADDR4_STRS_SIZE; i++) {
struct in_addr tmp = IPv4_GARBAGE_ADDR;
/* test each valid string against different flags */
for (flags = 1; flags < 0x8; flags++) {
/* skip bad flag */
if (flags == CMDLINE_IPADDR_NETWORK)
continue;
/* clear out everything */
memset(buf, 0, sizeof(buf));
memset(&result, 0, sizeof(result));
memset(&token, 0, sizeof(token));
token.ipaddr_data.flags = flags;
cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
buf, sizeof(buf));
ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
ipaddr_garbage_addr4_strs[i], (void*)&result);
/* if should have passed, or should have failed */
if ((ret < 0) ==
(can_parse_addr(CMDLINE_IPADDR_V4, flags))) {
printf("Error: unexpected behavior when parsing %s as %s!\n",
ipaddr_garbage_addr4_strs[i], buf);
return -1;
}
if (ret != -1 &&
memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
printf("Error: result mismatch when parsing %s as %s!\n",
ipaddr_garbage_addr4_strs[i], buf);
return -1;
}
}
}
/* test garbage ipv6 address strings */
for (i = 0; i < IPADDR_GARBAGE_ADDR6_STRS_SIZE; i++) {
cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
/* test each valid string against different flags */
for (flags = 1; flags < 0x8; flags++) {
/* skip bad flag */
if (flags == CMDLINE_IPADDR_NETWORK)
continue;
/* clear out everything */
memset(buf, 0, sizeof(buf));
memset(&result, 0, sizeof(result));
memset(&token, 0, sizeof(token));
token.ipaddr_data.flags = flags;
cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
buf, sizeof(buf));
ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
ipaddr_garbage_addr6_strs[i], (void*)&result);
/* if should have passed, or should have failed */
if ((ret < 0) ==
(can_parse_addr(CMDLINE_IPADDR_V6, flags))) {
printf("Error: unexpected behavior when parsing %s as %s!\n",
ipaddr_garbage_addr6_strs[i], buf);
return -1;
}
if (ret != -1 &&
memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
printf("Error: result mismatch when parsing %s as %s!\n",
ipaddr_garbage_addr6_strs[i], buf);
return -1;
}
}
}
/* test garbage ipv4 network strings */
for (i = 0; i < IPADDR_GARBAGE_NETWORK4_STRS_SIZE; i++) {
struct in_addr tmp = IPv4_GARBAGE_ADDR;
/* test each valid string against different flags */
for (flags = 1; flags < 0x8; flags++) {
/* skip bad flag */
if (flags == CMDLINE_IPADDR_NETWORK)
continue;
/* clear out everything */
memset(buf, 0, sizeof(buf));
memset(&result, 0, sizeof(result));
memset(&token, 0, sizeof(token));
token.ipaddr_data.flags = flags;
cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
buf, sizeof(buf));
ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
ipaddr_garbage_network4_strs[i], (void*)&result);
/* if should have passed, or should have failed */
if ((ret < 0) ==
(can_parse_addr(CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK, flags))) {
printf("Error: unexpected behavior when parsing %s as %s!\n",
ipaddr_garbage_network4_strs[i], buf);
return -1;
}
if (ret != -1 &&
memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
printf("Error: result mismatch when parsing %s as %s!\n",
ipaddr_garbage_network4_strs[i], buf);
return -1;
}
}
}
/* test garbage ipv6 address strings */
for (i = 0; i < IPADDR_GARBAGE_NETWORK6_STRS_SIZE; i++) {
cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
/* test each valid string against different flags */
for (flags = 1; flags < 0x8; flags++) {
/* skip bad flag */
if (flags == CMDLINE_IPADDR_NETWORK)
continue;
/* clear out everything */
memset(buf, 0, sizeof(buf));
memset(&result, 0, sizeof(result));
memset(&token, 0, sizeof(token));
token.ipaddr_data.flags = flags;
cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
buf, sizeof(buf));
ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
ipaddr_garbage_network6_strs[i], (void*)&result);
/* if should have passed, or should have failed */
if ((ret < 0) ==
(can_parse_addr(CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK, flags))) {
printf("Error: unexpected behavior when parsing %s as %s!\n",
ipaddr_garbage_network6_strs[i], buf);
return -1;
}
if (ret != -1 &&
memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
printf("Error: result mismatch when parsing %s as %s!\n",
ipaddr_garbage_network6_strs[i], buf);
return -1;
}
}
}
return 0;
}
void
symtab_node::dump_base (FILE *f)
{
static const char * const visibility_types[] = {
"default", "protected", "hidden", "internal"
};
fprintf (f, "%s/%i (%s)", asm_name (), order, name ());
dump_addr (f, " @", (void *)this);
fprintf (f, "\n Type: %s", symtab_type_names[type]);
if (definition)
fprintf (f, " definition");
if (analyzed)
fprintf (f, " analyzed");
if (alias)
fprintf (f, " alias");
if (weakref)
fprintf (f, " weakref");
if (cpp_implicit_alias)
fprintf (f, " cpp_implicit_alias");
if (alias_target)
fprintf (f, " target:%s",
DECL_P (alias_target)
? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
(alias_target))
: IDENTIFIER_POINTER (alias_target));
if (body_removed)
fprintf (f, "\n Body removed by symtab_remove_unreachable_nodes");
fprintf (f, "\n Visibility:");
if (in_other_partition)
fprintf (f, " in_other_partition");
if (used_from_other_partition)
fprintf (f, " used_from_other_partition");
if (force_output)
fprintf (f, " force_output");
if (forced_by_abi)
fprintf (f, " forced_by_abi");
if (externally_visible)
fprintf (f, " externally_visible");
if (resolution != LDPR_UNKNOWN)
fprintf (f, " %s",
ld_plugin_symbol_resolution_names[(int)resolution]);
if (TREE_ASM_WRITTEN (decl))
fprintf (f, " asm_written");
if (DECL_EXTERNAL (decl))
fprintf (f, " external");
if (TREE_PUBLIC (decl))
fprintf (f, " public");
if (DECL_COMMON (decl))
fprintf (f, " common");
if (DECL_WEAK (decl))
fprintf (f, " weak");
if (DECL_DLLIMPORT_P (decl))
fprintf (f, " dll_import");
if (DECL_COMDAT (decl))
fprintf (f, " comdat");
if (get_comdat_group ())
fprintf (f, " comdat_group:%s",
IDENTIFIER_POINTER (get_comdat_group_id ()));
if (DECL_ONE_ONLY (decl))
fprintf (f, " one_only");
if (get_section ())
fprintf (f, " section:%s",
get_section ());
if (implicit_section)
fprintf (f," (implicit_section)");
if (DECL_VISIBILITY_SPECIFIED (decl))
fprintf (f, " visibility_specified");
if (DECL_VISIBILITY (decl))
fprintf (f, " visibility:%s",
visibility_types [DECL_VISIBILITY (decl)]);
if (DECL_VIRTUAL_P (decl))
fprintf (f, " virtual");
if (DECL_ARTIFICIAL (decl))
fprintf (f, " artificial");
if (TREE_CODE (decl) == FUNCTION_DECL)
{
if (DECL_STATIC_CONSTRUCTOR (decl))
fprintf (f, " constructor");
if (DECL_STATIC_DESTRUCTOR (decl))
fprintf (f, " destructor");
}
fprintf (f, "\n");
if (same_comdat_group)
fprintf (f, " Same comdat group as: %s/%i\n",
same_comdat_group->asm_name (),
same_comdat_group->order);
if (next_sharing_asm_name)
fprintf (f, " next sharing asm name: %i\n",
next_sharing_asm_name->order);
if (previous_sharing_asm_name)
fprintf (f, " previous sharing asm name: %i\n",
previous_sharing_asm_name->order);
if (address_taken)
fprintf (f, " Address is taken.\n");
if (aux)
{
fprintf (f, " Aux:");
dump_addr (f, " @", (void *)aux);
}
fprintf (f, " References: ");
dump_references (f);
fprintf (f, " Referring: ");
dump_referring (f);
if (lto_file_data)
fprintf (f, " Read from file: %s\n",
lto_file_data->file_name);
}
