;;
esac
+PKG_CHECK_MODULES([TALLOC], [talloc])
+
dnl
dnl Driver specific build directories
dnl
AC_SUBST([GL_PC_LIB_PRIV])
AC_SUBST([GL_PC_CFLAGS])
AC_SUBST([DRI_PC_REQ_PRIV])
- AC_SUBST([GLESv1_LIB_DEPS])
+ AC_SUBST([GLESv1_CM_LIB_DEPS])
AC_SUBST([GLESv1_CM_PC_LIB_PRIV])
AC_SUBST([GLESv2_LIB_DEPS])
AC_SUBST([GLESv2_PC_LIB_PRIV])
[AC_MSG_ERROR([Expat required for DRI.])])
# put all the necessary libs together
- DRI_LIB_DEPS="$SELINUX_LIBS $LIBDRM_LIBS $EXPAT_LIB -lm -lpthread $DLOPEN_LIBS"
+ DRI_LIB_DEPS="$SELINUX_LIBS $LIBDRM_LIBS $EXPAT_LIB -lm -lpthread $DLOPEN_LIBS $TALLOC_LIBS"
fi
AC_SUBST([DRI_DIRS])
AC_SUBST([EXPAT_INCLUDES])
#include "main/glheader.h"
#include "main/config.h"
- #include "main/compiler.h"
#include "main/mfeatures.h"
#include "glapi/glapi.h"
#include "math/m_matrix.h" /* GLmatrix */
/** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */
gl_texture_index SamplerTargets[MAX_SAMPLERS];
+ /** Bitmask of which register files are read/written with indirect
+ * addressing. Mask of (1 << PROGRAM_x) bits.
+ */
+ GLbitfield IndirectRegisterFiles;
+
/** Logical counts */
/*@{*/
GLuint NumInstructions;
struct gl_program *Program; /**< Post-compile assembly code */
GLchar *InfoLog;
struct gl_sl_pragmas Pragmas;
+
+ unsigned Version; /**< GLSL version used for linking */
+
+ struct exec_list *ir;
+ struct glsl_symbol_table *symbols;
+
+ /** Shaders containing built-in functions that are used for linking. */
+ struct gl_shader *builtins_to_link[16];
+ unsigned num_builtins_to_link;
};
GLboolean Validated;
GLboolean _Used; /**< Ever used for drawing? */
GLchar *InfoLog;
+
+ unsigned Version; /**< GLSL version used for linking */
+
+ /**
+ * Per-stage shaders resulting from the first stage of linking.
+ */
+ /*@{*/
+ GLuint _NumLinkedShaders;
+ struct gl_shader *_LinkedShaders[2];
+ /*@}*/
};
GLboolean EmitCondCodes; /**< Use condition codes? */
GLboolean EmitComments; /**< Annotated instructions */
GLboolean EmitNVTempInitialization; /**< 0-fill NV temp registers */
+ /**
+ * Attempts to flatten all ir_if (OPCODE_IF) for GPUs that can't
+ * support control flow.
+ */
+ GLboolean EmitNoIfs;
void *MemPool;
GLbitfield Flags; /**< Mask of GLSL_x flags */
struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */
#include "main/glheader.h"
#include "main/colormac.h"
- #include "main/context.h"
+ #include "main/macros.h"
#include "prog_execute.h"
#include "prog_instruction.h"
#include "prog_parameter.h"
+ /**
+ * Return TRUE for +0 and other positive values, FALSE otherwise.
+ * Used for RCC opcode.
+ */
+ static INLINE GLboolean
+ positive(float x)
+ {
+ fi_type fi;
+ fi.f = x;
+ if (fi.i & 0x80000000)
+ return GL_FALSE;
+ return GL_TRUE;
+ }
+
+
+
/**
* Return a pointer to the 4-element float vector specified by the given
* source register.
store_vector4(inst, machine, result);
}
break;
+ case OPCODE_RCC: /* clamped riciprocal */
+ {
+ const float largest = 1.884467e+19, smallest = 5.42101e-20;
+ GLfloat a[4], r, result[4];
+ fetch_vector1(&inst->SrcReg[0], machine, a);
+ if (DEBUG_PROG) {
+ if (a[0] == 0)
+ printf("RCC(0)\n");
+ else if (IS_INF_OR_NAN(a[0]))
+ printf("RCC(inf)\n");
+ }
+ if (a[0] == 1.0F) {
+ r = 1.0F;
+ }
+ else {
+ r = 1.0F / a[0];
+ }
+ if (positive(r)) {
+ if (r > largest) {
+ r = largest;
+ }
+ else if (r < smallest) {
+ r = smallest;
+ }
+ }
+ else {
+ if (r < -largest) {
+ r = -largest;
+ }
+ else if (r > -smallest) {
+ r = -smallest;
+ }
+ }
+ result[0] = result[1] = result[2] = result[3] = r;
+ store_vector4(inst, machine, result);
+ }
+ break;
+
case OPCODE_RCP:
{
GLfloat a[4], result[4];
numExec++;
if (numExec > maxExec) {
- _mesa_problem(ctx, "Infinite loop detected in fragment program");
+ static GLboolean reported = GL_FALSE;
+ if (!reported) {
+ _mesa_problem(ctx, "Infinite loop detected in fragment program");
+ reported = GL_TRUE;
+ }
return GL_TRUE;
}
OPCODE_ADD, /* X X X X X */
OPCODE_AND, /* */
OPCODE_ARA, /* 2 */
- OPCODE_ARL, /* X X */
+ OPCODE_ARL, /* X X X */
OPCODE_ARL_NV, /* 2 */
OPCODE_ARR, /* 2 */
OPCODE_BGNLOOP, /* opt */
OPCODE_BGNSUB, /* opt */
OPCODE_BRA, /* 2 X */
OPCODE_BRK, /* 2 opt */
- OPCODE_CAL, /* 2 2 */
- OPCODE_CMP, /* X */
+ OPCODE_CAL, /* 2 2 X */
+ OPCODE_CMP, /* X X */
OPCODE_CONT, /* opt */
OPCODE_COS, /* X 2 X X */
OPCODE_DDX, /* X X */
OPCODE_DDY, /* X X */
- OPCODE_DP2, /* 2 */
+ OPCODE_DP2, /* 2 X */
OPCODE_DP2A, /* 2 */
OPCODE_DP3, /* X X X X X */
OPCODE_DP4, /* X X X X X */
OPCODE_LG2, /* X X 2 X X */
OPCODE_LIT, /* X X X X */
OPCODE_LOG, /* X X X */
- OPCODE_LRP, /* X X */
+ OPCODE_LRP, /* X X X */
OPCODE_MAD, /* X X X X X */
OPCODE_MAX, /* X X X X X */
OPCODE_MIN, /* X X X X X */
OPCODE_NOISE3, /* X */
OPCODE_NOISE4, /* X */
OPCODE_NOT, /* */
- OPCODE_NRM3, /* */
- OPCODE_NRM4, /* */
+ OPCODE_NRM3, /* X */
+ OPCODE_NRM4, /* X */
OPCODE_OR, /* */
OPCODE_PK2H, /* X */
OPCODE_PK2US, /* X */
OPCODE_PUSHA, /* 3 */
OPCODE_RCC, /* 1.1 */
OPCODE_RCP, /* X X X X X */
- OPCODE_RET, /* 2 2 */
+ OPCODE_RET, /* 2 2 X */
OPCODE_RFL, /* X X */
OPCODE_RSQ, /* X X X X X */
OPCODE_SCS, /* X */
/**
* For BRA and CAL instructions, the location to jump to.
* For BGNLOOP, points to ENDLOOP (and vice-versa).
- * For BRK, points to BGNLOOP (which points to ENDLOOP).
+ * For BRK, points to ENDLOOP
* For IF, points to ELSE or ENDIF.
* For ELSE, points to ENDIF.
*/
}
-static void
-fprint_alu_instruction(FILE *f,
- const struct prog_instruction *inst,
- const char *opcode_string, GLuint numRegs,
- gl_prog_print_mode mode,
- const struct gl_program *prog)
+void
+_mesa_fprint_alu_instruction(FILE *f,
+ const struct prog_instruction *inst,
+ const char *opcode_string, GLuint numRegs,
+ gl_prog_print_mode mode,
+ const struct gl_program *prog)
{
GLuint j;
_mesa_print_alu_instruction(const struct prog_instruction *inst,
const char *opcode_string, GLuint numRegs)
{
- fprint_alu_instruction(stderr, inst, opcode_string,
- numRegs, PROG_PRINT_DEBUG, NULL);
+ _mesa_fprint_alu_instruction(stderr, inst, opcode_string,
+ numRegs, PROG_PRINT_DEBUG, NULL);
}
default:
if (inst->Opcode < MAX_OPCODE) {
/* typical alu instruction */
- fprint_alu_instruction(f, inst,
- _mesa_opcode_string(inst->Opcode),
- _mesa_num_inst_src_regs(inst->Opcode),
- mode, prog);
+ _mesa_fprint_alu_instruction(f, inst,
+ _mesa_opcode_string(inst->Opcode),
+ _mesa_num_inst_src_regs(inst->Opcode),
+ mode, prog);
}
else {
- fprint_alu_instruction(f, inst,
- _mesa_opcode_string(inst->Opcode),
- 3/*_mesa_num_inst_src_regs(inst->Opcode)*/,
- mode, prog);
+ _mesa_fprint_alu_instruction(f, inst,
+ _mesa_opcode_string(inst->Opcode),
+ 3/*_mesa_num_inst_src_regs(inst->Opcode)*/,
+ mode, prog);
}
break;
}
fprintf(f, "NumParameters=%d\n", prog->NumParameters);
fprintf(f, "NumAttributes=%d\n", prog->NumAttributes);
fprintf(f, "NumAddressRegs=%d\n", prog->NumAddressRegs);
+ fprintf(f, "IndirectRegisterFiles: 0x%x (0b%s)\n",
+ prog->IndirectRegisterFiles, binary(prog->IndirectRegisterFiles));
fprintf(f, "SamplersUsed: 0x%x (0b%s)\n",
prog->SamplersUsed, binary(prog->SamplersUsed));
fprintf(f, "Samplers=[ ");
fprintf(f, "/* Compile status: %s */\n",
shader->CompileStatus ? "ok" : "fail");
- if (!shader->CompileStatus) {
- fprintf(f, "/* Log Info: */\n");
+ fprintf(f, "/* Log Info: */\n");
+ if (shader->InfoLog) {
fputs(shader->InfoLog, f);
}
- else {
+ if (shader->CompileStatus && shader->Program) {
fprintf(f, "/* GPU code */\n");
fprintf(f, "/*\n");
_mesa_fprint_program_opt(f, shader->Program, PROG_PRINT_DEBUG, GL_TRUE);