__inline void fpadd751(const digit_t* a, const digit_t* b, digit_t* c)
{ // Modular addition, c = a+b mod p751.
// Inputs: a, b in [0, 2*p751-1]
// Output: c in [0, 2*p751-1]
#if (OS_TARGET == OS_WIN)
unsigned int i, carry = 0;
digit_t mask;
for (i = 0; i < NWORDS_FIELD; i++) {
ADDC(carry, a[i], b[i], carry, c[i]);
}
carry = 0;
for (i = 0; i < NWORDS_FIELD; i++) {
SUBC(carry, c[i], ((digit_t*)p751x2)[i], carry, c[i]);
}
mask = 0 - (digit_t)carry;
carry = 0;
for (i = 0; i < NWORDS_FIELD; i++) {
ADDC(carry, c[i], ((digit_t*)p751x2)[i] & mask, carry, c[i]);
}
#elif (OS_TARGET == OS_LINUX)
fpadd751_asm(a, b, c);
#endif
}
void
kerberos5_printsub(unsigned char *data, int cnt, unsigned char *buf, int buflen)
{
int i;
buf[buflen-1] = '\0'; /* make sure its NULL terminated */
buflen -= 1;
switch(data[3]) {
case KRB_REJECT: /* Rejected (reason might follow) */
strlcpy((char *)buf, " REJECT ", buflen);
goto common;
case KRB_ACCEPT: /* Accepted (name might follow) */
strlcpy((char *)buf, " ACCEPT ", buflen);
common:
BUMP(buf, buflen);
if (cnt <= 4)
break;
ADDC(buf, buflen, '"');
for (i = 4; i < cnt; i++)
ADDC(buf, buflen, data[i]);
ADDC(buf, buflen, '"');
ADDC(buf, buflen, '\0');
break;
case KRB_AUTH: /* Authentication data follows */
strlcpy((char *)buf, " AUTH", buflen);
goto common2;
case KRB_RESPONSE:
strlcpy((char *)buf, " RESPONSE", buflen);
goto common2;
case KRB_FORWARD: /* Forwarded credentials follow */
strlcpy((char *)buf, " FORWARD", buflen);
goto common2;
case KRB_FORWARD_ACCEPT: /* Forwarded credentials accepted */
strlcpy((char *)buf, " FORWARD_ACCEPT", buflen);
goto common2;
case KRB_FORWARD_REJECT: /* Forwarded credentials rejected */
/* (reason might follow) */
strlcpy((char *)buf, " FORWARD_REJECT", buflen);
goto common2;
default:
snprintf(buf, buflen, " %d (unknown)", data[3]);
common2:
BUMP(buf, buflen);
for (i = 4; i < cnt; i++) {
snprintf(buf, buflen, " %d", data[i]);
BUMP(buf, buflen);
}
break;
}
}
void
kerberos4_printsub(unsigned char *data, int cnt, unsigned char *buf, int buflen)
{
char lbuf[32];
int i;
buf[buflen-1] = '\0'; /* make sure its NULL terminated */
buflen -= 1;
switch(data[3]) {
case KRB_REJECT: /* Rejected (reason might follow) */
strncpy((char *)buf, " REJECT ", buflen);
goto common;
case KRB_ACCEPT: /* Accepted (name might follow) */
strncpy((char *)buf, " ACCEPT ", buflen);
common:
BUMP(buf, buflen);
if (cnt <= 4)
break;
ADDC(buf, buflen, '"');
for (i = 4; i < cnt; i++)
ADDC(buf, buflen, data[i]);
ADDC(buf, buflen, '"');
ADDC(buf, buflen, '\0');
break;
case KRB_AUTH: /* Authentication data follows */
strncpy((char *)buf, " AUTH", buflen);
goto common2;
case KRB_CHALLENGE:
strncpy((char *)buf, " CHALLENGE", buflen);
goto common2;
case KRB_RESPONSE:
strncpy((char *)buf, " RESPONSE", buflen);
goto common2;
default:
snprintf(lbuf, sizeof(lbuf), " %d (unknown)", data[3]);
strncpy((char *)buf, lbuf, buflen);
common2:
BUMP(buf, buflen);
for (i = 4; i < cnt; i++) {
snprintf(lbuf, sizeof(lbuf), " %d", data[i]);
strncpy((char *)buf, lbuf, buflen);
BUMP(buf, buflen);
}
break;
}
}
static struct token *
get_ident (struct linereader *lr)
{
char *buf;
size_t bufact;
size_t bufmax = 56;
const struct keyword_t *kw;
int ch;
buf = xmalloc (bufmax);
bufact = 0;
ADDC (lr->buf[lr->idx - 1]);
while (!isspace ((ch = lr_getc (lr))) && ch != '"' && ch != ';'
&& ch != '<' && ch != ',' && ch != EOF)
{
if (ch == lr->escape_char)
{
ch = lr_getc (lr);
if (ch == '\n' || ch == EOF)
{
lr_error (lr, _("invalid escape sequence"));
break;
}
}
ADDC (ch);
}
lr_ungetc (lr, ch);
kw = lr->hash_fct (buf, bufact);
if (kw != NULL && kw->symname_or_ident == 0)
{
lr->token.tok = kw->token;
free (buf);
}
else
{
lr->token.tok = tok_ident;
buf = xrealloc (buf, bufact + 1);
buf[bufact] = '\0';
lr->token.val.str.startmb = buf;
lr->token.val.str.lenmb = bufact;
}
return &lr->token;
}
void
kerberos5_printsub (unsigned char *data, int cnt,
unsigned char *buf, int buflen)
{
char *p;
int i;
buf[buflen - 1] = '\0'; /* make sure its NULL terminated */
buflen -= 1;
p = req_type_str (data[3]);
if (!p)
{
int l = snprintf (buf, buflen, " %d (unknown)", data[3]);
buf += l;
buflen -= l;
}
else
{
while (buflen > 0 && (*buf++ = *p++) != 0)
buflen--;
}
switch (data[3])
{
case KRB_REJECT: /* Rejected (reason might follow) */
case KRB_ACCEPT: /* Accepted (username might follow) */
if (cnt <= 4)
break;
ADDC (buf, buflen, '"');
for (i = 4; i < cnt; i++)
ADDC (buf, buflen, data[i]);
ADDC (buf, buflen, '"');
ADDC (buf, buflen, '\0');
break;
case KRB_AUTH:
case KRB_RESPONSE:
case KRB_FORWARD:
case KRB_FORWARD_ACCEPT:
case KRB_FORWARD_REJECT:
for (i = 4; buflen > 0 && i < cnt; i++)
{
int l = snprintf (buf, buflen, " %d", data[i]);
buf += l;
buflen -= l;
}
}
}
__inline void fpsub751(const digit_t* a, const digit_t* b, digit_t* c)
{ // Modular subtraction, c = a-b mod p751.
// Inputs: a, b in [0, 2*p751-1]
// Output: c in [0, 2*p751-1]
#if (OS_TARGET == OS_WIN)
unsigned int i, borrow = 0;
digit_t mask;
for (i = 0; i < NWORDS_FIELD; i++) {
SUBC(borrow, a[i], b[i], borrow, c[i]);
}
mask = 0 - (digit_t)borrow;
borrow = 0;
for (i = 0; i < NWORDS_FIELD; i++) {
ADDC(borrow, c[i], ((digit_t*)p751x2)[i] & mask, borrow, c[i]);
}
#elif (OS_TARGET == OS_LINUX)
fpsub751_asm(a, b, c);
#endif
}
unsigned int mp_add(const digit_t* a, const digit_t* b, digit_t* c, const unsigned int nwords)
{ // Multiprecision addition, c = a+b, where lng(a) = lng(b) = nwords. Returns the carry bit.
unsigned int i, carry = 0;
for (i = 0; i < nwords; i++) {
ADDC(carry, a[i], b[i], carry, c[i]);
}
return carry;
}
void fpdiv2_751(const digit_t* a, digit_t* c)
{ // Modular division by two, c = a/2 mod p751.
// Input : a in [0, 2*p751-1]
// Output: c in [0, 2*p751-1]
unsigned int i, carry = 0;
digit_t mask;
mask = 0 - (digit_t)(a[0] & 1); // If a is odd compute a+p751
for (i = 0; i < NWORDS_FIELD; i++) {
ADDC(carry, a[i], ((digit_t*)p751)[i] & mask, carry, c[i]);
}
mp_shiftr1(c, NWORDS_FIELD);
}
void fpcorrection751(digit_t* a)
{ // Modular correction to reduce field element a in [0, 2*p751-1] to [0, p751-1].
unsigned int i, borrow = 0;
digit_t mask;
for (i = 0; i < NWORDS_FIELD; i++) {
SUBC(borrow, a[i], ((digit_t*)p751)[i], borrow, a[i]);
}
mask = 0 - (digit_t)borrow;
borrow = 0;
for (i = 0; i < NWORDS_FIELD; i++) {
ADDC(borrow, a[i], ((digit_t*)p751)[i] & mask, borrow, a[i]);
}
}
static size_t process_half(int sock,const unsigned char *sbuf,size_t slen) {
const unsigned char *p,*e;
unsigned char c;
struct socket *s=sockets+sock;
p=sbuf; e=sbuf+slen;
while (p<e)
switch (c=*p++) {
case '\r':
break;
case '\n':
s->handler(sock,SLINE,s->data,s->ibuf,s->ilen);
s->ilen=0;
break;
default:
ADDC(c);
break;
}
s->procin+=slen;
return 0;
}
void fp2mul_mont(const f2elm_t *a, const f2elm_t *b, f2elm_t *c)
{ // GF(p^2) multiplication using Montgomery arithmetic, c = a*b in GF(p^2).
// Inputs: a = a0+a1*i and b = b0+b1*i, where a0, a1, b0, b1 are in [0, 2*p-1]
// Output: c = c0+c1*i, where c0, c1 are in [0, 2*p-1]
felm_t t1, t2;
dfelm_t tt1, tt2, tt3;
digit_t mask;
unsigned int i, borrow = 0;
mp_mul(a->e[0], b->e[0], tt1, NWORDS_FIELD); // tt1 = a0*b0
mp_mul(a->e[1], b->e[1], tt2, NWORDS_FIELD); // tt2 = a1*b1
mp_addfast(a->e[0], a->e[1], t1); // t1 = a0+a1
mp_addfast(b->e[0], b->e[1], t2); // t2 = b0+b1
mask = mp_subfast(tt1, tt2, tt3); // tt3 = a0*b0 - a1*b1. If tt3 < 0 then mask = 0xFF..F, else if tt3 >= 0 then mask = 0x00..0
for (i = 0; i < NWORDS_FIELD; i++) {
ADDC(borrow, tt3[NWORDS_FIELD+i], ((const digit_t*)PRIME)[i] & mask, borrow, tt3[NWORDS_FIELD+i]);
}
rdc_mont(tt3, c->e[0]); // c[0] = a0*b0 - a1*b1
mp_addfastx2(tt1, tt2, tt1); // tt1 = a0*b0 + a1*b1
mp_mul(t1, t2, tt2, NWORDS_FIELD); // tt2 = (a0+a1)*(b0+b1)
mp_subfast(tt2, tt1, tt2); // tt2 = (a0+a1)*(b0+b1) - a0*b0 - a1*b1
rdc_mont(tt2, c->e[1]); // c[1] = (a0+a1)*(b0+b1) - a0*b0 - a1*b1
}
static struct token *
get_symname (struct linereader *lr)
{
/* Symbol in brackets. We must distinguish three kinds:
1. reserved words
2. ISO 10646 position values
3. all other. */
char *buf;
size_t bufact = 0;
size_t bufmax = 56;
const struct keyword_t *kw;
int ch;
buf = (char *) xmalloc (bufmax);
do
{
ch = lr_getc (lr);
if (ch == lr->escape_char)
{
int c2 = lr_getc (lr);
ADDC (c2);
if (c2 == '\n')
ch = '\n';
}
else
ADDC (ch);
}
while (ch != '>' && ch != '\n');
if (ch == '\n')
lr_error (lr, _("unterminated symbolic name"));
/* Test for ISO 10646 position value. */
if (buf[0] == 'U' && (bufact == 6 || bufact == 10))
{
char *cp = buf + 1;
while (cp < &buf[bufact - 1] && isxdigit (*cp))
++cp;
if (cp == &buf[bufact - 1])
{
/* Yes, it is. */
lr->token.tok = tok_ucs4;
lr->token.val.ucs4 = strtoul (buf + 1, NULL, 16);
return &lr->token;
}
}
/* It is a symbolic name. Test for reserved words. */
kw = lr->hash_fct (buf, bufact - 1);
if (kw != NULL && kw->symname_or_ident == 1)
{
lr->token.tok = kw->token;
free (buf);
}
else
{
lr->token.tok = tok_bsymbol;
buf = xrealloc (buf, bufact + 1);
buf[bufact] = '\0';
lr->token.val.str.startmb = buf;
lr->token.val.str.lenmb = bufact - 1;
}
return &lr->token;
}
static size_t process_sockbuf(int sock,const unsigned char *sbuf,size_t slen) {
int i,newattr;
const unsigned char *p,*e;
unsigned char c;
struct socket *s=sockets+sock;
unsigned option;
if (s->mode==SM_HALF)
return process_half(sock,sbuf,slen);
p=sbuf; e=sbuf+slen;
while (p<e)
switch (s->state) {
case sNORMAL:
switch (c=*p++) {
case '\a':
s->handler(sock,SBELL,s->data,NULL,0);
break;
case '\t':
i=8-s->ilen%8;
while (i--)
ADDC(' ');
break;
case '\n':
s->handler(sock,SLINE,s->data,s->ibuf,s->ilen);
s->ilen=0;
break;
case '\033':
s->state=sESC;
break;
case IAC:
s->state=sIAC;
break;
default:
ADDC(c);
break;
}
break;
case sIAC:
switch (c=*p++) {
case DO:
case DONT:
case WILL:
case WONT:
s->tcmd=c;
s->state=sDW;
break;
case GA:
case EOR:
s->lp=0;
cancel_lpe(sock);
s->handler(sock,SPROMPT,s->data,s->ibuf,s->ilen);
s->ilen=0;
s->state=sNORMAL;
break;
case SB: /* subneg */
s->sbbptr=0;
s->state=sSUBNEG;
break;
case IAC:
ADDC(IAC);
s->state=sNORMAL;
break;
default:
s->state=sNORMAL;
break;
}
break;
case sSUBNEG:
switch (c=*p++) {
case IAC:
s->state=sSUBNEGD;
break;
case SE:
/* this certainly sucks, mccp authors didnt read telnet
rfc apparently */
if (s->sbbptr==2 && s->sbbuf[0]==85 && s->sbbuf[1]==WILL)
goto mccp_braindamage;
default:
if (s->sbbptr<sizeof(s->sbbuf))
s->sbbuf[s->sbbptr++]=c;
break;
}
break;
case sSUBNEGD:
switch (c=*p++) {
case IAC:
if (s->sbbptr<sizeof(s->sbbuf))
s->sbbuf[s->sbbptr++]=IAC;
s->state=sSUBNEG;
break;
case SE:
mccp_braindamage: s->state=sNORMAL;
if ((s->sbbptr==2 && s->sbbuf[0]==85 && s->sbbuf[1]==WILL) ||
(s->sbbptr==1 && s->sbbuf[0]==86))
{
if (!s->zsp) {
start_mccp(sock);
if (p<e) {
s->procin+=p-sbuf;
return e-p; /* return immediately because the mccp was
started */
}
}
break;
}
// handle non-MCCP options
if (0 < s->sbbptr)
{
s->handler(sock, SSUBNEG, s->data, s->sbbuf, s->sbbptr);
}
break;
default:
s->state=sNORMAL;
}
break;
case sDW:
switch (c=*p++) {
case TELOPT_ECHO:
if (s->tcmd==WILL)
s->handler(sock,SECHOOFF,s->data,NULL,0);
if (s->tcmd==WONT)
s->handler(sock,SECHOON,s->data,NULL,0);
break;
case TELOPT_MCCPv1:
case TELOPT_MCCPv2: /* mccp, always allow compression */
if (s->tcmd==WILL) {
unsigned char tmp[]={IAC,DO,0};
tmp[2]=c;
swrite(sock,tmp,3,1);
clmsg("Enabling MCCP.");
}
break;
default:
// send to Perl option request.
option = (unsigned char) c;
s->handler(sock, SOPTREQ, s->data, &option, 0);
break;
}
s->state=sNORMAL;
break;
case sESC:
switch (*p++) {
case '[':
s->acnt=0;
s->args[0]=0;
s->state=sGNUM;
break;
default:
s->state=sNORMAL;
break;
}
break;
case sGNUM:
switch (c=*p++) {
case '\n':
s->handler(sock,SLINE,s->data,s->ibuf,s->ilen);
s->ilen=0;
s->state=sNORMAL;
break;
case IAC:
s->state=sIAC;
break;
case '0': case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
s->args[s->acnt]=s->args[s->acnt]*10+(int)(c-'0');
break;
case ';':
if (s->acnt<9)
s->acnt++;
s->args[s->acnt]=0;
break;
case 'm':
newattr=s->attr;
for (i=0;i<=s->acnt;i++)
if (s->args[i]==0)
newattr=7;
else if (s->args[i]==1)
newattr|=8;
else if (s->args[i]>=30&&s->args[i]<=37)
newattr=(newattr&8)|((s->args[i]-30)&7);
s->attr=newattr;
s->state=sNORMAL;
break;
default:
s->state=sNORMAL;
break;
}
break;
default:
s->state=sNORMAL;
}
cancel_lpe(sock);
if (s->ilen>0 && s->lp && s->state==sNORMAL) {
if (lpdelay>0)
s->lpevent=stimeout(gettime()+lpdelay,(PEVHANDLER)&lpe_handler,s);
else {
s->handler(s-sockets,SPROMPT,s->data,s->ibuf,s->ilen);
s->ilen=0;
}
}
s->procin+=slen;
return 0;
}
void
gen8_vec4_generator::generate_vec4_instruction(vec4_instruction *instruction,
struct brw_reg dst,
struct brw_reg *src)
{
vec4_instruction *ir = (vec4_instruction *) instruction;
if (dst.width == BRW_WIDTH_4) {
/* This happens in attribute fixups for "dual instanced" geometry
* shaders, since they use attributes that are vec4's. Since the exec
* width is only 4, it's essential that the caller set
* force_writemask_all in order to make sure the instruction is executed
* regardless of which channels are enabled.
*/
assert(ir->force_writemask_all);
/* Fix up any <8;8,1> or <0;4,1> source registers to <4;4,1> to satisfy
* the following register region restrictions (from Graphics BSpec:
* 3D-Media-GPGPU Engine > EU Overview > Registers and Register Regions
* > Register Region Restrictions)
*
* 1. ExecSize must be greater than or equal to Width.
*
* 2. If ExecSize = Width and HorzStride != 0, VertStride must be set
* to Width * HorzStride."
*/
for (int i = 0; i < 3; i++) {
if (src[i].file == BRW_GENERAL_REGISTER_FILE)
src[i] = stride(src[i], 4, 4, 1);
}
}
switch (ir->opcode) {
case BRW_OPCODE_MOV:
MOV(dst, src[0]);
break;
case BRW_OPCODE_ADD:
ADD(dst, src[0], src[1]);
break;
case BRW_OPCODE_MUL:
MUL(dst, src[0], src[1]);
break;
case BRW_OPCODE_MACH:
MACH(dst, src[0], src[1]);
break;
case BRW_OPCODE_MAD:
MAD(dst, src[0], src[1], src[2]);
break;
case BRW_OPCODE_FRC:
FRC(dst, src[0]);
break;
case BRW_OPCODE_RNDD:
RNDD(dst, src[0]);
break;
case BRW_OPCODE_RNDE:
RNDE(dst, src[0]);
break;
case BRW_OPCODE_RNDZ:
RNDZ(dst, src[0]);
break;
case BRW_OPCODE_AND:
AND(dst, src[0], src[1]);
break;
case BRW_OPCODE_OR:
OR(dst, src[0], src[1]);
break;
case BRW_OPCODE_XOR:
XOR(dst, src[0], src[1]);
break;
case BRW_OPCODE_NOT:
NOT(dst, src[0]);
break;
case BRW_OPCODE_ASR:
ASR(dst, src[0], src[1]);
break;
case BRW_OPCODE_SHR:
SHR(dst, src[0], src[1]);
break;
case BRW_OPCODE_SHL:
SHL(dst, src[0], src[1]);
break;
case BRW_OPCODE_CMP:
CMP(dst, ir->conditional_mod, src[0], src[1]);
break;
case BRW_OPCODE_SEL:
SEL(dst, src[0], src[1]);
break;
case BRW_OPCODE_DPH:
DPH(dst, src[0], src[1]);
break;
case BRW_OPCODE_DP4:
DP4(dst, src[0], src[1]);
break;
case BRW_OPCODE_DP3:
DP3(dst, src[0], src[1]);
break;
case BRW_OPCODE_DP2:
DP2(dst, src[0], src[1]);
break;
case BRW_OPCODE_F32TO16:
F32TO16(dst, src[0]);
break;
case BRW_OPCODE_F16TO32:
F16TO32(dst, src[0]);
break;
case BRW_OPCODE_LRP:
LRP(dst, src[0], src[1], src[2]);
break;
case BRW_OPCODE_BFREV:
/* BFREV only supports UD type for src and dst. */
BFREV(retype(dst, BRW_REGISTER_TYPE_UD),
retype(src[0], BRW_REGISTER_TYPE_UD));
break;
case BRW_OPCODE_FBH:
/* FBH only supports UD type for dst. */
FBH(retype(dst, BRW_REGISTER_TYPE_UD), src[0]);
break;
case BRW_OPCODE_FBL:
/* FBL only supports UD type for dst. */
FBL(retype(dst, BRW_REGISTER_TYPE_UD), src[0]);
break;
case BRW_OPCODE_CBIT:
/* CBIT only supports UD type for dst. */
CBIT(retype(dst, BRW_REGISTER_TYPE_UD), src[0]);
break;
case BRW_OPCODE_ADDC:
ADDC(dst, src[0], src[1]);
break;
case BRW_OPCODE_SUBB:
SUBB(dst, src[0], src[1]);
break;
case BRW_OPCODE_BFE:
BFE(dst, src[0], src[1], src[2]);
break;
case BRW_OPCODE_BFI1:
BFI1(dst, src[0], src[1]);
break;
case BRW_OPCODE_BFI2:
BFI2(dst, src[0], src[1], src[2]);
break;
case BRW_OPCODE_IF:
IF(ir->predicate);
break;
case BRW_OPCODE_ELSE:
ELSE();
break;
case BRW_OPCODE_ENDIF:
ENDIF();
break;
case BRW_OPCODE_DO:
DO();
break;
case BRW_OPCODE_BREAK:
BREAK();
break;
case BRW_OPCODE_CONTINUE:
CONTINUE();
break;
case BRW_OPCODE_WHILE:
WHILE();
break;
case SHADER_OPCODE_RCP:
MATH(BRW_MATH_FUNCTION_INV, dst, src[0]);
break;
case SHADER_OPCODE_RSQ:
MATH(BRW_MATH_FUNCTION_RSQ, dst, src[0]);
break;
case SHADER_OPCODE_SQRT:
MATH(BRW_MATH_FUNCTION_SQRT, dst, src[0]);
break;
case SHADER_OPCODE_EXP2:
MATH(BRW_MATH_FUNCTION_EXP, dst, src[0]);
break;
case SHADER_OPCODE_LOG2:
MATH(BRW_MATH_FUNCTION_LOG, dst, src[0]);
break;
case SHADER_OPCODE_SIN:
MATH(BRW_MATH_FUNCTION_SIN, dst, src[0]);
break;
case SHADER_OPCODE_COS:
MATH(BRW_MATH_FUNCTION_COS, dst, src[0]);
break;
case SHADER_OPCODE_POW:
MATH(BRW_MATH_FUNCTION_POW, dst, src[0], src[1]);
break;
case SHADER_OPCODE_INT_QUOTIENT:
MATH(BRW_MATH_FUNCTION_INT_DIV_QUOTIENT, dst, src[0], src[1]);
break;
case SHADER_OPCODE_INT_REMAINDER:
MATH(BRW_MATH_FUNCTION_INT_DIV_REMAINDER, dst, src[0], src[1]);
break;
case SHADER_OPCODE_TEX:
case SHADER_OPCODE_TXD:
case SHADER_OPCODE_TXF:
case SHADER_OPCODE_TXF_CMS:
case SHADER_OPCODE_TXF_MCS:
case SHADER_OPCODE_TXL:
case SHADER_OPCODE_TXS:
case SHADER_OPCODE_TG4:
case SHADER_OPCODE_TG4_OFFSET:
generate_tex(ir, dst);
break;
case VS_OPCODE_URB_WRITE:
generate_urb_write(ir, true);
break;
case SHADER_OPCODE_GEN4_SCRATCH_READ:
generate_scratch_read(ir, dst, src[0]);
break;
case SHADER_OPCODE_GEN4_SCRATCH_WRITE:
generate_scratch_write(ir, dst, src[0], src[1]);
break;
case VS_OPCODE_PULL_CONSTANT_LOAD:
case VS_OPCODE_PULL_CONSTANT_LOAD_GEN7:
generate_pull_constant_load(ir, dst, src[0], src[1]);
break;
case GS_OPCODE_URB_WRITE:
generate_urb_write(ir, false);
break;
case GS_OPCODE_THREAD_END:
generate_gs_thread_end(ir);
break;
case GS_OPCODE_SET_WRITE_OFFSET:
generate_gs_set_write_offset(dst, src[0], src[1]);
break;
case GS_OPCODE_SET_VERTEX_COUNT:
generate_gs_set_vertex_count(dst, src[0]);
break;
case GS_OPCODE_SET_DWORD_2_IMMED:
generate_gs_set_dword_2_immed(dst, src[0]);
break;
case GS_OPCODE_PREPARE_CHANNEL_MASKS:
generate_gs_prepare_channel_masks(dst);
break;
case GS_OPCODE_SET_CHANNEL_MASKS:
generate_gs_set_channel_masks(dst, src[0]);
break;
case SHADER_OPCODE_SHADER_TIME_ADD:
assert(!"XXX: Missing Gen8 vec4 support for INTEL_DEBUG=shader_time");
break;
case SHADER_OPCODE_UNTYPED_ATOMIC:
assert(!"XXX: Missing Gen8 vec4 support for UNTYPED_ATOMIC");
break;
case SHADER_OPCODE_UNTYPED_SURFACE_READ:
assert(!"XXX: Missing Gen8 vec4 support for UNTYPED_SURFACE_READ");
break;
case VS_OPCODE_UNPACK_FLAGS_SIMD4X2:
assert(!"VS_OPCODE_UNPACK_FLAGS_SIMD4X2 should not be used on Gen8+.");
break;
default:
if (ir->opcode < (int) ARRAY_SIZE(opcode_descs)) {
_mesa_problem(ctx, "Unsupported opcode in `%s' in VS\n",
opcode_descs[ir->opcode].name);
} else {
_mesa_problem(ctx, "Unsupported opcode %d in VS", ir->opcode);
}
abort();
}
}
void ATL_USERMM(SZT nmu, SZT nnu, SZT K, CTYPE *pA, CTYPE *pB, TYPE *pC,
CTYPE *pAn, CTYPE *pBn, CTYPE *pCn)
{
register TYPE rA0, rA1, rA2, rA3, rB0, rB1, rb1;
register TYPE rC00, rC10, rC20, rC30;
register TYPE rC01, rC11, rC21, rC31;
CTYPE *pB0 = pB;
int m, n;
for (m=0; m < nmu; m++)
{
rB0 = *pB;
rA0 = *pA;
for (n=0; n < nnu; n++)
{
/*
* K == 1
*/
rC00 = rA0 * rB0;
ADDC(rC00, *pC);
rA1 = pA[1];
rC10 = rA1 * rB0;
ADDC(rC10, pC[1]);
rA2 = pA[2];
rC20 = rA2 * rB0;
ADDC(rC20, pC[2]);
rA3 = pA[3];
rC30 = rA3 * rB0;
ADDC(rC30, pC[3]);
rB1 = pB[1];
rC01 = rA0 * rB1;
ADDC(rC01, pC[4]);
rB0 = pB[2];
rC11 = rA1 * rB1;
ADDC(rC11, pC[5]);
rA0 = pA[4];
rC21 = rA2 * rB1;
ADDC(rC21, pC[6]);
rA1 = pA[5];
rC31 = rA3 * rB1;
ADDC(rC31, pC[7]);
rA2 = pA[6];
/*
* K == 2
*/
rC00 += rA0 * rB0;
rA3 = pA[7];
rC10 += rA1 * rB0;
rB1 = pB[3];
rC20 += rA2 * rB0;
rC30 += rA3 * rB0;
rB0 = pB[4];
rC01 += rA0 * rB1;
rA0 = pA[8];
rC11 += rA1 * rB1;
rA1 = pA[9];
rC21 += rA2 * rB1;
rA2 = pA[10];
rC31 += rA3 * rB1;
rA3 = pA[11];
/*
* K == 3
*/
rC00 += rA0 * rB0;
rB1 = pB[5];
rC10 += rA1 * rB0;
rb1 = pB[7];
rC20 += rA2 * rB0;
rC30 += rA3 * rB0;
rB0 = pB[6];
rC01 += rA0 * rB1;
rA0 = pA[12];
rC11 += rA1 * rB1;
rA1 = pA[13];
rC21 += rA2 * rB1;
rA2 = pA[14];
rC31 += rA3 * rB1;
rA3 = pA[15];
/*
* K == 4
*/
rC00 += rA0 * rB0;
*pC = rC00;
rC10 += rA1 * rB0;
pC[1] = rC10;
rC20 += rA2 * rB0;
pC[2] = rC20;
rC30 += rA3 * rB0;
pC[3] = rC30;
rB0 = pB[8];
rC01 += rA0 * rb1;
pC[4] = rC01;
rA0 = *pA;
rC11 += rA1 * rb1;
pC[5] = rC11;
rC21 += rA2 * rb1;
pC[6] = rC21;
rC31 += rA3 * rb1;
pC[7] = rC31;
pB += 8;
pC += 8;
}
pA += 16;
pB = pB0;
}
}
int
sockaddr_snprintf(char * const sbuf, const size_t len, const char * const fmt,
const struct sockaddr * const sa)
{
const void *a = NULL;
char abuf[1024], nbuf[1024], *addr = NULL;
char Abuf[1024], pbuf[32], *name = NULL, *port = NULL;
char *ebuf = &sbuf[len - 1], *buf = sbuf;
const char *ptr, *s;
int p = -1;
#ifdef HAVE_NETATALK_AT_H
const struct sockaddr_at *sat = NULL;
#endif
const struct sockaddr_in *sin4 = NULL;
const struct sockaddr_in6 *sin6 = NULL;
const struct sockaddr_un *sun = NULL;
#ifdef HAVE_NET_IF_DL_H
const struct sockaddr_dl *sdl = NULL;
char *w = NULL;
#endif
int na = 1;
#define ADDC(c) do { if (buf < ebuf) *buf++ = c; else buf++; } \
while (/*CONSTCOND*/0)
#define ADDS(p) do { for (s = p; *s; s++) ADDC(*s); } \
while (/*CONSTCOND*/0)
#define ADDNA() do { if (na) ADDS("N/A"); } \
while (/*CONSTCOND*/0)
switch (sa->sa_family) {
case AF_UNSPEC:
goto done;
#ifdef HAVE_NETATALK_AT_H
case AF_APPLETALK:
sat = ((const struct sockaddr_at *)(const void *)sa);
p = ntohs(sat->sat_port);
(void)snprintf(addr = abuf, sizeof(abuf), "%u.%u",
ntohs(sat->sat_addr.s_net), sat->sat_addr.s_node);
(void)snprintf(port = pbuf, sizeof(pbuf), "%d", p);
break;
#endif
case AF_LOCAL:
sun = ((const struct sockaddr_un *)(const void *)sa);
(void)strlcpy(addr = abuf, sun->sun_path, sizeof(abuf));
break;
case AF_INET:
sin4 = ((const struct sockaddr_in *)(const void *)sa);
p = ntohs(sin4->sin_port);
a = &sin4->sin_addr;
break;
case AF_INET6:
sin6 = ((const struct sockaddr_in6 *)(const void *)sa);
p = ntohs(sin6->sin6_port);
a = &sin6->sin6_addr;
break;
#ifdef HAVE_NET_IF_DL_H
case AF_LINK:
sdl = ((const struct sockaddr_dl *)(const void *)sa);
(void)strlcpy(addr = abuf, link_ntoa(sdl), sizeof(abuf));
if ((w = strchr(addr, ':')) != NULL) {
*w++ = '\0';
addr = w;
}
break;
#endif
default:
errno = EAFNOSUPPORT;
return -1;
}
if (addr == abuf)
name = addr;
if (a && getnameinfo(sa, (socklen_t)SLEN(sa), addr = abuf,
(unsigned int)sizeof(abuf), NULL, 0,
NI_NUMERICHOST|NI_NUMERICSERV) != 0)
return -1;
for (ptr = fmt; *ptr; ptr++) {
if (*ptr != '%') {
ADDC(*ptr);
continue;
}
next_char:
switch (*++ptr) {
case '?':
na = 0;
goto next_char;
case 'a':
ADDS(addr);
break;
case 'p':
if (p != -1) {
(void)snprintf(nbuf, sizeof(nbuf), "%d", p);
ADDS(nbuf);
} else
ADDNA();
break;
case 'f':
(void)snprintf(nbuf, sizeof(nbuf), "%d", sa->sa_family);
ADDS(nbuf);
break;
case 'l':
(void)snprintf(nbuf, sizeof(nbuf), "%d", SLEN(sa));
ADDS(nbuf);
break;
case 'A':
if (name)
ADDS(name);
else if (!a)
ADDNA();
else {
getnameinfo(sa, (socklen_t)SLEN(sa),
name = Abuf,
(unsigned int)sizeof(nbuf), NULL, 0, 0);
ADDS(name);
}
break;
case 'P':
if (port)
ADDS(port);
else if (p == -1)
ADDNA();
else {
getnameinfo(sa, (socklen_t)SLEN(sa), NULL, 0,
port = pbuf,
(unsigned int)sizeof(pbuf), 0);
ADDS(port);
}
break;
case 'I':
#ifdef HAVE_NET_IF_DL_H
if (sdl && addr != abuf) {
ADDS(abuf);
} else
#endif
{
ADDNA();
}
break;
case 'F':
if (sin6) {
(void)snprintf(nbuf, sizeof(nbuf), "%d",
sin6->sin6_flowinfo);
ADDS(nbuf);
break;
} else {
ADDNA();
}
break;
case 'S':
if (sin6) {
(void)snprintf(nbuf, sizeof(nbuf), "%d",
sin6->sin6_scope_id);
ADDS(nbuf);
break;
} else {
ADDNA();
}
break;
case 'R':
#ifdef HAVE_NETATALK_AT_H
if (sat) {
const struct netrange *n =
&sat->sat_range.r_netrange;
(void)snprintf(nbuf, sizeof(nbuf),
"%d:[%d,%d]", n->nr_phase , n->nr_firstnet,
n->nr_lastnet);
ADDS(nbuf);
} else
#endif
{
ADDNA();
}
break;
case 'D':
switch (sa->sa_family) {
#ifdef HAVE_NETATALK_AT_H
case AF_APPLETALK:
debug_at(nbuf, sizeof(nbuf), sat);
break;
#endif
case AF_LOCAL:
debug_un(nbuf, sizeof(nbuf), sun);
break;
case AF_INET:
debug_in(nbuf, sizeof(nbuf), sin4);
break;
case AF_INET6:
debug_in6(nbuf, sizeof(nbuf), sin6);
break;
#ifdef HAVE_NET_IF_DL_H
case AF_LINK:
debug_dl(nbuf, sizeof(nbuf), sdl);
break;
#endif
default:
abort();
}
ADDS(nbuf);
break;
default:
ADDC('%');
if (na == 0)
ADDC('?');
if (*ptr == '\0')
goto done;
/*FALLTHROUGH*/
case '%':
ADDC(*ptr);
break;
}
na = 1;
}
done:
if (buf < ebuf)
*buf = '\0';
else if (len != 0)
sbuf[len - 1] = '\0';
return (int)(buf - sbuf);
}
/*
* Write summary to stderr according to format 'fmt'. If 'enable' is 0, it
* will not attempt to write anything. Can be used to validate the
* correctness of the 'fmt' string.
*/
int
dd_write_msg(const char *fmt, int enable)
{
char hbuf[7], nbuf[32];
const char *ptr;
int64_t mS;
struct timeval tv;
(void)gettimeofday(&tv, NULL);
mS = tv2mS(tv) - tv2mS(st.start);
if (mS == 0)
mS = 1;
#define ADDC(c) do { if (enable != 0) buffer_write(&c, 1, 0); } \
while (/*CONSTCOND*/0)
#define ADDS(p) do { if (enable != 0) buffer_write(p, strlen(p), 0); } \
while (/*CONSTCOND*/0)
for (ptr = fmt; *ptr; ptr++) {
if (*ptr != '%') {
ADDC(*ptr);
continue;
}
switch (*++ptr) {
case 'b':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long)st.bytes);
ADDS(nbuf);
break;
case 'B':
if (humanize_number(hbuf, sizeof(hbuf),
st.bytes, "B",
HN_AUTOSCALE, HN_DECIMAL) == -1)
warnx("humanize_number (bytes transferred)");
ADDS(hbuf);
break;
case 'e':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long) (st.bytes * 1000LL / mS));
ADDS(nbuf);
break;
case 'E':
if (humanize_number(hbuf, sizeof(hbuf),
st.bytes * 1000LL / mS, "B",
HN_AUTOSCALE, HN_DECIMAL) == -1)
warnx("humanize_number (bytes per second)");
ADDS(hbuf); ADDS("/sec");
break;
case 'i':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long)st.in_part);
ADDS(nbuf);
break;
case 'I':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long)st.in_full);
ADDS(nbuf);
break;
case 'o':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long)st.out_part);
ADDS(nbuf);
break;
case 'O':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long)st.out_full);
ADDS(nbuf);
break;
case 's':
(void)snprintf(nbuf, sizeof(nbuf), "%li.%03d",
(long) (mS / 1000), (int) (mS % 1000));
ADDS(nbuf);
break;
case 'p':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long)st.sparse);
ADDS(nbuf);
break;
case 't':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long)st.trunc);
ADDS(nbuf);
break;
case 'w':
(void)snprintf(nbuf, sizeof(nbuf), "%llu",
(unsigned long long)st.swab);
ADDS(nbuf);
break;
case 'P':
ADDS("block");
if (st.sparse != 1) ADDS("s");
break;
case 'T':
ADDS("block");
if (st.trunc != 1) ADDS("s");
break;
case 'W':
ADDS("block");
if (st.swab != 1) ADDS("s");
break;
case '%':
ADDC(*ptr);
break;
default:
if (*ptr == '\0')
goto done;
errx(EXIT_FAILURE, "unknown specifier '%c' in "
"msgfmt string", *ptr);
/* NOTREACHED */
}
}
done:
/* flush buffer */
buffer_write(NULL, 0, 1);
return 0;
}
void rdc_mont(const dfelm_t ma, felm_t mc)
{ // Efficient Montgomery reduction using comba and exploiting the special form of the prime p751.
// mc = ma*R^-1 mod p751x2, where R = 2^768.
// If ma < 2^768*p751, the output mc is in the range [0, 2*p751-1].
// ma is assumed to be in Montgomery representation.
#if (OS_TARGET == OS_WIN)
unsigned int carry;
digit_t t = 0;
uint128_t uv = {0};
mc[0] = ma[0];
mc[1] = ma[1];
mc[2] = ma[2];
mc[3] = ma[3];
mc[4] = ma[4];
MUL128(mc[0], ((digit_t*)p751p1)[5], uv);
ADDC(0, uv[0], ma[5], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
mc[5] = uv[0];
uv[0] = uv[1];
uv[1] = 0;
MULADD128(mc[0], ((digit_t*)p751p1)[6], uv, carry, uv);
MULADD128(mc[1], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[6], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[6] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[0], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[1], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[2], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[7], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[7] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[0], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[1], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[2], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[3], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[8], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[8] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[0], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[1], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[2], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[3], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[4], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[9], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[9] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[0], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[1], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[2], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[3], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[4], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[5], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[10], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[10] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[0], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[1], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[2], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[3], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[4], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[5], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[6], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[11], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[11] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[1], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[2], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[3], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[4], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[5], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[6], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[7], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[12], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[0] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[2], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[3], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[4], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[5], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[6], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[7], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[8], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[13], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[1] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[3], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[4], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[5], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[6], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[7], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[8], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[9], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[14], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[2] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[4], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[5], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[6], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[7], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[8], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[9], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[10], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[15], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[3] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[5], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[6], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[7], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[8], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[9], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[10], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
MULADD128(mc[11], ((digit_t*)p751p1)[5], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[16], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[4] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[6], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[7], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[8], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[9], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[10], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
MULADD128(mc[11], ((digit_t*)p751p1)[6], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[17], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[5] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[7], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[8], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[9], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[10], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
MULADD128(mc[11], ((digit_t*)p751p1)[7], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[18], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[6] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[8], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[9], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[10], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
MULADD128(mc[11], ((digit_t*)p751p1)[8], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[19], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[7] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[9], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[10], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
MULADD128(mc[11], ((digit_t*)p751p1)[9], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[20], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[8] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[10], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
MULADD128(mc[11], ((digit_t*)p751p1)[10], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[21], carry, uv[0]);
ADDC(carry, uv[1], 0, carry, uv[1]);
t += carry;
mc[9] = uv[0];
uv[0] = uv[1];
uv[1] = t;
t = 0;
MULADD128(mc[11], ((digit_t*)p751p1)[11], uv, carry, uv);
t += carry;
ADDC(0, uv[0], ma[22], carry, mc[10]);
ADDC(carry, uv[1], 0, carry, uv[1]);
ADDC(0, uv[1], ma[23], carry, mc[11]);
#elif (OS_TARGET == OS_LINUX)
rdc751_asm(ma, mc);
#endif
}
static struct token *
get_string (struct linereader *lr, const struct charmap_t *charmap,
struct localedef_t *locale, const struct repertoire_t *repertoire,
int verbose)
{
int return_widestr = lr->return_widestr;
char *buf;
wchar_t *buf2 = NULL;
size_t bufact;
size_t bufmax = 56;
/* We must return two different strings. */
buf = xmalloc (bufmax);
bufact = 0;
/* We know it'll be a string. */
lr->token.tok = tok_string;
/* If we need not translate the strings (i.e., expand <...> parts)
we can run a simple loop. */
if (!lr->translate_strings)
{
int ch;
buf2 = NULL;
while ((ch = lr_getc (lr)) != '"' && ch != '\n' && ch != EOF)
ADDC (ch);
/* Catch errors with trailing escape character. */
if (bufact > 0 && buf[bufact - 1] == lr->escape_char
&& (bufact == 1 || buf[bufact - 2] != lr->escape_char))
{
lr_error (lr, _("illegal escape sequence at end of string"));
--bufact;
}
else if (ch == '\n' || ch == EOF)
lr_error (lr, _("unterminated string"));
ADDC ('\0');
}
else
{
int illegal_string = 0;
size_t buf2act = 0;
size_t buf2max = 56 * sizeof (uint32_t);
int ch;
int warned = 0;
/* We have to provide the wide character result as well. */
if (return_widestr)
buf2 = xmalloc (buf2max);
/* Read until the end of the string (or end of the line or file). */
while ((ch = lr_getc (lr)) != '"' && ch != '\n' && ch != EOF)
{
size_t startidx;
uint32_t wch;
struct charseq *seq;
if (ch != '<')
{
/* The standards leave it up to the implementation to decide
what to do with character which stand for themself. We
could jump through hoops to find out the value relative to
the charmap and the repertoire map, but instead we leave
it up to the locale definition author to write a better
definition. We assume here that every character which
stands for itself is encoded using ISO 8859-1. Using the
escape character is allowed. */
if (ch == lr->escape_char)
{
ch = lr_getc (lr);
if (ch == '\n' || ch == EOF)
break;
}
if (verbose && !warned)
{
lr_error (lr, _("\
non-symbolic character value should not be used"));
warned = 1;
}
ADDC (ch);
if (return_widestr)
ADDWC ((uint32_t) ch);
continue;
}
/* Now we have to search for the end of the symbolic name, i.e.,
the closing '>'. */
startidx = bufact;
while ((ch = lr_getc (lr)) != '>' && ch != '\n' && ch != EOF)
{
if (ch == lr->escape_char)
{
ch = lr_getc (lr);
if (ch == '\n' || ch == EOF)
break;
}
ADDC (ch);
}
if (ch == '\n' || ch == EOF)
/* Not a correct string. */
break;
if (bufact == startidx)
{
/* <> is no correct name. Ignore it and also signal an
error. */
illegal_string = 1;
continue;
}
/* It might be a Uxxxx symbol. */
if (buf[startidx] == 'U'
&& (bufact - startidx == 5 || bufact - startidx == 9))
{
char *cp = buf + startidx + 1;
while (cp < &buf[bufact] && isxdigit (*cp))
++cp;
if (cp == &buf[bufact])
{
char utmp[10];
/* Yes, it is. */
ADDC ('\0');
wch = strtoul (buf + startidx + 1, NULL, 16);
/* Now forget about the name we just added. */
bufact = startidx;
if (return_widestr)
ADDWC (wch);
/* See whether the charmap contains the Uxxxxxxxx names. */
snprintf (utmp, sizeof (utmp), "U%08X", wch);
seq = charmap_find_value (charmap, utmp, 9);
if (seq == NULL)
{
/* No, this isn't the case. Now determine from
the repertoire the name of the character and
find it in the charmap. */
if (repertoire != NULL)
{
const char *symbol;
symbol = repertoire_find_symbol (repertoire, wch);
if (symbol != NULL)
seq = charmap_find_value (charmap, symbol,
strlen (symbol));
}
if (seq == NULL)
{
#ifndef NO_TRANSLITERATION
/* Transliterate if possible. */
if (locale != NULL)
{
uint32_t *translit;
if ((locale->avail & CTYPE_LOCALE) == 0)
{
/* Load the CTYPE data now. */
int old_needed = locale->needed;
locale->needed = 0;
locale = load_locale (LC_CTYPE,
locale->name,
locale->repertoire_name,
charmap, locale);
locale->needed = old_needed;
}
if ((locale->avail & CTYPE_LOCALE) != 0
&& ((translit = find_translit (locale,
charmap, wch))
!= NULL))
/* The CTYPE data contains a matching
transliteration. */
{
int i;
for (i = 0; translit[i] != 0; ++i)
{
char utmp[10];
snprintf (utmp, sizeof (utmp), "U%08X",
translit[i]);
seq = charmap_find_value (charmap, utmp,
9);
assert (seq != NULL);
ADDS (seq->bytes, seq->nbytes);
}
continue;
}
}
#endif /* NO_TRANSLITERATION */
/* Not a known name. */
illegal_string = 1;
}
}
if (seq != NULL)
ADDS (seq->bytes, seq->nbytes);
continue;
}
}
/* We now have the symbolic name in buf[startidx] to
buf[bufact-1]. Now find out the value for this character
in the charmap as well as in the repertoire map (in this
order). */
seq = charmap_find_value (charmap, &buf[startidx],
bufact - startidx);
if (seq == NULL)
{
/* This name is not in the charmap. */
lr_error (lr, _("symbol `%.*s' not in charmap"),
(int) (bufact - startidx), &buf[startidx]);
illegal_string = 1;
}
if (return_widestr)
{
/* Now the same for the multibyte representation. */
if (seq != NULL && seq->ucs4 != UNINITIALIZED_CHAR_VALUE)
wch = seq->ucs4;
else
{
wch = repertoire_find_value (repertoire, &buf[startidx],
bufact - startidx);
if (seq != NULL)
seq->ucs4 = wch;
}
if (wch == ILLEGAL_CHAR_VALUE)
{
/* This name is not in the repertoire map. */
lr_error (lr, _("symbol `%.*s' not in repertoire map"),
(int) (bufact - startidx), &buf[startidx]);
illegal_string = 1;
}
else
ADDWC (wch);
}
/* Now forget about the name we just added. */
bufact = startidx;
/* And copy the bytes. */
if (seq != NULL)
ADDS (seq->bytes, seq->nbytes);
}
if (ch == '\n' || ch == EOF)
{
lr_error (lr, _("unterminated string"));
illegal_string = 1;
}
if (illegal_string)
{
free (buf);
free (buf2);
lr->token.val.str.startmb = NULL;
lr->token.val.str.lenmb = 0;
lr->token.val.str.startwc = NULL;
lr->token.val.str.lenwc = 0;
return &lr->token;
}
ADDC ('\0');
if (return_widestr)
{
ADDWC (0);
lr->token.val.str.startwc = xrealloc (buf2,
buf2act * sizeof (uint32_t));
lr->token.val.str.lenwc = buf2act;
}
}
void
#line 27
print_usage (void)
#line 27
{
#line 27
unsigned i;
#line 27
unsigned n;
#line 27
char buf[RMARGIN+1];
#line 27
unsigned *idxbuf;
#line 27
unsigned nidx;
#line 27
#line 27
#define FLUSH do { buf[n] = 0; printf ("%s\n", buf); n = USAGECOLUMN; memset (buf, ' ', n); } while (0)
#line 27
#define ADDC(c) do { if (n == RMARGIN) FLUSH; buf[n++] = c; } while (0)
#line 27
#line 27
idxbuf = calloc (NOPTHELP, sizeof (idxbuf[0]));
#line 27
if (!idxbuf)
#line 27
{
#line 27
fprintf (stderr, "not enough memory");
#line 27
abort ();
#line 27
}
#line 27
#line 27
n = snprintf (buf, sizeof buf, "%s %s ", _("Usage:"), "dicod");
#line 27
#line 27
/* Print a list of short options without arguments. */
#line 27
for (i = nidx = 0; i < NOPTHELP; i++)
#line 27
if (opthelp[i].opt && opthelp[i].descr && opthelp[i].opt[1] != '-'
#line 27
&& opthelp[i].arg == NULL)
#line 27
idxbuf[nidx++] = i;
#line 27
#line 27
if (nidx)
#line 27
{
#line 27
qsort (idxbuf, nidx, sizeof (idxbuf[0]), cmpidx_short);
#line 27
#line 27
ADDC ('[');
#line 27
ADDC ('-');
#line 27
for (i = 0; i < nidx; i++)
#line 27
{
#line 27
ADDC (opthelp[idxbuf[i]].opt[1]);
#line 27
}
#line 27
ADDC (']');
#line 27
}
#line 27
#line 27
/* Print a list of short options with arguments. */
#line 27
for (i = nidx = 0; i < NOPTHELP; i++)
#line 27
{
#line 27
if (opthelp[i].opt && opthelp[i].descr && opthelp[i].opt[1] != '-'
#line 27
&& opthelp[i].arg)
#line 27
idxbuf[nidx++] = i;
#line 27
}
#line 27
#line 27
if (nidx)
#line 27
{
#line 27
qsort (idxbuf, nidx, sizeof (idxbuf[0]), cmpidx_short);
#line 27
#line 27
for (i = 0; i < nidx; i++)
#line 27
{
#line 27
struct opthelp *opt = opthelp + idxbuf[i];
#line 27
size_t len = 5 + strlen (opt->arg)
#line 27
+ (opt->is_optional ? 2 : 1);
#line 27
#line 27
if (n + len > RMARGIN) FLUSH;
#line 27
buf[n++] = ' ';
#line 27
buf[n++] = '[';
#line 27
buf[n++] = '-';
#line 27
buf[n++] = opt->opt[1];
#line 27
if (opt->is_optional)
#line 27
{
#line 27
buf[n++] = '[';
#line 27
strcpy (&buf[n], opt->arg);
#line 27
n += strlen (opt->arg);
#line 27
buf[n++] = ']';
#line 27
}
#line 27
else
#line 27
{
#line 27
buf[n++] = ' ';
#line 27
strcpy (&buf[n], opt->arg);
#line 27
n += strlen (opt->arg);
#line 27
}
#line 27
buf[n++] = ']';
#line 27
}
#line 27
}
#line 27
#line 27
#ifdef HAVE_GETOPT_LONG
#line 27
/* Print a list of long options */
#line 27
for (i = nidx = 0; i < NOPTHELP; i++)
#line 27
{
#line 27
if (opthelp[i].opt && opthelp[i].descr
#line 27
&& (opthelp[i].opt[1] == '-' || opthelp[i].opt[2] == ','))
#line 27
idxbuf[nidx++] = i;
#line 27
}
#line 27
#line 27
if (nidx)
#line 27
{
#line 27
qsort (idxbuf, nidx, sizeof (idxbuf[0]), cmpidx_long);
#line 27
#line 27
for (i = 0; i < nidx; i++)
#line 27
{
#line 27
struct opthelp *opt = opthelp + idxbuf[i];
#line 27
size_t len;
#line 27
const char *longopt;
#line 27
#line 27
if (opt->opt[1] == '-')
#line 27
longopt = opt->opt;
#line 27
else if (opt->opt[2] == ',')
#line 27
longopt = opt->opt + 4;
#line 27
else
#line 27
continue;
#line 27
#line 27
len = 3 + strlen (longopt)
#line 27
+ (opt->arg ? 1 + strlen (opt->arg)
#line 27
+ (opt->is_optional ? 2 : 0) : 0);
#line 27
if (n + len > RMARGIN) FLUSH;
#line 27
buf[n++] = ' ';
#line 27
buf[n++] = '[';
#line 27
strcpy (&buf[n], longopt);
#line 27
n += strlen (longopt);
#line 27
if (opt->arg)
#line 27
{
#line 27
buf[n++] = '=';
#line 27
if (opt->is_optional)
#line 27
{
#line 27
buf[n++] = '[';
#line 27
strcpy (&buf[n], opt->arg);
#line 27
n += strlen (opt->arg);
#line 27
buf[n++] = ']';
#line 27
}
#line 27
else
#line 27
{
#line 27
strcpy (&buf[n], opt->arg);
#line 27
n += strlen (opt->arg);
#line 27
}
#line 27
}
#line 27
buf[n++] = ']';
#line 27
}
#line 27
}
#line 27
#endif
#line 27
FLUSH;
#line 27
free (idxbuf);
#line 27
}
