Esempio n. 1
0
TypeSpec
ASTunary_expression::typecheck (TypeSpec expected)
{
    // FIXME - closures
    typecheck_children (expected);
    TypeSpec t = expr()->typespec();
    if (t.is_structure()) {
        error ("Can't do '%s' to a %s.", opname(), type_c_str(t));
        return TypeSpec ();
    }
    switch (m_op) {
    case Sub :
    case Add :
        if (t.is_string()) {
            error ("Can't do '%s' to a %s.", opname(), type_c_str(t));
            return TypeSpec ();
        }
        m_typespec = t;
        break;
    case Not :
        m_typespec = TypeDesc::TypeInt;  // ! is always an int
        break;
    case Compl :
        if (! t.is_int()) {
            error ("Operator '~' can only be done to an int");
            return TypeSpec ();
        }
        m_typespec = t;
        break;
    default:
        error ("unknown unary operator");
    }
    return m_typespec;
}
Esempio n. 2
0
void
ASTNode::print (std::ostream &out, int indentlevel) const 
{
    indent (out, indentlevel);
    out << "(" << nodetypename() << " : " 
        << "    (type: " << typespec().string() << ") "
        << (opname() ? opname() : "") << "\n";
    printchildren (out, indentlevel);
    indent (out, indentlevel);
    out << ")\n";
}
Esempio n. 3
0
void ast_node_dump(const ast_node n)
{
	if (!n)
		return;

	switch (n->type) {
	case N_2OP:
		printf(" (%s", opname(n->op));
		ast_node_dump(n->left);
		ast_node_dump(n->right);
		printf(")");
		return;
	case N_NUM:
		printf(" %ld", n->num);
		return;
	case N_VAR:
		printf(" %s", n->id);
		return;
	case N_COND:
		printf(" (if");
		ast_node_dump(n->left); /* condition */
		ast_node_dump(n->arg[0]); /* true case */
		ast_node_dump(n->arg[1]); /* false case */
		printf(")");
		return;
	}

	printf("ERROR\n");
}
Esempio n. 4
0
void IRPrinter::visitBinop(Binop *e)
{
    *out << opname(e->op) << ' ';
    visit(e->left);
    *out << ", ";
    visit(e->right);
}
Esempio n. 5
0
File: dump.c Progetto: 99years/plan9
void
nbnsdumpmessage(NbnsMessage *s)
{
	NbnsMessageQuestion *q;
	NbnsMessageResource *r;
	print("0x%.4ux %s %s (%d)",
		s->id, opname(s->opcode), s->response ? "response" : "request", s->opcode);
	if (s->broadcast)
		print(" B");
	if (s->recursionavailable)
		print(" RA");
	if (s->recursiondesired)
		print(" RD");
	if (s->truncation)
		print(" TC");
	if (s->authoritativeanswer)
		print(" AA");
	if (s->response)
		print(" rcode %d", s->rcode);
	print("\n");
	for (q = s->q; q; q = q->next)
		nbnsdumpmessagequestion(q);
	for (r = s->an; r; r = r->next)
		nbnsdumpmessageresource(r, "answer");
	for (r = s->ns; r; r = r->next)
		nbnsdumpmessageresource(r, "ns");
	for (r = s->ar; r; r = r->next)
		nbnsdumpmessageresource(r, "additional");
}
Esempio n. 6
0
File: tree.c Progetto: UraKn0x/gbdk
/* printtree1 - recursively print tree p */
static void printtree1(Tree p, int fd, int lev) {
	FILE *f = fd == 1 ? stdout : stderr;
	int i;
	static char blanks[] = "                                                   ";

	if (p == 0 || *printed(i = nodeid(p)))
		return;
	fprint(f, "#%d%S%S", i, blanks, i < 10 ? 2 : i < 100 ? 1 : 0, blanks, lev);
	fprint(f, "%s %t", opname(p->op), p->type);
	*printed(i) = 1;
	for (i = 0; i < NELEMS(p->kids); i++)
		if (p->kids[i])
			fprint(f, " #%d", nodeid(p->kids[i]));
	if (p->op == FIELD && p->u.field)
		fprint(f, " %s %d..%d", p->u.field->name,
			fieldsize(p->u.field) + fieldright(p->u.field), fieldright(p->u.field));
	else if (generic(p->op) == CNST)
		fprint(f, " %s", vtoa(p->type, p->u.v));
	else if (p->u.sym)
		fprint(f, " %s", p->u.sym->name);
	if (p->node)
		fprint(f, " node=%p", p->node);
	fprint(f, "\n");
	for (i = 0; i < NELEMS(p->kids); i++)
		printtree1(p->kids[i], fd, lev + 1);
}
Esempio n. 7
0
static void fuse_ll_process(void *data, const char *buf, size_t len,
                     struct fuse_chan *ch)
{
    struct fuse_ll *f = (struct fuse_ll *) data;
    struct fuse_in_header *in = (struct fuse_in_header *) buf;
    const void *inarg = buf + sizeof(struct fuse_in_header);
    struct fuse_req *req;

    /* Foxconn removed start pling 06/19/2009 */
#if 0
    if (f->debug)
        fprintf(stderr, "unique: %llu, opcode: %s (%i), nodeid: %lu, insize: %zu\n",
                (unsigned long long) in->unique,
                opname((enum fuse_opcode) in->opcode), in->opcode,
                (unsigned long) in->nodeid, len);
#endif
    /* Foxconn removed end pling 06/19/2009 */

    req = (struct fuse_req *) calloc(1, sizeof(struct fuse_req));
    if (req == NULL) {
        fprintf(stderr, "fuse: failed to allocate request\n");
        return;
    }

    req->f = f;
    req->unique = in->unique;
    req->ctx.uid = in->uid;
    req->ctx.gid = in->gid;
    req->ctx.pid = in->pid;
    req->ch = ch;
    req->ctr = 1;
    list_init_req(req);
    fuse_mutex_init(&req->lock);

    if (!f->got_init && in->opcode != FUSE_INIT)
        fuse_reply_err(req, EIO);
    else if (f->allow_root && in->uid != f->owner && in->uid != 0 &&
             in->opcode != FUSE_INIT && in->opcode != FUSE_READ &&
             in->opcode != FUSE_WRITE && in->opcode != FUSE_FSYNC &&
             in->opcode != FUSE_RELEASE && in->opcode != FUSE_READDIR &&
             in->opcode != FUSE_FSYNCDIR && in->opcode != FUSE_RELEASEDIR) {
        fuse_reply_err(req, EACCES);
    } else if (in->opcode >= FUSE_MAXOP || !fuse_ll_ops[in->opcode].func)
        fuse_reply_err(req, ENOSYS);
    else {
        if (in->opcode != FUSE_INTERRUPT) {
            struct fuse_req *intr;
            pthread_mutex_lock(&f->lock);
            intr = check_interrupt(f, req);
            list_add_req(req, &f->list);
            pthread_mutex_unlock(&f->lock);
            if (intr)
                fuse_reply_err(intr, EAGAIN);
        }
        fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
    }
}
Esempio n. 8
0
TypeSpec
ASTloop_statement::typecheck (TypeSpec expected)
{
    typecheck_list (init ());
    oslcompiler->push_nesting (true);
    typecheck_list (cond ());
    typecheck_list (iter ());
    typecheck_list (stmt ());
    oslcompiler->pop_nesting (true);

    TypeSpec c = cond()->typespec();
    if (c.is_closure())
        error ("Cannot use a closure as an '%s' condition", opname());
    if (c.is_structure())
        error ("Cannot use a struct as an '%s' condition", opname());
    if (c.is_array())
        error ("Cannot use an array as an '%s' condition", opname());
    return m_typespec = TypeDesc (TypeDesc::NONE);
}
Esempio n. 9
0
static int getrule(Node p, int nt) {
	int rulenum;

	assert(p);
	rulenum = (*IR->x._rule)(p->x.state, nt);
	if (!rulenum) {
		fprint(stderr, "(%x->op=%s at %w is corrupt.)\n", p, opname(p->op), &src);
		assert(0);
	}
	return rulenum;
}
Esempio n. 10
0
  void moduleInit() override {
    HHVM_ME(MCRouter, __construct);

    HHVM_NAMED_ME(MCRouter, get,  mcr_str<mc_op_get>);
    HHVM_NAMED_ME(MCRouter, gets, mcr_str<mc_op_gets>);

    HHVM_NAMED_ME(MCRouter, add, mcr_set<mc_op_add>);
    HHVM_NAMED_ME(MCRouter, set, mcr_set<mc_op_set>);
    HHVM_NAMED_ME(MCRouter, replace, mcr_set<mc_op_replace>);
    HHVM_NAMED_ME(MCRouter, prepend, mcr_aprepend<mc_op_prepend>);
    HHVM_NAMED_ME(MCRouter, append, mcr_aprepend<mc_op_append>);

    HHVM_NAMED_ME(MCRouter, incr, mcr_str_delta<mc_op_incr>);
    HHVM_NAMED_ME(MCRouter, decr, mcr_str_delta<mc_op_decr>);

    HHVM_NAMED_ME(MCRouter, del, mcr_str<mc_op_delete>);
    HHVM_NAMED_ME(MCRouter, flushAll, mcr_int<mc_op_flushall>);

    HHVM_NAMED_ME(MCRouter, version, mcr_void<mc_op_version>);

    HHVM_ME(MCRouter, cas);

    Native::registerNativeDataInfo<MCRouter>(s_MCRouter.get());

    HHVM_STATIC_ME(MCRouter, getOpName);
    HHVM_STATIC_ME(MCRouter, getResultName);

    std::string opname("mc_op_");
    for (int i = 0; i < mc_nops; ++i) {
      std::string name;
      name = opname + mc_op_to_string((mc_op_t)i);
      // mcrouter defines op names as foo-bar,
      // but PHP wants constants like foo_bar
      for (int j = opname.size(); j < name.size(); ++j) {
        if (name[j] == '-') {
          name[j] = '_';
        }
      }
      Native::registerClassConstant<KindOfInt64>(
        s_MCRouter.get(),
        makeStaticString(name),
        i);
    }
    for (int i = 0; i < mc_nres; ++i) {
      Native::registerClassConstant<KindOfInt64>(
        s_MCRouter.get(),
        makeStaticString(mc_res_to_string((mc_res_t)i)),
        i);
    }

    loadSystemlib();
  }
Esempio n. 11
0
/* {{{ dump_op
 */
static void dump_op(zend_op_array *op_array, zend_op *opi, int num, zend_uint base_address)
{
    unsigned int flags, op1_type, op2_type, res_type;
    char *op_result = NULL;
    char *op_op1 = NULL;
    char *op_op2 = NULL;

    TSRMLS_FETCH();

    /* EXT_STMT */
    if (opi->opcode == 101) {
        fprintf(PVT_G(log_file_path), "\t<tr class=\"s\">");
    } else {
        fprintf(PVT_G(log_file_path), "\t<tr>");
    }

    fprintf(PVT_G(log_file_path),
        "<td>%d</td><td>%d</td><td title=\"%d\" class=\"wz\">%s</td>",
        num, opi->lineno, opi->opcode, opname(opi->opcode)
    );

    if (!(opi->PVT_EXTENDED_VALUE(result) & EXT_TYPE_UNUSED)) {
        op_result = format_znode(&opi->result, base_address);
        fprintf(PVT_G(log_file_path),
            "<td>%s</td>", op_result
        );
        if (op_result) {
            efree(op_result);
        }
    } else {
        fprintf(PVT_G(log_file_path), "<td></td>");
    }

    op_op1 = format_znode(&opi->op1, base_address);
    fprintf(PVT_G(log_file_path),
        "<td>%s</td>", op_op1
    );

    if (op_op1) {
        efree(op_op1);
    }

    op_op2 = format_znode(&opi->op2, base_address);
    fprintf(PVT_G(log_file_path),
        "<td>%s</td></tr>\n", op_op2
    );
    if (op_op2) {
        efree(op_op2);
    }
}
Esempio n. 12
0
void dump_op(zend_op *op, int num){
	static char buffer_op1[BUFFER_LEN];
	static char buffer_op2[BUFFER_LEN];
	static char buffer_result[BUFFER_LEN];
    format_znode(&op->op1, buffer_op1);
    format_znode(&op->op2, buffer_op2);
    format_znode(&op->result, buffer_result);
	printf("%6d|%6d|%20s|%50s|%10s|%10s|%6s|\n", num, op->lineno,
			opname(op->opcode),
            get_handler(op),
			buffer_op1,
			buffer_op2,
			buffer_result
            ) ;
}
Esempio n. 13
0
File: svg.c Progetto: Melab/gvmt
char* getNodeText(Node p) {
    switch (generic(p->op)) {
    case LABEL:
        return stringf("LABEL %s", p->syms[0]->x.name);
    case ADDRL:
        if (isdigit(p->syms[0]->name[0]))
            return stringf("ADDRL t%s", p->syms[0]->name);
        else
            return stringf("ADDRL %s", p->syms[0]->name);
    case ADDRG:
        return stringf("ADDRG %s", p->syms[0]->x.name);
    case ADDRF:
        return stringf("ADDRF %s", p->syms[0]->name);
    case EQ:
        return stringf("BREQ %s", p->syms[0]->x.name);
    case NE:
        return stringf("BRNE %s", p->syms[0]->x.name);
    case LT:
        return stringf("BRLT %s", p->syms[0]->x.name);
    case GT:
        return stringf("BRGT %s", p->syms[0]->x.name);
    case LE:
        return stringf("BRLE %s", p->syms[0]->x.name);
    case GE:
        return stringf("BRGE %s", p->syms[0]->x.name);
    case CNST:
        if (optype(p->op) == I)
            return stringf("CNST %d", p->syms[0]->u.c.v.i);
        else if (optype(p->op) == U)
            return stringf("CNST %u", p->syms[0]->u.c.v.u);
        else
            return opname(p->op);
    default:   
        return opname(p->op);
    }
}
Esempio n. 14
0
TypeSpec
ASTassign_expression::typecheck (TypeSpec expected)
{
    TypeSpec vt = var()->typecheck ();
    TypeSpec et = expr()->typecheck (vt);

    if (! var()->is_lvalue()) {
        error ("Can't assign via %s to something that isn't an lvalue", opname());
        return TypeSpec();
    }

    ASSERT (m_op == Assign);  // all else handled by binary_op

    // We don't currently support assignment of whole arrays
    if (vt.is_array() || et.is_array()) {
        error ("Can't assign entire arrays");
        return TypeSpec();
    }

    // Special case: ok to assign a literal 0 to a closure to
    // initialize it.
    if (vt.is_closure() && ! et.is_closure() &&
        (et.is_float() || et.is_int()) &&
        expr()->nodetype() == literal_node &&
        ((ASTliteral *)&(*expr()))->floatval() == 0.0f) {
        return TypeSpec(); // it's ok
    }

    // If either argument is a structure, they better both be the same
    // exact kind of structure.
    if (vt.is_structure() || et.is_structure()) {
        int vts = vt.structure(), ets = et.structure();
        if (vts == ets)
            return m_typespec = vt;
        // Otherwise, a structure mismatch
        error ("Cannot assign '%s' to '%s'", type_c_str(et), type_c_str(vt));
        return TypeSpec();
    }

    // Expression must be of a type assignable to the lvalue
    if (! assignable (vt, et)) {
        error ("Cannot assign '%s' to '%s'", type_c_str(et), type_c_str(vt));
        // FIXME - can we print the variable in question?
        return TypeSpec();
    }

    return m_typespec = vt;
}
Esempio n. 15
0
static void dumptree(Node p) {
	if (p->op == VREG+P && p->syms[0]) {
		fprint(stderr, "VREGP(%s)", p->syms[0]->name);
		return;
	} else if (generic(p->op) == LOAD) {
		fprint(stderr, "LOAD(");
		dumptree(p->kids[0]);
		fprint(stderr, ")");
		return;
	}
	fprint(stderr, "%s(", opname(p->op));
	switch (generic(p->op)) {
	case CNST: case LABEL:
	case ADDRG: case ADDRF: case ADDRL:
		if (p->syms[0])
			fprint(stderr, "%s", p->syms[0]->name);
		break;
	case RET:
		if (p->kids[0])
			dumptree(p->kids[0]);
		break;
	case CVF: case CVI: case CVP: case CVU: case JUMP: 
	case ARG: case BCOM: case NEG: case INDIR:
		dumptree(p->kids[0]);
		break;
	case CALL:
		if (optype(p->op) != B) {
			dumptree(p->kids[0]);
			break;
		}
		/* else fall thru */
	case EQ: case NE: case GT: case GE: case LE: case LT:
	case ASGN: case BOR: case BAND: case BXOR: case RSH: case LSH:
	case ADD: case SUB:  case DIV: case MUL: case MOD:
		dumptree(p->kids[0]);
		fprint(stderr, ", ");
		dumptree(p->kids[1]);
		break;
	default: assert(0);
	}
	fprint(stderr, ")");
}
void Unop::dump(QTextStream &out)
{
    out << opname(op);
    expr->dump(out);
}
void Binop::dump(QTextStream &out)
{
    left->dump(out);
    out << ' ' << opname(op) << ' ';
    right->dump(out);
}
void fimg2d_debug_command(struct fimg2d_bltcmd *cmd)
{
    int i;
    struct fimg2d_param *p = &cmd->blt.param;
    struct fimg2d_image *img;
    struct fimg2d_rect *r;
    struct fimg2d_dma *c;

    if (WARN_ON(!cmd->ctx))
        return;

    pr_info("\n[%s] ctx: %p seq_no(%u)\n", __func__, cmd->ctx, cmd->blt.seq_no);
    pr_info(" op: %s(%d)\n", opname(cmd->blt.op), cmd->blt.op);
    pr_info(" solid color: 0x%lx\n", p->solid_color);
    pr_info(" g_alpha: 0x%x\n", p->g_alpha);
    pr_info(" premultiplied: %d\n", p->premult);
    if (p->dither)
        pr_info(" dither: %d\n", p->dither);
    if (p->rotate)
        pr_info(" rotate: %d\n", p->rotate);
    if (p->repeat.mode) {
        pr_info(" repeat: %d, pad color: 0x%lx\n",
                p->repeat.mode, p->repeat.pad_color);
    }
    if (p->bluscr.mode) {
        pr_info(" bluescreen mode: %d, bs_color: 0x%lx " \
                "bg_color: 0x%lx\n",
                p->bluscr.mode, p->bluscr.bs_color,
                p->bluscr.bg_color);
    }
    if (p->scaling.mode) {
        pr_info(" scaling %d, s:%d,%d d:%d,%d\n",
                p->scaling.mode,
                p->scaling.src_w, p->scaling.src_h,
                p->scaling.dst_w, p->scaling.dst_h);
    }
    if (p->clipping.enable) {
        pr_info(" clipping LT(%d,%d) RB(%d,%d) WH(%d,%d)\n",
                p->clipping.x1, p->clipping.y1,
                p->clipping.x2, p->clipping.y2,
                rect_w(&p->clipping), rect_h(&p->clipping));
    }

    for (i = 0; i < MAX_IMAGES; i++) {
        img = &cmd->image[i];
        r = &img->rect;

        if (!img->addr.type)
            continue;

        pr_info(" %s type: %d addr: 0x%lx\n",
                imagename(i), img->addr.type, img->addr.start);

        pr_info(" %s width: %d height: %d " \
                "stride: %d order: %d format: %s(%d)\n",
                imagename(i), img->width, img->height,
                img->stride, img->order,
                cfname(img->fmt), img->fmt);
        pr_info(" %s rect LT(%d,%d) RB(%d,%d) WH(%d,%d)\n",
                imagename(i), r->x1, r->y1, r->x2, r->y2,
                rect_w(r), rect_h(r));

        c = &cmd->dma[i].base;
        if (c->size) {
            pr_info(" %s dma base addr: 0x%lx " \
                    "size: 0x%x cached: 0x%x\n",
                    imagename(i), c->addr, c->size,
                    c->cached);
        }

        if (img->plane2.type) {
            pr_info(" %s plane2 type: %d addr: 0x%lx\n",
                    imagename(i), img->plane2.type,
                    img->plane2.start);
        }

        c = &cmd->dma[i].plane2;
        if (c->size) {
            pr_info(" %s dma plane2 addr: 0x%lx " \
                    "size: 0x%x cached: 0x%x\n",
                    imagename(i), c->addr, c->size,
                    c->cached);
        }
    }

    if (cmd->dma_all)
        pr_info(" dma size all: 0x%x bytes\n", cmd->dma_all);

    pr_info(" L1: 0x%x L2: 0x%x bytes\n", L1_CACHE_SIZE, L2_CACHE_SIZE);
}
Esempio n. 19
0
TypeSpec
ASTbinary_expression::typecheck (TypeSpec expected)
{
    typecheck_children (expected);
    TypeSpec l = left()->typespec();
    TypeSpec r = right()->typespec();

    // No binary ops work on structs or arrays
    if (l.is_structure() || r.is_structure() || l.is_array() || r.is_array()) {
        error ("Not allowed: '%s %s %s'",
               type_c_str(l), opname(), type_c_str(r));
        return TypeSpec ();
    }

    // Special for closures -- just a few cases to worry about
    if (l.is_color_closure() || r.is_color_closure()) {
        if (m_op == Add) {
            if (l.is_color_closure() && r.is_color_closure())
                return m_typespec = l;
        }
        if (m_op == Mul) {
            if (l.is_color_closure() && (r.is_color() || r.is_int_or_float()))
                return m_typespec = l;
            if (r.is_color_closure() && (l.is_color() || l.is_int_or_float())) {
                // N.B. Reorder so that it's always r = closure * k,
                // not r = k * closure.  See codegen for why this helps.
                std::swap (m_children[0], m_children[1]);
                return m_typespec = r;
            }
        }
        // If we got this far, it's an op that's not allowed
        error ("Not allowed: '%s %s %s'",
               type_c_str(l), opname(), type_c_str(r));
        return TypeSpec ();
    }

    switch (m_op) {
    case Sub :
    case Add :
    case Mul :
    case Div :
        // Add/Sub/Mul/Div work for any equivalent types, and
        // combination of int/float and other numeric types, but do not
        // work with strings.  Add/Sub don't work with matrices, but
        // Mul/Div do.
        // FIXME -- currently, equivalent types combine to make the
        // left type.  But maybe we should be more careful, for example
        // point-point -> vector, etc.
        if (l.is_string() || r.is_string())
            break;   // Dispense with strings trivially
        if ((m_op == Sub || m_op == Add) && (l.is_matrix() || r.is_matrix()))
            break;   // Matrices don't combine for + and -
        if (equivalent (l, r) ||
                (l.is_numeric() && r.is_int_or_float()) ||
                (l.is_int_or_float() && r.is_numeric()))
            return m_typespec = higherprecision (l.simpletype(), r.simpletype());
        break;

    case Mod :
        // Mod only works with ints, and return ints.
        if (l.is_int() && r.is_int())
            return m_typespec = TypeDesc::TypeInt;
        break;

    case Equal :
    case NotEqual :
        // Any equivalent types can be compared with == and !=, also a 
        // float or int can be compared to any other numeric type.
        // Result is always an int.
        if (equivalent (l, r) || 
              (l.is_numeric() && r.is_int_or_float()) ||
              (l.is_int_or_float() && r.is_numeric()))
            return m_typespec = TypeDesc::TypeInt;
        break;

    case Greater :
    case Less :
    case GreaterEqual :
    case LessEqual :
        // G/L comparisons only work with floats or ints, and always
        // return int.
        if (l.is_int_or_float() && r.is_int_or_float())
            return m_typespec = TypeDesc::TypeInt;
        break;

    case BitAnd :
    case BitOr :
    case Xor :
    case ShiftLeft :
    case ShiftRight :
        // Bitwise ops only work with ints, and return ints.
        if (l.is_int() && r.is_int())
            return m_typespec = TypeDesc::TypeInt;
        break;

    case And :
    case Or :
        // Logical ops work on any simple type (since they test for
        // nonzeroness), but always return int.
        return m_typespec = TypeDesc::TypeInt;

    default:
        error ("unknown binary operator");
    }

    // If we got this far, it's an op that's not allowed
    error ("Not allowed: '%s %s %s'",
           type_c_str(l), opname(), type_c_str(r));
    return TypeSpec ();
}
Esempio n. 20
0
void fimg2d_debug_command(struct fimg2d_bltcmd *cmd)
{
	int i;
	struct fimg2d_blit *blt;
	struct fimg2d_image *img;
	struct fimg2d_param *p;
	struct fimg2d_rect *r;
	struct fimg2d_dma *c;

	if (WARN_ON(!cmd->ctx))
		return;

	blt = &cmd->blt;

	/* Common information */
	pr_info("\n[%s] ctx: %p seq_no(%u)\n", __func__,
				cmd->ctx, cmd->blt.seq_no);
	pr_info(" use fence: %d\n", blt->use_fence);
	pr_info(" Update layer : 0x%lx\n", cmd->src_flag);
	if (blt->dither)
		pr_info(" dither: %d\n", blt->dither);
	/* End of common information */

	/* Source information */
	for (i = 0; i < MAX_SRC; i++) {
		img = &cmd->image_src[i];
		if (!img->addr.type)
			continue;

		p = &img->param;
		r = &img->rect;
		c = &cmd->dma_src[i].base;

		pr_info(" SRC[%d] op: %s(%d)\n",
				i, opname(img->op), img->op);
		pr_info(" SRC[%d] type: %d addr: 0x%lx\n",
				i, img->addr.type, img->addr.start);
		pr_info(" SRC[%d] width: %d height: %d ",
				i, img->width, img->height);
		pr_info(" SRC[%d] stride: %d order: %d format: %s(%d)\n",
				i, img->stride, img->order,
				cfname(img->fmt), img->fmt);
		pr_info(" SRC[%d] rect LT(%d,%d) RB(%d,%d) WH(%d,%d)\n",
				i, r->x1, r->y1, r->x2, r->y2,
				rect_w(r), rect_h(r));

		pr_info(" solid color: 0x%lx\n", p->solid_color);
		pr_info(" g_alpha: 0x%x\n", p->g_alpha);
		pr_info(" premultiplied: %d\n", p->premult);

		if (p->rotate)
			pr_info(" rotate: %d\n", p->rotate);
		if (p->repeat.mode) {
			pr_info(" repeat: %d, pad color: 0x%lx\n",
					p->repeat.mode, p->repeat.pad_color);
		}
		if (p->scaling.mode) {
			pr_info(" scaling %d, s:%d,%d d:%d,%d\n",
					p->scaling.mode,
					p->scaling.src_w, p->scaling.src_h,
					p->scaling.dst_w, p->scaling.dst_h);
		}
		if (p->clipping.enable) {
			pr_info(" clipping LT(%d,%d) RB(%d,%d) WH(%d,%d)\n",
					p->clipping.x1, p->clipping.y1,
					p->clipping.x2, p->clipping.y2,
					rect_w(&p->clipping),
					rect_h(&p->clipping));
		}

		if (c->size) {
			pr_info(" SRC[%d] dma base addr: %#lx size: %zd cached: %zd\n",
					i, c->addr, c->size, c->cached);
			pr_info(" SRC[%d] dma iova: %#lx, offset: %zd\n",
					i, (unsigned long)c->iova, c->offset);
		}

	}
	/* End of source information */

	/* Destination information */
	img = &cmd->image_dst;

	p = &img->param;
	r = &img->rect;
	c = &cmd->dma_dst.base;

	pr_info(" DST type: %d addr: 0x%lx\n",
			img->addr.type, img->addr.start);
	pr_info(" DST width: %d height: %d stride: %d order: %d format: %s(%d)\n",
			img->width, img->height, img->stride, img->order,
			cfname(img->fmt), img->fmt);
	pr_info(" DST rect LT(%d,%d) RB(%d,%d) WH(%d,%d)\n",
			r->x1, r->y1, r->x2, r->y2,
			rect_w(r), rect_h(r));

	pr_info(" solid color: 0x%lx\n", p->solid_color);
	pr_info(" g_alpha: 0x%x\n", p->g_alpha);
	pr_info(" premultiplied: %d\n", p->premult);

	if (c->size) {
		pr_info(" DST dma base addr: %#lx size: %zd cached: %zd\n",
				c->addr, c->size, c->cached);
		pr_info(" DST dma iova: %#lx offset: %zd\n",
				(unsigned long)c->iova, c->offset);
	}
	/* End of destination */

	if (cmd->dma_all)
		pr_info(" dma size all: %zd bytes\n", cmd->dma_all);
}
Esempio n. 21
0
static void dumptree(Node p) {
    switch (specific(p->op)) {
    case ASGN+B:
        assert(p->kids[0]);
        assert(p->kids[1]);
        assert(p->syms[0]);
        dumptree(p->kids[0]);
        dumptree(p->kids[1]);
        print("%s %d\n", opname(p->op), p->syms[0]->u.c.v.u);
        return;
    case RET+V:
        assert(!p->kids[0]);
        assert(!p->kids[1]);
        print("%s\n", opname(p->op));
        return;
    }
    switch (generic(p->op)) {
    case CNST:
    case ADDRG:
    case ADDRF:
    case ADDRL:
    case LABEL:
        assert(!p->kids[0]);
        assert(!p->kids[1]);
        assert(p->syms[0] && p->syms[0]->x.name);
        print("%s %s\n", opname(p->op), p->syms[0]->x.name);
        return;
    case CVF:
    case CVI:
    case CVP:
    case CVU:
        assert(p->kids[0]);
        assert(!p->kids[1]);
        assert(p->syms[0]);
        dumptree(p->kids[0]);
        print("%s %d\n", opname(p->op), p->syms[0]->u.c.v.i);
        return;
    case ARG:
    case BCOM:
    case NEG:
    case INDIR:
    case JUMP:
    case RET:
        assert(p->kids[0]);
        assert(!p->kids[1]);
        dumptree(p->kids[0]);
        print("%s\n", opname(p->op));
        return;
    case CALL:
        assert(p->kids[0]);
        assert(!p->kids[1]);
        assert(optype(p->op) != B);
        dumptree(p->kids[0]);
        print("%s\n", opname(p->op));
        return;
    case ASGN:
    case BOR:
    case BAND:
    case BXOR:
    case RSH:
    case LSH:
    case ADD:
    case SUB:
    case DIV:
    case MUL:
    case MOD:
        assert(p->kids[0]);
        assert(p->kids[1]);
        dumptree(p->kids[0]);
        dumptree(p->kids[1]);
        print("%s\n", opname(p->op));
        return;
    case EQ:
    case NE:
    case GT:
    case GE:
    case LE:
    case LT:
        assert(p->kids[0]);
        assert(p->kids[1]);
        assert(p->syms[0]);
        assert(p->syms[0]->x.name);
        dumptree(p->kids[0]);
        dumptree(p->kids[1]);
        print("%s %s\n", opname(p->op), p->syms[0]->x.name);
        return;
    }
    assert(0);
}
Esempio n. 22
0
void IRPrinter::visitUnop(Unop *e)
{
    *out << opname(e->op) << ' ';
    visit(e->expr);
}