src/freedreno/ir3/ir3_print.c - platform/external/mesa3d - Git at Google

 /*
  * Copyright (C) 2014 Rob Clark <robclark@freedesktop.org>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
  * Authors:
  *    Rob Clark <robclark@freedesktop.org>
  */

 #include <stdarg.h>
 #include <stdio.h>

 #include "ir3.h"

 #define PTRID(x) ((unsigned long)(x))

 /* ansi escape sequences: */
 #define RESET	"\x1b[0m"
 #define RED		"\x1b[0;31m"
 #define GREEN	"\x1b[0;32m"
 #define BLUE	"\x1b[0;34m"
 #define MAGENTA	"\x1b[0;35m"

 /* syntax coloring, mostly to make it easier to see different sorts of
  * srcs (immediate, constant, ssa, array, ...)
  */
 #define SYN_REG(x)		RED x RESET
 #define SYN_IMMED(x)	GREEN x RESET
 #define SYN_CONST(x)	GREEN x RESET
 #define SYN_SSA(x)		BLUE x RESET
 #define SYN_ARRAY(x)	MAGENTA x RESET

 static const char *
 type_name(type_t type)
 {
 	static const char *type_names[] = {
 			[TYPE_F16] = "f16",
 			[TYPE_F32] = "f32",
 			[TYPE_U16] = "u16",
 			[TYPE_U32] = "u32",
 			[TYPE_S16] = "s16",
 			[TYPE_S32] = "s32",
 			[TYPE_U8]  = "u8",
 			[TYPE_S8]  = "s8",
 	};
 	return type_names[type];
 }

 static void print_instr_name(struct ir3_instruction *instr, bool flags)
 {
 	if (!instr)
 		return;
 #ifdef DEBUG
 	printf("%04u:", instr->serialno);
 #endif
 	printf("%04u:", instr->name);
 	printf("%04u:", instr->ip);
 	if (instr->flags & IR3_INSTR_UNUSED) {
 		printf("XXX: ");
 	} else {
 		printf("%03u: ", instr->use_count);
 	}

 	if (flags) {
 		printf("\t");
 		if (instr->flags & IR3_INSTR_SY)
 			printf("(sy)");
 		if (instr->flags & IR3_INSTR_SS)
 			printf("(ss)");
 		if (instr->flags & IR3_INSTR_JP)
 			printf("(jp)");
 		if (instr->repeat)
 			printf("(rpt%d)", instr->repeat);
 		if (instr->nop)
 			printf("(nop%d)", instr->nop);
 		if (instr->flags & IR3_INSTR_UL)
 			printf("(ul)");
 	} else {
 		printf(" ");
 	}

 	if (is_meta(instr)) {
 		switch (instr->opc) {
 		case OPC_META_INPUT:  printf("_meta:in");   break;
 		case OPC_META_SPLIT:        printf("_meta:split");        break;
 		case OPC_META_COLLECT:      printf("_meta:collect");      break;
 		case OPC_META_TEX_PREFETCH: printf("_meta:tex_prefetch"); break;

 		/* shouldn't hit here.. just for debugging: */
 		default: printf("_meta:%d", instr->opc);    break;
 		}
 	} else if (instr->opc == OPC_MOV) {
 		if (instr->cat1.src_type == instr->cat1.dst_type)
 			printf("mov");
 		else
 			printf("cov");
 		printf(".%s%s", type_name(instr->cat1.src_type),
 				type_name(instr->cat1.dst_type));
 	} else {
 		printf("%s", ir3_instr_name(instr));
 		if (instr->flags & IR3_INSTR_3D)
 			printf(".3d");
 		if (instr->flags & IR3_INSTR_A)
 			printf(".a");
 		if (instr->flags & IR3_INSTR_O)
 			printf(".o");
 		if (instr->flags & IR3_INSTR_P)
 			printf(".p");
 		if (instr->flags & IR3_INSTR_S)
 			printf(".s");
 		if (instr->flags & IR3_INSTR_A1EN)
 			printf(".a1en");
 		if (instr->opc == OPC_LDC)
 			printf(".offset%d", instr->cat6.d);
 		if (instr->flags & IR3_INSTR_B) {
 			printf(".base%d",
 				   is_tex(instr) ? instr->cat5.tex_base : instr->cat6.base);
 		}
 		if (instr->flags & IR3_INSTR_S2EN)
 			printf(".s2en");

 		static const char *cond[0x7] = {
 				"lt",
 				"le",
 				"gt",
 				"ge",
 				"eq",
 				"ne",
 		};

 		switch (instr->opc) {
 		case OPC_CMPS_F:
 		case OPC_CMPS_U:
 		case OPC_CMPS_S:
 		case OPC_CMPV_F:
 		case OPC_CMPV_U:
 		case OPC_CMPV_S:
 			printf(".%s", cond[instr->cat2.condition & 0x7]);
 			break;
 		default:
 			break;
 		}
 	}
 }

 static void print_reg_name(struct ir3_register *reg)
 {
 	if ((reg->flags & (IR3_REG_FABS | IR3_REG_SABS)) &&
 			(reg->flags & (IR3_REG_FNEG | IR3_REG_SNEG | IR3_REG_BNOT)))
 		printf("(absneg)");
 	else if (reg->flags & (IR3_REG_FNEG | IR3_REG_SNEG | IR3_REG_BNOT))
 		printf("(neg)");
 	else if (reg->flags & (IR3_REG_FABS | IR3_REG_SABS))
 		printf("(abs)");

 	if (reg->flags & IR3_REG_R)
 		printf("(r)");

 	if (reg->flags & IR3_REG_HIGH)
 		printf("H");
 	if (reg->flags & IR3_REG_HALF)
 		printf("h");

 	if (reg->flags & IR3_REG_IMMED) {
 		printf(SYN_IMMED("imm[%f,%d,0x%x]"), reg->fim_val, reg->iim_val, reg->iim_val);
 	} else if (reg->flags & IR3_REG_ARRAY) {
 		printf(SYN_ARRAY("arr[id=%u, offset=%d, size=%u"), reg->array.id,
 				reg->array.offset, reg->size);
 		/* for ARRAY we could have null src, for example first write
 		 * instruction..
 		 */
 		if (reg->instr) {
 			printf(SYN_ARRAY(", "));
 			printf(SYN_SSA("_["));
 			print_instr_name(reg->instr, false);
 			printf(SYN_SSA("]"));
 		}
 		printf(SYN_ARRAY("]"));
 	} else if (reg->flags & IR3_REG_SSA) {
 		printf(SYN_SSA("_["));
 		print_instr_name(reg->instr, false);
 		printf(SYN_SSA("]"));
 	} else if (reg->flags & IR3_REG_RELATIV) {
 		if (reg->flags & IR3_REG_CONST)
 			printf(SYN_CONST("c<a0.x + %d>"), reg->array.offset);
 		else
 			printf(SYN_REG("r<a0.x + %d>")" (%u)", reg->array.offset, reg->size);
 	} else {
 		if (reg->flags & IR3_REG_CONST)
 			printf(SYN_CONST("c%u.%c"), reg_num(reg), "xyzw"[reg_comp(reg)]);
 		else
 			printf(SYN_REG("r%u.%c"), reg_num(reg), "xyzw"[reg_comp(reg)]);
 	}

 	if (reg->wrmask > 0x1)
 		printf(" (wrmask=0x%x)", reg->wrmask);
 }

 static void
 tab(int lvl)
 {
 	for (int i = 0; i < lvl; i++)
 		printf("\t");
 }

 static void
 print_instr(struct ir3_instruction *instr, int lvl)
 {
 	unsigned i;

 	tab(lvl);

 	print_instr_name(instr, true);

 	if (is_tex(instr)) {
 		printf(" (%s)(", type_name(instr->cat5.type));
 		for (i = 0; i < 4; i++)
 			if (instr->regs[0]->wrmask & (1 << i))
 				printf("%c", "xyzw"[i]);
 		printf(")");
 	} else if (instr->regs_count > 0) {
 		printf(" ");
 	}

 	for (i = 0; i < instr->regs_count; i++) {
 		struct ir3_register *reg = instr->regs[i];

 		printf(i ? ", " : "");
 		print_reg_name(reg);
 	}

 	if (is_tex(instr) && !(instr->flags & IR3_INSTR_S2EN)) {
 		if (!!(instr->flags & IR3_INSTR_B)) {
 			if (!!(instr->flags & IR3_INSTR_A1EN)) {
 				printf(", s#%d", instr->cat5.samp);
 			} else {
 				printf(", s#%d, t#%d", instr->cat5.samp & 0xf,
 					   instr->cat5.samp >> 4);
 			}
 		} else {
 			printf(", s#%d, t#%d", instr->cat5.samp, instr->cat5.tex);
 		}
 	}

 	if (instr->address) {
 		printf(", address=_");
 		printf("[");
 		print_instr_name(instr->address, false);
 		printf("]");
 	}

 	if (instr->cp.left) {
 		printf(", left=_");
 		printf("[");
 		print_instr_name(instr->cp.left, false);
 		printf("]");
 	}

 	if (instr->cp.right) {
 		printf(", right=_");
 		printf("[");
 		print_instr_name(instr->cp.right, false);
 		printf("]");
 	}

 	if (instr->opc == OPC_META_SPLIT) {
 		printf(", off=%d", instr->split.off);
 	} else if (instr->opc == OPC_META_TEX_PREFETCH) {
 		printf(", tex=%d, samp=%d, input_offset=%d", instr->prefetch.tex,
 				instr->prefetch.samp, instr->prefetch.input_offset);
 	}

 	if (is_flow(instr) && instr->cat0.target) {
 		/* the predicate register src is implied: */
 		if (instr->opc == OPC_B) {
 			printf("r %sp0.x", instr->cat0.inv ? "!" : "");
 		}
 		printf(", target=block%u", block_id(instr->cat0.target));
 	}

 	if (instr->deps_count) {
 		printf(", false-deps:");
 		for (unsigned i = 0; i < instr->deps_count; i++) {
 			if (i > 0)
 				printf(", ");
 			printf("_[");
 			print_instr_name(instr->deps[i], false);
 			printf("]");
 		}
 	}

 	printf("\n");
 }

 void ir3_print_instr(struct ir3_instruction *instr)
 {
 	print_instr(instr, 0);
 }

 static void
 print_block(struct ir3_block *block, int lvl)
 {
 	tab(lvl); printf("block%u {\n", block_id(block));

 	/* computerator (ir3 assembler) doesn't really use blocks for flow
 	 * control, so block->predecessors will be null.
 	 */
 	if (block->predecessors && block->predecessors->entries > 0) {
 		unsigned i = 0;
 		tab(lvl+1);
 		printf("pred: ");
 		set_foreach (block->predecessors, entry) {
 			struct ir3_block *pred = (struct ir3_block *)entry->key;
 			if (i++)
 				printf(", ");
 			printf("block%u", block_id(pred));
 		}
 		printf("\n");
 	}

 	foreach_instr (instr, &block->instr_list) {
 		print_instr(instr, lvl+1);
 	}

 	tab(lvl+1); printf("/* keeps:\n");
 	for (unsigned i = 0; i < block->keeps_count; i++) {
 		print_instr(block->keeps[i], lvl+2);
 	}
 	tab(lvl+1); printf(" */\n");

 	if (block->successors[1]) {
 		/* leading into if/else: */
 		tab(lvl+1);
 		printf("/* succs: if _[");
 		print_instr_name(block->condition, false);
 		printf("] block%u; else block%u; */\n",
 				block_id(block->successors[0]),
 				block_id(block->successors[1]));
 	} else if (block->successors[0]) {
 		tab(lvl+1);
 		printf("/* succs: block%u; */\n",
 				block_id(block->successors[0]));
 	}
 	tab(lvl); printf("}\n");
 }

 void
 ir3_print(struct ir3 *ir)
 {
 	foreach_block (block, &ir->block_list)
 		print_block(block, 0);

 	foreach_output_n (out, i, ir) {
 		printf("out%d: ", i);
 		print_instr(out, 0);
 	}
 }
	/*
	* Copyright (C) 2014 Rob Clark <robclark@freedesktop.org>
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice (including the next
	* paragraph) shall be included in all copies or substantial portions of the
	* Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	* SOFTWARE.
	*
	* Authors:
	* Rob Clark <robclark@freedesktop.org>
	*/

	#include <stdarg.h>
	#include <stdio.h>

	#include "ir3.h"

	#define PTRID(x) ((unsigned long)(x))

	/* ansi escape sequences: */
	#define RESET "\x1b[0m"
	#define RED "\x1b[0;31m"
	#define GREEN "\x1b[0;32m"
	#define BLUE "\x1b[0;34m"
	#define MAGENTA "\x1b[0;35m"

	/* syntax coloring, mostly to make it easier to see different sorts of
	* srcs (immediate, constant, ssa, array, ...)
	*/
	#define SYN_REG(x) RED x RESET
	#define SYN_IMMED(x) GREEN x RESET
	#define SYN_CONST(x) GREEN x RESET
	#define SYN_SSA(x) BLUE x RESET
	#define SYN_ARRAY(x) MAGENTA x RESET

	static const char *
	type_name(type_t type)
	{
	static const char *type_names[] = {
	[TYPE_F16] = "f16",
	[TYPE_F32] = "f32",
	[TYPE_U16] = "u16",
	[TYPE_U32] = "u32",
	[TYPE_S16] = "s16",
	[TYPE_S32] = "s32",
	[TYPE_U8] = "u8",
	[TYPE_S8] = "s8",
	};
	return type_names[type];
	}

	static void print_instr_name(struct ir3_instruction *instr, bool flags)
	{
	if (!instr)
	return;
	#ifdef DEBUG
	printf("%04u:", instr->serialno);
	#endif
	printf("%04u:", instr->name);
	printf("%04u:", instr->ip);
	if (instr->flags & IR3_INSTR_UNUSED) {
	printf("XXX: ");
	} else {
	printf("%03u: ", instr->use_count);
	}

	if (flags) {
	printf("\t");
	if (instr->flags & IR3_INSTR_SY)
	printf("(sy)");
	if (instr->flags & IR3_INSTR_SS)
	printf("(ss)");
	if (instr->flags & IR3_INSTR_JP)
	printf("(jp)");
	if (instr->repeat)
	printf("(rpt%d)", instr->repeat);
	if (instr->nop)
	printf("(nop%d)", instr->nop);
	if (instr->flags & IR3_INSTR_UL)
	printf("(ul)");
	} else {
	printf(" ");
	}

	if (is_meta(instr)) {
	switch (instr->opc) {
	case OPC_META_INPUT: printf("_meta:in"); break;
	case OPC_META_SPLIT: printf("_meta:split"); break;
	case OPC_META_COLLECT: printf("_meta:collect"); break;
	case OPC_META_TEX_PREFETCH: printf("_meta:tex_prefetch"); break;

	/* shouldn't hit here.. just for debugging: */
	default: printf("_meta:%d", instr->opc); break;
	}
	} else if (instr->opc == OPC_MOV) {
	if (instr->cat1.src_type == instr->cat1.dst_type)
	printf("mov");
	else
	printf("cov");
	printf(".%s%s", type_name(instr->cat1.src_type),
	type_name(instr->cat1.dst_type));
	} else {
	printf("%s", ir3_instr_name(instr));
	if (instr->flags & IR3_INSTR_3D)
	printf(".3d");
	if (instr->flags & IR3_INSTR_A)
	printf(".a");
	if (instr->flags & IR3_INSTR_O)
	printf(".o");
	if (instr->flags & IR3_INSTR_P)
	printf(".p");
	if (instr->flags & IR3_INSTR_S)
	printf(".s");
	if (instr->flags & IR3_INSTR_A1EN)
	printf(".a1en");
	if (instr->opc == OPC_LDC)
	printf(".offset%d", instr->cat6.d);
	if (instr->flags & IR3_INSTR_B) {
	printf(".base%d",
	is_tex(instr) ? instr->cat5.tex_base : instr->cat6.base);
	}
	if (instr->flags & IR3_INSTR_S2EN)
	printf(".s2en");

	static const char *cond[0x7] = {
	"lt",
	"le",
	"gt",
	"ge",
	"eq",
	"ne",
	};

	switch (instr->opc) {
	case OPC_CMPS_F:
	case OPC_CMPS_U:
	case OPC_CMPS_S:
	case OPC_CMPV_F:
	case OPC_CMPV_U:
	case OPC_CMPV_S:
	printf(".%s", cond[instr->cat2.condition & 0x7]);
	break;
	default:
	break;
	}
	}
	}

	static void print_reg_name(struct ir3_register *reg)
	{
	if ((reg->flags & (IR3_REG_FABS \| IR3_REG_SABS)) &&
	(reg->flags & (IR3_REG_FNEG \| IR3_REG_SNEG \| IR3_REG_BNOT)))
	printf("(absneg)");
	else if (reg->flags & (IR3_REG_FNEG \| IR3_REG_SNEG \| IR3_REG_BNOT))
	printf("(neg)");
	else if (reg->flags & (IR3_REG_FABS \| IR3_REG_SABS))
	printf("(abs)");

	if (reg->flags & IR3_REG_R)
	printf("(r)");

	if (reg->flags & IR3_REG_HIGH)
	printf("H");
	if (reg->flags & IR3_REG_HALF)
	printf("h");

	if (reg->flags & IR3_REG_IMMED) {
	printf(SYN_IMMED("imm[%f,%d,0x%x]"), reg->fim_val, reg->iim_val, reg->iim_val);
	} else if (reg->flags & IR3_REG_ARRAY) {
	printf(SYN_ARRAY("arr[id=%u, offset=%d, size=%u"), reg->array.id,
	reg->array.offset, reg->size);
	/* for ARRAY we could have null src, for example first write
	* instruction..
	*/
	if (reg->instr) {
	printf(SYN_ARRAY(", "));
	printf(SYN_SSA("_["));
	print_instr_name(reg->instr, false);
	printf(SYN_SSA("]"));
	}
	printf(SYN_ARRAY("]"));
	} else if (reg->flags & IR3_REG_SSA) {
	printf(SYN_SSA("_["));
	print_instr_name(reg->instr, false);
	printf(SYN_SSA("]"));
	} else if (reg->flags & IR3_REG_RELATIV) {
	if (reg->flags & IR3_REG_CONST)
	printf(SYN_CONST("c<a0.x + %d>"), reg->array.offset);
	else
	printf(SYN_REG("r<a0.x + %d>")" (%u)", reg->array.offset, reg->size);
	} else {
	if (reg->flags & IR3_REG_CONST)
	printf(SYN_CONST("c%u.%c"), reg_num(reg), "xyzw"[reg_comp(reg)]);
	else
	printf(SYN_REG("r%u.%c"), reg_num(reg), "xyzw"[reg_comp(reg)]);
	}

	if (reg->wrmask > 0x1)
	printf(" (wrmask=0x%x)", reg->wrmask);
	}

	static void
	tab(int lvl)
	{
	for (int i = 0; i < lvl; i++)
	printf("\t");
	}

	static void
	print_instr(struct ir3_instruction *instr, int lvl)
	{
	unsigned i;

	tab(lvl);

	print_instr_name(instr, true);

	if (is_tex(instr)) {
	printf(" (%s)(", type_name(instr->cat5.type));
	for (i = 0; i < 4; i++)
	if (instr->regs[0]->wrmask & (1 << i))
	printf("%c", "xyzw"[i]);
	printf(")");
	} else if (instr->regs_count > 0) {
	printf(" ");
	}

	for (i = 0; i < instr->regs_count; i++) {
	struct ir3_register *reg = instr->regs[i];

	printf(i ? ", " : "");
	print_reg_name(reg);
	}

	if (is_tex(instr) && !(instr->flags & IR3_INSTR_S2EN)) {
	if (!!(instr->flags & IR3_INSTR_B)) {
	if (!!(instr->flags & IR3_INSTR_A1EN)) {
	printf(", s#%d", instr->cat5.samp);
	} else {
	printf(", s#%d, t#%d", instr->cat5.samp & 0xf,
	instr->cat5.samp >> 4);
	}
	} else {
	printf(", s#%d, t#%d", instr->cat5.samp, instr->cat5.tex);
	}
	}

	if (instr->address) {
	printf(", address=_");
	printf("[");
	print_instr_name(instr->address, false);
	printf("]");
	}

	if (instr->cp.left) {
	printf(", left=_");
	printf("[");
	print_instr_name(instr->cp.left, false);
	printf("]");
	}

	if (instr->cp.right) {
	printf(", right=_");
	printf("[");
	print_instr_name(instr->cp.right, false);
	printf("]");
	}

	if (instr->opc == OPC_META_SPLIT) {
	printf(", off=%d", instr->split.off);
	} else if (instr->opc == OPC_META_TEX_PREFETCH) {
	printf(", tex=%d, samp=%d, input_offset=%d", instr->prefetch.tex,
	instr->prefetch.samp, instr->prefetch.input_offset);
	}

	if (is_flow(instr) && instr->cat0.target) {
	/* the predicate register src is implied: */
	if (instr->opc == OPC_B) {
	printf("r %sp0.x", instr->cat0.inv ? "!" : "");
	}
	printf(", target=block%u", block_id(instr->cat0.target));
	}

	if (instr->deps_count) {
	printf(", false-deps:");
	for (unsigned i = 0; i < instr->deps_count; i++) {
	if (i > 0)
	printf(", ");
	printf("_[");
	print_instr_name(instr->deps[i], false);
	printf("]");
	}
	}

	printf("\n");
	}

	void ir3_print_instr(struct ir3_instruction *instr)
	{
	print_instr(instr, 0);
	}

	static void
	print_block(struct ir3_block *block, int lvl)
	{
	tab(lvl); printf("block%u {\n", block_id(block));

	/* computerator (ir3 assembler) doesn't really use blocks for flow
	* control, so block->predecessors will be null.
	*/
	if (block->predecessors && block->predecessors->entries > 0) {
	unsigned i = 0;
	tab(lvl+1);
	printf("pred: ");
	set_foreach (block->predecessors, entry) {
	struct ir3_block pred = (struct ir3_block )entry->key;
	if (i++)
	printf(", ");
	printf("block%u", block_id(pred));
	}
	printf("\n");
	}

	foreach_instr (instr, &block->instr_list) {
	print_instr(instr, lvl+1);
	}

	tab(lvl+1); printf("/* keeps:\n");
	for (unsigned i = 0; i < block->keeps_count; i++) {
	print_instr(block->keeps[i], lvl+2);
	}
	tab(lvl+1); printf(" */\n");

	if (block->successors[1]) {
	/* leading into if/else: */
	tab(lvl+1);
	printf("/* succs: if _[");
	print_instr_name(block->condition, false);
	printf("] block%u; else block%u; */\n",
	block_id(block->successors[0]),
	block_id(block->successors[1]));
	} else if (block->successors[0]) {
	tab(lvl+1);
	printf("/* succs: block%u; */\n",
	block_id(block->successors[0]));
	}
	tab(lvl); printf("}\n");
	}

	void
	ir3_print(struct ir3 *ir)
	{
	foreach_block (block, &ir->block_list)
	print_block(block, 0);

	foreach_output_n (out, i, ir) {
	printf("out%d: ", i);
	print_instr(out, 0);
	}
	}