C++ printb函数代码示例

void armv7a::arm_sbfx(armv7a_ir& inst)
{
    inst.print_inst("arm_sbfx");
    inst.check(27, 21, B(011 1101));
    inst.check(6, 4, B(101));

    if(rf.condition_passed(inst.cond()))
    {
        uint32_t widthm1 = inst(20, 16);
        uint32_t rd = inst(15, 12);
        uint32_t lsb = inst(11, 7);
        uint32_t rn = inst(3, 0);
        uint32_t d = rd;
        uint32_t n = rn;
        uint32_t lsbit = lsb;
        uint32_t widthminus1 = widthm1;

        if((d == 15) || (n == 15))
        {
            printb(d_inst, "arm_sbfx error");
        }

        //ESO
        uint32_t msbit = lsbit + widthminus1;

        if(msbit <= 31)
        {
            bits _rn(get_field(rf.r_read(n), msbit, lsbit), widthm1 + 1);
            bits _rd;
            sign_extend(&_rd, _rn, 32);
            rf.r_write(d, _rd.val);
        }

        else
        {
            printb(d_inst, "arm_sbfx error 2");
        }
    }
}

/* write registers of the MCI module */
bool MCI::write(uint32_t data, uint32_t addr, int size)
{
    bool result = true;

    switch (addr) {
        default:
            printb(d_mci, "write unknown: 0x%.4x\n", addr);
            result = false;
            break;
    }

    return result;
}

bool ARMV5::check_be()
{
    bool b = cp15.c1_b();
    bool e = (CPSR_E(rf.cpsr)) ? true : false;

    if (!b && !e) {
        return true;
    }

    else {
        printb(core_id, d_armv5, "%s endian check error", current_inst_name);
    }
}

int test_apply_move() {
	int status, num_moves, i;
	Board board;
	Move *moves;
	status = WIN;
	num_moves = 0;
	setup(&board);
	printb(&board);
	moves = gen_moves(&board, &num_moves);
	printf("found %d moves\n", num_moves);
	for(i=0; i<35 && i<num_moves; i++) {
		printf("move %d: %d is moving from %d to %d, capturing %d\n",
			i, moving_type(moves[i]), moves[i].from,
			moves[i].to, capturing_type(moves[i]));
		printf("board after move %d looks like:\n", i+1);
		apply_move(&board, moves[i]);
		printb(&board);
		undo_move(&board, moves[i]);
	}
	
	return status;
}

bool gic2_vctrl::read(uint32_t* data, uint32_t offset)
{
    if(offset == 0x0)
    {
        *data = en;
    }
    else if(offset == 0x30)
    {
        //ELSR0, for list[0]~list[31]
        *data = 0;
        for(int i = 0; i <= 31; i++)
        {
            if(!list[i].valid)
            {
                set_bit(data, i, 1);
            }
        }
    }
    else if(offset == 0x34)
    {
        //ELSR1, for list[32]~list[63]
        *data = 0;
        for(int i = 32; i <= 63; i++)
        {
            if(!list[i - 32].valid)
            {
                set_bit(data, i - 32, 1);
            }
        }
    }
    else if((offset >= 0x100) && (offset <= 0x1FC))
    {
        //list[n]
        uint32_t n = (offset - 0x100) / 4;

        *data = 0;
        set_bit(data, 31, list[n].hw);
        set_bit(data, 30, list[n].group1);
        set_field(data, 29, 28, list[n].state);
        set_field(data, 27, 23, list[n].priority);
        set_field(data, 19, 10, list[n].pid);
        set_field(data, 9, 0, list[n].vid);
        printd(d_gic2_vctrl, "read list[%d], pid = %d, vid = %d", n, list[n].pid, list[n].vid);
    }
    else
    {
        printb(d_gic2_vctrl, "read 0x%X error", offset);
    }

    return true;
}

/* load the initrd image or binary data to RAM */
void board_realvieweb::load_initrd(char* path_initrd)
{
    int fid;

    printd(d_realvieweb, "loading initrd...");

    if (path_initrd != NULL) {
        fid = open(path_initrd, O_RDONLY);

        if (fid > 0) {
            uint32_t addr = ADDR_INITRD;
            uint32_t buff;
            int count;
            bool result;

            do {
                count = read(fid, &buff, 4);
                result = ram->write(buff, addr, 4);
                //result = ram->local_access(false, addr, buff, 4);
                size_initrd += count;

                if (result == false) {
                    printb(d_realvieweb, "cannot load initrd");
                }

                else {
                    addr += 4;
                }

            }
            while (count > 0);
        }

        else {
            printb(d_realvieweb, "cannot open initrd");
        }
    }
}

int main(int argc, char * argv[]) {
    struct mem_pool * pool = mem_pool_new(4);

    int r1,r2,r3,r4;

    r1 = mem_pool_alloc(pool, 16);
    printb(pool, r1);

    r2 = mem_pool_alloc(pool, 32);
    printb(pool, r2);

    r3 = mem_pool_alloc(pool, 16);
    printb(pool, r3);

    mem_pool_free(pool, r1);
    mem_pool_free(pool, r3);

    r4 = mem_pool_alloc(pool, 32);
    printb(pool, r4);

    mem_pool_destroy(pool);
    return 0;
}

void
bridge_addrs(const char *delim, int d)
{
	char dstaddr[NI_MAXHOST];
	char dstport[NI_MAXSERV];
	const int niflag = NI_NUMERICHOST|NI_DGRAM;
	struct ifbaconf ifbac;
	struct ifbareq *ifba;
	char *inbuf = NULL, buf[sizeof(ifba->ifba_ifsname) + 1], *inb;
	struct sockaddr *sa;
	int i, len = 8192;

	/* ifconfig will call us with the argv of the command */
	if (strcmp(delim, "addr") == 0)
		delim = "";

	while (1) {
		ifbac.ifbac_len = len;
		inb = realloc(inbuf, len);
		if (inb == NULL)
			err(1, "malloc");
		ifbac.ifbac_buf = inbuf = inb;
		strlcpy(ifbac.ifbac_name, name, sizeof(ifbac.ifbac_name));
		if (ioctl(s, SIOCBRDGRTS, &ifbac) < 0) {
			if (errno == ENETDOWN)
				return;
			err(1, "%s", name);
		}
		if (ifbac.ifbac_len + sizeof(*ifba) < len)
			break;
		len *= 2;
	}

	for (i = 0; i < ifbac.ifbac_len / sizeof(*ifba); i++) {
		ifba = ifbac.ifbac_req + i;
		strlcpy(buf, ifba->ifba_ifsname, sizeof(buf));
		printf("%s%s %s %u ", delim, ether_ntoa(&ifba->ifba_dst),
		    buf, ifba->ifba_age);
		sa = (struct sockaddr *)&ifba->ifba_dstsa;
		printb("flags", ifba->ifba_flags, IFBAFBITS);
		if (sa->sa_family != AF_UNSPEC &&
		    getnameinfo(sa, sa->sa_len,
		    dstaddr, sizeof(dstaddr),
		    dstport, sizeof(dstport), niflag) == 0)
			printf(" tunnel %s:%s", dstaddr, dstport);
		printf("\n");
	}
	free(inbuf);
}

static void
gre_status(int s)
{
	uint32_t opts = 0;

	ifr.ifr_data = (caddr_t)&opts;
	if (ioctl(s, GREGKEY, &ifr) == 0)
		if (opts != 0)
			printf("\tgrekey: 0x%x (%u)\n", opts, opts);
	opts = 0;
	if (ioctl(s, GREGOPTS, &ifr) != 0 || opts == 0)
		return;
	printb("\toptions", opts, GREBITS);
	putchar('\n');
}

/* load the application program to RAM */
void board_realvieweb::load_prog(char* path_prog)
{
    int fid;

    if (path_prog != NULL) {
        fid = open(path_prog, O_RDONLY);

        if (fid > 0) {
            uint32_t addr = ADDR_PROG;
            uint32_t buff;
            int count;
            bool result;

            do {
                count = read(fid, &buff, 4);
                result = ram->write(buff, addr, 4);
                //result = ram->local_access(true, addr, buff, 4);
                size_prog += count;

                if (result == false) {
                    printb(d_realvieweb, "cannot load program");
                }

                else {
                    addr += 4;
                }

            }
            while (count > 0);
        }

        else {
            printb(d_realvieweb, "cannot load program");
        }
    }
}

void armv7a::arm_add_sp_plus_imm(armv7a_ir& inst)
{
    inst.print_inst("arm_add_sp_plus_imm");
    inst.check(27, 21, B(001 0100));
    inst.check(19, 16, B(1101));

    if(rf.condition_passed(inst.cond()))
    {
        uint32_t s = inst(20);
        uint32_t rd = inst(15, 12);
        bits imm12(inst(11, 0), 12);

        if((rd == B(1111)) && (s == 1))
        {
            printb(d_inst, "arm_add_sp_plus_imm SUBS PC LR");
        }

        uint32_t d = rd;
        bool setflags = s == 1;
        bits imm32;
        arm_expand_imm(&imm32, imm12);
        //ESO
        bits result;
        uint32_t carry;
        uint32_t overflow;
        bits sp(rf.r_read(SP), 32);
        add_with_carry(&result, &carry, &overflow, sp, imm32, 0);
        printd(d_inst, "SP(R%d)=0x%X, imm32=0x%X, result=r%d=0x%X", SP, sp.val, imm32.val, d, result.val);

        if(d == 15)
        {
            rf.alu_write_pc(result.val);
        }

        else
        {
            rf.r_write(d, result.val);

            if(setflags)
            {
                rf.cpsr_N(result(31));
                rf.cpsr_Z(is_zero_bit(result));
                rf.cpsr_C(carry);
                rf.cpsr_V(overflow);
            }
        }
    }
}

static void
print_port(struct cfg *cfg, int port)
{
	etherswitch_port_t p;
	int ifm_ulist[IFMEDIAREQ_NULISTENTRIES];
	int i;

	bzero(&p, sizeof(p));
	p.es_port = port;
	p.es_ifmr.ifm_ulist = ifm_ulist;
	p.es_ifmr.ifm_count = IFMEDIAREQ_NULISTENTRIES;
	if (ioctl(cfg->fd, IOETHERSWITCHGETPORT, &p) != 0)
		err(EX_OSERR, "ioctl(IOETHERSWITCHGETPORT)");
	printf("port%d:\n", port);
	if (cfg->conf.vlan_mode == ETHERSWITCH_VLAN_DOT1Q)
		printf("\tpvid: %d\n", p.es_pvid);
	printb("\tflags", p.es_flags, ETHERSWITCH_PORT_FLAGS_BITS);
	printf("\n");
	if (p.es_nleds) {
		printf("\tled: ");
		for (i = 0; i < p.es_nleds; i++) {
			printf("%d:%s%s", i+1, ledstyles[p.es_led[i]], (i==p.es_nleds-1)?"":" ");
		}
		printf("\n");
	}
	printf("\tmedia: ");
	print_media_word(p.es_ifmr.ifm_current, 1);
	if (p.es_ifmr.ifm_active != p.es_ifmr.ifm_current) {
		putchar(' ');
		putchar('(');
		print_media_word(p.es_ifmr.ifm_active, 0);
		putchar(')');
	}
	putchar('\n');
	printf("\tstatus: %s\n", (p.es_ifmr.ifm_status & IFM_ACTIVE) != 0 ? "active" : "no carrier");
	if (cfg->mediatypes) {
		printf("\tsupported media:\n");
		if (p.es_ifmr.ifm_count > IFMEDIAREQ_NULISTENTRIES)
			p.es_ifmr.ifm_count = IFMEDIAREQ_NULISTENTRIES;
		for (i=0; i<p.es_ifmr.ifm_count; i++) {
			printf("\t\tmedia ");
			print_media_word(ifm_ulist[i], 0);
			putchar('\n');
		}
	}
}

int resolve(char* path)
{
    BOARD b;

    // decode path
    decodepath(path,&b);
    printb(&b);
    // check status

    // analyze next

    // resolve next

    // resolve current

    return 0;
}

void armv7a::arm_swp(armv7a_ir& inst)
{
    inst.print_inst("arm_swp");
    inst.check(27, 23, B(10));
    inst.check(21, 20, 0);
    inst.check(11, 4, B(1001));

    if(rf.condition_passed(inst.cond()))
    {
        uint32_t b = inst(22);
        uint32_t rn = inst(19, 16);
        uint32_t rt = inst(15, 12);
        uint32_t rt2 = inst(3, 0);

        uint32_t t = rt;
        uint32_t t2 = rt2;
        uint32_t n = rn;
        uint32_t size = (b == 1) ? 1 : 4;

        if((t == 15) || (t2 == 15) || (n == t) || (n == t2))
        {
            printb(d_inst, "arm_swp error");
        }

        //ESO

        bits data;
        mem_a_read(&data, rf.r_read(n), size);

        bits _t2(rf.r_read(t2), 8 * size);
        mem_a_write(rf.r_read(n), size, _t2);

        if(size == 1)
        {
            rf.r_write(t, data.val);
        }

        else
        {
            rf.r_write(t, data.val);
        }
    }
}

void
bridge_list(char *delim)
{
	struct ifbreq *reqp;
	struct ifbifconf bifc;
	int i, len = 8192;
	char buf[sizeof(reqp->ifbr_ifsname) + 1], *inbuf = NULL, *inb;

	while (1) {
		bifc.ifbic_len = len;
		inb = realloc(inbuf, len);
		if (inb == NULL)
			err(1, "malloc");
		bifc.ifbic_buf = inbuf = inb;
		strlcpy(bifc.ifbic_name, name, sizeof(bifc.ifbic_name));
		if (ioctl(s, SIOCBRDGIFS, &bifc) < 0)
			err(1, "%s", name);
		if (bifc.ifbic_len + sizeof(*reqp) < len)
			break;
		len *= 2;
	}
	for (i = 0; i < bifc.ifbic_len / sizeof(*reqp); i++) {
		reqp = bifc.ifbic_req + i;
		strlcpy(buf, reqp->ifbr_ifsname, sizeof(buf));
		printf("%s%s ", delim, buf);
		printb("flags", reqp->ifbr_ifsflags, IFBIFBITS);
		printf("\n");
		if (reqp->ifbr_ifsflags & IFBIF_SPAN)
			continue;
		printf("\t\t");
		printf("port %u ifpriority %u ifcost %u",
		    reqp->ifbr_portno, reqp->ifbr_priority,
		    reqp->ifbr_path_cost);
		if (reqp->ifbr_ifsflags & IFBIF_STP)
			printf(" %s role %s",
			    stpstates[reqp->ifbr_state],
			    stproles[reqp->ifbr_role]);
		printf("\n");
		bridge_rules(buf, 0);
	}
	free(bifc.ifbic_buf);
}