From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lj1-x22c.google.com (mail-lj1-x22c.google.com [IPv6:2a00:1450:4864:20::22c]) by sourceware.org (Postfix) with ESMTPS id C9F57385840D for ; Tue, 23 Apr 2024 17:38:26 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C9F57385840D Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org C9F57385840D Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::22c ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1713893917; cv=none; b=hj+ycQiYKzNLAwNsN2RqA+rl1aRljRnSiY/Xk8E2cdC3IzldbVGWCAbCq0o//gVUJ/3MLKBdMeE8hXSVTPGdF/y8L7EttT3mQm/kDbEL/pa97SnTmmIpB/FugWXD/mGT8nwc3OKXuP7ZRtR8prb81GvHepLj8ny5n6rHZBdZWvs= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1713893917; c=relaxed/simple; bh=tD4o/s3dc2Hp8k/owDe64gtwaAkOydBgcp5Z/wSyAN8=; h=DKIM-Signature:MIME-Version:From:Date:Message-ID:Subject:To; b=IV2H4zBBJQtKChMAXNPsWkMNeQD2FSnt5hNLQgz7BHPaYz7vsDLDgNlHvfRI60y9Iy/oFVAC2a9TKGPWvQsYRGHfs+dQ3GLaVEiv5bIe5VmLUgoMKRp4w81Rdv24Mfz4W19tCo7hO1vwrTBgtCjN9badd6Jn7ECLYxBJf82kVAM= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-lj1-x22c.google.com with SMTP id 38308e7fff4ca-2de232989aaso11032811fa.1 for ; Tue, 23 Apr 2024 10:38:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1713893905; x=1714498705; darn=gcc.gnu.org; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:from:to:cc:subject:date :message-id:reply-to; bh=vjArXxrrxyTHool1HC/d9GxkTe0FBgDyuWoOFi8COrY=; b=G42meHE3O78OqYZWDycIFS2rdGv9D1dr4T6Asd76gydVuIcoVLqOuB7yleCrsUjn2q 78ADkvkPuQXZ8D4dIWWxaycYp3OoY0KOa0/GZ547gNHnZxRFMtU0lB6R84KpAIAETVcJ Sw9ETSaUf+Un1B+Bkdzv4HoMUBblomw/XItEh0T5QYy3voWkcET77iTWcRsyoda6KYXE dXodixywcbA8g7AUIQ1MCqTqdpaDxx9puvZGoWVyCGO1wSKGtglrSBjAgZx1+0pMywIe nwf56y7sUYH/mog5eKYUJfxkysqruOFX+hyaEEOitk7F7UmWJUJt7t+9lBYxg8tgR+wJ bGsg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1713893905; x=1714498705; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=vjArXxrrxyTHool1HC/d9GxkTe0FBgDyuWoOFi8COrY=; b=cXTym6Sb0kP2QOzjxL4Kyv+uUd59MUOYK/5wEzLwne5zbrO3NaNUmJotB0Q9BwFV1X Z9pwiQG/Mq8tO/fWSb418+UL/N8tPO6FcSbUoWB22bNFwH9ADu/whsfPQ+ioDIt+Inls YXOMoFwEbZa8/HtLJKgRsX32HzYhLbzHl9GYSXWJZ1DFE+LpwvOUICGzG7a7hXB7sLbV b8BVIiccBU0Kz8707KiI0RjcdoQx7OcnS0jp1YNScVc2YOxPqGnxlQuxgru9ttahQ1Cy Lpv22kCzdzWbpfMFVxmkXFSJJNmd2IBELACJojyjJSlxpNCgkOgu345mHryDIc9/8fKd j/yw== X-Gm-Message-State: AOJu0YzC9hMkJtz3hm1UkspinicmO2i+yeiEBnf5E7CxXf2BioAlW9+e NAQZe57d8Nl7W+pJUWU74eIp3eNlaba1ik/XeopGuSEIADePUQlpRKkAjxDUbTLjQosLmyaEMxZ JQTGCxoQu3ETQIikkpKhYPmjdP/jOEA== X-Google-Smtp-Source: AGHT+IF+OMZJpMtibVSl+KgKTcztZDOr3OQw3EeZSxANcJ5tBjGBbJKQLNnKdWsnmuDGORjc/mjtsXgBi0+LSJe48/c= X-Received: by 2002:a2e:86d4:0:b0:2da:4e78:aabe with SMTP id n20-20020a2e86d4000000b002da4e78aabemr9195203ljj.43.1713893904693; Tue, 23 Apr 2024 10:38:24 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Uros Bizjak Date: Tue, 23 Apr 2024 19:38:12 +0200 Message-ID: Subject: Re: [PATCH] i386: Avoid =&r,r,r andn double-word alternative for ia32 [PR114810] To: Jakub Jelinek Cc: gcc-patches@gcc.gnu.org Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Spam-Status: No, score=2.8 required=5.0 tests=BAYES_50,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM,LIKELY_SPAM_BODY,RCVD_IN_DNSWL_NONE,SCC_10_SHORT_WORD_LINES,SCC_5_SHORT_WORD_LINES,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=no autolearn_force=no version=3.4.6 X-Spam-Level: ** X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On Tue, Apr 23, 2024 at 5:50=E2=80=AFPM Jakub Jelinek wr= ote: > > Hi! > > As discussed in the PR, on ia32 with its 8 GPRs, where 1 is always fixed > and other 2 often are as well having an alternative which needs 3 > double-word registers is just too much for RA. > The following patch splits that alternative into two, one with o is used > even on ia32, but one with the 3x r is used just for -m64/-mx32. > Tried to reduce the testcase further, but it wasn't easily possible. > > Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk? > > 2024-04-23 Jakub Jelinek > > PR target/114810 > * config/i386/i386.md (*andn3_doubleword_bmi): Split the =3D= &r,r,ro > alternative into =3D&r,r,r enabled only for x64 and =3D&r,r,o. > > * g++.target/i386/pr114810.C: New test. OK. Thanks, Uros. > > --- gcc/config/i386/i386.md.jj 2024-04-15 14:25:58.203322878 +0200 > +++ gcc/config/i386/i386.md 2024-04-23 12:15:47.171956091 +0200 > @@ -12482,10 +12482,10 @@ (define_split > }) > > (define_insn_and_split "*andn3_doubleword_bmi" > - [(set (match_operand: 0 "register_operand" "=3D&r,r,r") > + [(set (match_operand: 0 "register_operand" "=3D&r,&r,r,r") > (and: > - (not: (match_operand: 1 "register_operand" "r,0,r")) > - (match_operand: 2 "nonimmediate_operand" "ro,ro,0"))) > + (not: (match_operand: 1 "register_operand" "r,r,0,r")= ) > + (match_operand: 2 "nonimmediate_operand" "r,o,ro,0"))) > (clobber (reg:CC FLAGS_REG))] > "TARGET_BMI" > "#" > @@ -12496,7 +12496,8 @@ (define_insn_and_split "*andn3_doub > (parallel [(set (match_dup 3) > (and:DWIH (not:DWIH (match_dup 4)) (match_dup 5))) > (clobber (reg:CC FLAGS_REG))])] > - "split_double_mode (mode, &operands[0], 3, &operands[0], &operand= s[3]);") > + "split_double_mode (mode, &operands[0], 3, &operands[0], &operand= s[3]);" > + [(set_attr "isa" "x64,*,*,*")]) > > (define_insn_and_split "*andn3_doubleword" > [(set (match_operand:DWI 0 "register_operand") > --- gcc/testsuite/g++.target/i386/pr114810.C.jj 2024-04-23 14:21:19.20261= 3799 +0200 > +++ gcc/testsuite/g++.target/i386/pr114810.C 2024-04-23 14:24:22.81311= 6589 +0200 > @@ -0,0 +1,861 @@ > +// PR target/114810 > +// { dg-do compile { target { { { *-*-linux* } && ia32 } && c++17 } } } > +// { dg-options "-mstackrealign -O2 -mbmi -fno-exceptions -fno-plt -marc= h=3Dx86-64 -w" } > +// { dg-additional-options "-fpie" { target pie } } > + > +enum E1 { a, dp, b, jm, c, dq, d, mj, e, dr, f, jn, h, dt, j, nt, l, du,= m, jo, n, dv, o, mk, p, dw, q, jp, s, dx, t, ol, u, dy, v, jq, w }; > +enum dz { x, ml, y }; > +struct ea { short g; } z, jr; > +long long aa; > +struct eb { ea ab; ea dp[]; }; > +enum ac { }; > +typedef enum { } nu; > +struct ad { ac k; }; > +unsigned ec (long); > +struct ae; > +int js (ae); > +unsigned af (); > +struct ed; > +template < int ag > struct ee { using ah =3D ed[ag]; }; > +template < int ag > struct array { typename ee < ag >::ah ai; ed & opera= tor[] (int aj) { return ai[aj]; } }; > +struct { void dp (...); } ak; > +void ef (int); > +template < typename al > struct jt { al & operator[] (short); }; > +struct am { void operator=3D (bool); }; > +struct an { am operator[] (unsigned); }; > +template < typename, unsigned, unsigned >using eg =3D an; > +struct ao; > +struct ae { ae (ao *); }; > +struct mm { mm (); mm (int); }; > +enum ap { }; > +enum eh { }; > +bool aq, ju, ar, ei, nv, as, ej, at; > +struct jv > +{ > + jv (eh au):dp (au) {} > + jv (); > + operator eh (); > + unsigned av () > + { > + aq =3D dp & 7; > + return dp * (aq ? : 4); > + } > + unsigned ek () > + { > + int aw; > + bool mn =3D dp & 7; > + aw =3D dp * (mn ? : 4); > + return aw + 3 >> 2; > + } > + eh dp; > +} ax, el, ay, jw, az, em, ba, om; > +struct ed > +{ > + ed ():bb (), dp () {} > + int bc () { return bb; } > + jv en () { return (eh) dp; } > + unsigned ek () > + { > + jv bd; > + bd =3D (eh) dp; > + return bd.ek (); > + } > + ap jx (); > + unsigned bb:24; > + int dp:8; > +}; > +struct be { short dp =3D 0; } bf, eo; > +struct bg > +{ > + bg (); > + bg (ed r) > + { > + dp.bh =3D r; > + if (r.bc ()) > + mo =3D true; > + else > + bi =3D true; > + } > + static bg ep (int); > + bg (be); > + struct { ed bh; } dp; > + union { char mo:1; char bi:1; short bj =3D 0; }; > +} jy, bk, eq, bl, mp, bm, er; > +struct bn > +{ > + explicit bn (ed bo):bh (bo) {} > + ed dp (); > + ed bh; > + be es; > + char bj =3D 0; > +}; > +struct bp > +{ > + eg < int, 6, 4 > dp; > +}; > +jt < bg > bq; > +jt < bn > definitions; > +struct ao > +{ > + bp & br (); > +}; > +enum jz:short; > +template < typename > using bs =3D ae; > +ao *et (); > +short bt, nw; > +struct bu > +{ > + int dp; > +}; > +dz bv; > +unsigned eu; > +struct bw > +{ > + ac k; > + unsigned dp; > +} *bx; > +bool ka (); > +struct by > +{ > + bool dp; > +}; > +typedef enum > +{ bz, ev } ca; > +typedef enum > +{ > + mq, cb, ew, cc, kb, cd, ex, ce > +} on; > +typedef struct cf > +{ > + on jx; > + char dp; > + char cg; > +} kc; > +struct ch > +{ > + kc *dp; > +}; > +typedef enum > +{ > + ci, ey, cj, mr, ck, ez, cl, kd, cm, fa, cn, nx, co, fb, cp, ke, cq, fc= , > + cr, ms, cs, fd, ct, kf, cu, fe, cv, os, cw, ff, cx, kg, cy, fg, cz, mt= , da > +} fh; > +typedef struct { cf db; fh dp; kc dc; ch kh[]; } dd; > +nu fi (); > +typedef enum > +{ de, ny } fj; > +typedef struct { fj jx; } df; > +typedef struct { by dp; } dg; > +dg *ki; > +struct dh > +{ > + ad *dp; > + eb *args; > + bw *di; > + bu *block; > + struct > + { > + struct > + { > + bool fk; > + } dj; > + bool dp; > + bool dk; > + } mu; > + ed dl[84]; > +}; > +ed fl (dh *, ea); > +enum dm > +{ }; > +dm kj (); > +enum > +{ dn }; > +struct fm > +{ > + operator ed (); > + operator bg (); > + bn dc (); > + ao *operator-> (); > +}; > +struct oo > +{ > + oo (ed); > + oo (bg); > + oo (fm); > +}; > +struct fn > +{ > + enum dp > + { > + kk, fo, mv, fp, kl, fq > + }; > + jv lm; > + fn (bw *, bu *); > + fn fr (); > + ed bo (jv); > + bn dc (); > + bn dc (be); > + ed km (oo); > + fm copy (bn, oo); > + fm fs (); > + fm nz (bn, oo, oo, oo); > + void ft (oo); > + void ft (E1, bn, oo); > + fm ft (E1, bn, oo, oo); > + void ft (E1, bn, oo, oo, oo); > + void ft (E1, bn, bn, oo); > + void kn (E1, bn, oo); > + fm kn (dp, bn, oo); > + fm kn (dp, bn, bn, oo); > + fm fu (E1, bn, oo, oo); > + fm fu (E1, bn, bn, oo, oo); > + fm fu (dp, bn, bn, oo, oo); > + fm mw (E1, bn, int); > + fm fv (E1, bn, oo, oo); > + fm fv (dp, bn, oo, oo); > + void dp (E1, bn, mm, bool =3D false, bool =3D false, bool =3D false); > + void dp (E1, bn, oo, oo, mm =3D false, bool =3D false, bool =3D false)= ; > + fm ds (E1, bn, oo, short, char =3D 0, bool =3D false); > + fm ds (E1, bn, oo, oo, short =3D 0, char =3D 0, bool =3D false); > + fm ko (E1, bn, oo, oo); > + fm ko (E1, bn, oo, oo, oo); > + fm fw (E1, bn, oo, oo); > + fm dp (E1, bn, oo, oo, oo); > + fm oy (E1, bn, oo, short, char, char, bool, bool); > + fm fx (E1, bn, oo, oo, oo); > +}; > +int kp, fy, mx, fz, kq, ga, oa, gb; > +int *kr, *gc, *my; > +long gd; > +ca ks; > +namespace > +{ > + void ge (dh *, char *, unsigned, cf *, char *); > + ed kt (dh *, kc *); > + ed gf (dh *, ed, bg =3D bg (), bg =3D bg ()); > + void mz (bool); > + ed gg (dh *, fn, ed, ed); > + ed ku (dh *, fn, ed, unsigned, bool); > + ed gh (dh *, ed); > + void op (dh *, ed, int, ed); > + ed op (dh *, ed, int, jv); > + void gi (dh *, ed, unsigned); > + void kv (dh *, ed, bg, ed); > + ed gj (dh *, ed, ed =3D ed ()); > + void na (dh *, int *); > + void gk (dh *, ed, ed); > + ed kw (dh *); > + bool gl (dh *); > + void ob (dh *, dd *); > + void gm (dh * ctx, dd * db) > + { > + fn bld (ctx->di, ctx->block); > + ed dst =3D kt (ctx, &db->dc), dp =3D kt (ctx, db->kh[0].dp), kx, gn; > + unsigned count =3D db->dc.dp; > + if (db->dc.cg) > + count *=3D 2; > + if (kr && db->dc.cg) > + { > + long dp =3D count =3D=3D 4 ? 0 : (1ull << (count & 3)) - 1 << mx; > + if ((aa | dp) =3D=3D aa && mx + count) > + { > + array < 16 > elems; > + bs < ao > gn > + { > + et ()}; > + unsigned g =3D ec (aa & mx ? : 1 << mx - 1); > + for (unsigned i; count; ++i) > + { > + elems[i] =3D fl (ctx, ctx->args->dp[g]); > + bq[i] =3D elems[i]; > + } > + definitions[0] =3D bn (dst); > + int dp =3D js (gn), ot =3D dst.bc (); > + ef (dp); > + ak.dp (ot, elems); > + } > + } > + ed go =3D bld.km (dp); > + if (kp) > + { > + bg dp =3D bg::ep (kp); > + bn ky =3D bld.dc (), gp =3D bld.dc (eo); > + go =3D bld.fr ().fu (e, ky, gp, dp, go); > + } > + ed nb =3D fl (ctx, ctx->args->ab); > + bool aligned; > + if (db->dc.cg) > + aligned =3D kr && fy % 4; > + bool gq =3D count =3D=3D 1 || kr && kp + fy % 4 + count; > + if (aligned) > + gn =3D gq ? bld.bo (ax) : bld.bo (el); > + E1 kz; > + switch (gn.ek ()) > + { > + case 1: > + kz =3D dt; > + break; > + case 2: > + kz =3D j; > + break; > + case 3: > + gn =3D bld.bo (ay) =3D bld.bo (jw); > + ei =3D true; > + } > + bld.dp (kz, bn (gn), kx, go); > + if (aligned) > + { > + bg dp =3D kr ? bg::ep (kp + fy % 4) : go; > + kv (ctx, gn, dp, dst); > + } > + if (ei) > + { > + gi (ctx, gn, 4); > + jv dp =3D dst.ek ()? ax : el; > + ed gr =3D op (ctx, gn, 2, dp), > + oc =3D op (ctx, gn, 0, dp), gs =3D op (ctx, gn, 1, dp); > + bld.ft (jm, bn (dst), oc, gs, gr); > + } > + gi (ctx, dst, db->dc.dp); > + } > + jz la (ca, unsigned); > + void gt (dh *, dd *, ed); > + bool nc (dh *, dd *); > + void gu (dh *, E1, jz, unsigned, bn, ed); > + void lb (dh *, jz, bn, ed); > + bool gv (dh *, ed &, ed, unsigned, long); > + dh *pb; > + bu *gw; > + dd *lc; > + bool gx; > + jv nd; > + void gy () > + { > + fn bld (pb->di, gw); > + switch (lc->dp) > + { > + case ms: > + ob (pb, lc); > + case ke: > + gm (pb, lc); > + case fb: > + ob (pb, lc); > + case fc: > + ob (pb, lc); > + case fg: > + ob (pb, lc); > + case cp: > + { > + if (bv =3D=3D x || bv =3D=3D y) > + { > + ed dp =3D kt (pb, &lc->dc), ld =3D kw (pb); > + bld.copy (bn (dp), ld); > + } > + if (eu <=3D pb->di->dp) > + gf (pb, kt (pb, &lc->dc)); > + ed dp =3D bld.bo (az), bc =3D gf (pb, dp), gz =3D > + fl (pb, jr), od =3D kt (pb, &lc->dc); > + if (pb->di->dp) > + { > + bn dp =3D bld.dc (), ha =3D bld.dc (eo); > + ed le =3D fl (pb, jr), hb =3D bld.fu (dr, dp, ha, jy, le), = ne =3D kt (pb, &lc->dc); > + bld.ko (jq, bn (ne), hb, bc); > + } > + bn hc =3D bld.dc (), lf =3D bld.dc (eo); > + bg hd =3D bg::ep (0), oq =3D bg::ep (5); > + ed hb =3D bld.fu (f, hc, lf, gz, hd); > + bld.dp (u, bn (od), hb, oq, bc); > + } > + case cr: > + { > + ed dp =3D kt (pb, &lc->dc); > + gf (pb, dp); > + } > + case mr: > + case ey: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dst =3D kt (pb, &lc->dc); > + if (lc) > + if (lc->kh[0].dp->cg && kh.en ()) > + { > + bn he =3D bld.dc (); > + bg dp; > + kh =3D bld.fw (dx, he, dp, kh); > + } > + if (lc->kh[0].dp->cg && kh.en ()) > + { > + bn lg =3D bld.dc (); > + bg dp; > + kh =3D bld.fw (t, lg, dp, kh); > + } > + ge (pb, "", 8, &lc->db, ""); > + bn dc =3D bld.lm.ek ()? bn (dst) : bld.dc (); > + if (lc->dp) > + kh =3D bld.copy (dc, kh); > + else > + { > + bn hf =3D bld.dc (); > + kh =3D bld.fu (fn::kk, dc, hf, kh, bg (bf)); > + } > + if (dst.ek () !=3D bld.lm.ek ()) > + { > + bg dp; > + bld.ft (jm, bn (dst), kh, dp); > + } > + mz (pb); > + } > + case nx: > + { > + ed nf =3D kt (pb, lc->kh[0].dp), kh =3D bld.km (nf), dst =3D kt= (pb, &lc->dc); > + if (kh.ek ()) > + op (pb, kh, 0, dst); > + if (dst.ek ()) > + { > + bg dp; > + bld.ft (jm, bn (dst), kh, dp); > + } > + bld.copy (bn (dst), kh); > + } > + case cy: > + case ff: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), delta =3D kt (pb, lc->kh[1].dp= ), dst =3D > + kt (pb, &lc->dc), bo, hg, hi, dp =3D bld.bo (az), hh =3D gf (= pb, dp), lh =3D bld.fs (); > + if (ka ()) > + gt (pb, lc, kh); > + { > + ed hh =3D kt (pb, lc->kh[1].dp) =3D kt (pb, &lc->dc) =3D gh (= pb, kh); > + if (lc || ka ()) > + hh =3D bld.km (hh); > + if (nd =3D=3D ba || kh.en ()) > + bo =3D bld.bo (az) =3D gg (pb, bld, hh, kh); > + if (dst.jx ()) > + bld.dc (); > + bld.ft (mj, bn (dst), bo); > + bld.ft (b, bn (dst), bo); > + if (kh.en ()) > + bo =3D gg (pb, bld, hh, kh); > + bld.copy (bn (dst), bo); > + if (kh.en () =3D=3D em) > + { > + hg =3D bld.bo (az) =3D bld.bo (az); > + bld.ft (mj, bn (hg), kh); > + gg (pb, bld, hh, hg) =3D gg (pb, bld, hh, hi); > + bld.ft (jm, bn (dst), hg, hi); > + gi (pb, dst, 2); > + } > + ge (pb, "", 4, &lc->db, ""); > + mz (pb); > + } > + kt (pb, lc->kh[0].dp); > + if (ka ()) > + gt (pb, lc, kh); > + if (fz) > + bld.copy (bn (dst), kh); > + delta =3D bld.km (delta) =3D gh (pb, kh); > + if (ka () && gv (pb, bo, kh, fz, gd)) > + { > + bn dp =3D bld.dc (), oe =3D bld.dc (); > + bg hj =3D bg::ep (0); > + ed li =3D > + bld.fv (jn, dp, delta, hj), hk =3D ku (pb, bld, kh, oa, t= rue); > + gj (pb, li) =3D bld.ko (ol, oe, hk, kh, li); > + } > + if (pb->di->k && fz) > + { > + bn dp =3D bld.dc (), ng =3D bld.dc (eo), hl =3D bld.dc (), = lj =3D bld.dc (eo); > + delta =3D bld.fu (dr, dp, ng, delta, bk); > + bg hm =3D bg::ep (2); > + delta =3D bld.fu (nt, hl, lj, delta, hm); > + } > + bn ou =3D bld.dc (), hn =3D bld.dc (), lk =3D bld.dc (), ho =3D= bld.dc (eo) =3D bld.dc (), nh =3D bld.dc (eo) =3D bld.dc (), hp =3D bld.dc= (eo) =3D bld.dc (), ll =3D bld.dc (eo), hq =3D bld.dc (); > + bg of =3D bg::ep (0), hr =3D bg::ep (64) =3D bld.fu (q, nh, hr,= delta); > + if (fz) > + { > + bn dp =3D bld.dc (), ni =3D bld.dc () =3D bld.dc (), hs =3D= bld.dc (), ln =3D bld.dc (), ht =3D bld.dc (), oz =3D bld.dc (), hu =3D bl= d.dc (), lo =3D bld.dc (); > + ed hv =3D bld.fu (du, ni, hg, delta), nj =3D bld.fu (nt, hs= , hg, delta); > + if (fz) > + { > + bn dp =3D bld.dc () =3D bld.dc (), hw =3D bld.dc (), lp= =3D bld.dc () =3D bld.dc (), hx =3D bld.dc (); > + bg og =3D bg::ep (4444), hy =3D bg::ep (32); > + ed lotolohi =3D bld.copy (dp, og), hz =3D bld.fu (dv, h= w, hv, lotolohi) =3D > + bld.fu (mk, lp, hv, hz) =3D bld.fu (q, hx, hy, delta)= ; > + } > + hg =3D bld.fu (dv, ln, ht, hv, nj); > + bg lq =3D bg::ep (88888888); > + ed ia =3D bld.copy (oz, lq); > + hi =3D bld.fu (dv, hu, lo, hg, ia); > + } > + else > + { > + bn dp =3D bld.dc (); > + bg nk =3D bg::ep (4275878552); > + hi =3D bld.copy (dp, nk); > + } > + ed hz =3D bld.ft (jm, hn, hg, hi); > + ed hv =3D bld.fu (m, lk, ho, hz, delta); > + ed nj =3D bld.fu (l, hp, hz, delta); > + hz =3D bld.fu (o, ll, hv, nj); > + hg =3D bld.bo (ax) =3D bld.bo (ax); > + bld.ft (mj, bn (hg), bn (hi), hz); > + fm ib =3D bld.dp (w, hq, kh, hg, hi); > + bp & lr =3D ib->br (), &ic =3D ib->br (); > + lr.dp[0] =3D true; > + ic.dp[1] =3D true; > + if (pb->di && fz) > + { > + bn dp =3D bld.dc (), ov =3D bld.dc (), id =3D bld.dc (); > + bg ls =3D bg::ep (2), ie =3D bg::ep (1); > + ed nl =3D bld.ko (dy, dp, ls, lh); > + bo =3D bld.ds (a, ov, nl, kh); > + lh =3D bld.dp (s, id, ie, lh, hh); > + } > + bo =3D gg (pb, bld, lh, kh); > + jv ig; > + bo =3D op (pb, bo, 0, ig); > + bld.copy (bn (dst), bo); > + mz (pb); > + } > + case cq: > + { > + ed dp =3D kt (pb, &lc->dc), lt =3D fl (pb, z); > + bg ih =3D bg::ep (8), oh =3D bg::ep (4); > + bld.dp (jp, bn (dp), lt, ih, oh); > + } > + case cw: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dst =3D kt (pb, &lc->dc); > + if (lc->dc.cg) > + { > + bn dp =3D bld.dc (eo), ii =3D bld.dc (); > + fm lu =3D bld.kn (fn::kl, ii, bg (bf)); > + ed bo =3D bld.fv (fn::fp, dp, kh, lu); > + gj (pb, dst); > + } > + gk (pb, kh, dst); > + mz (pb); > + } > + case ci: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dst =3D kt (pb, &lc->dc); > + if (kh.jx ()) > + bld.ft (b, bn (dst), kh); > + bld.copy (bn (dst), kh); > + } > + case mt: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dst =3D kt (pb, &lc->dc); > + bn dp =3D bld.dc (), ij =3D bld.dc (eo), nm =3D > + bld.dc (), ik =3D bld.dc (eo), lv =3D bld.dc (eo); > + ed bo =3D bld.kn (fn::fo, dp, ij, kh); > + bld.fu (fn::kk, nm, ik, bo, bg (bf)).dc ().dp (); > + ed cond =3D gj (pb, bo); > + bld.kn (fn::fo, bn (dst), lv, cond); > + mz (pb); > + } > + case da: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dst =3D kt (pb, &lc->dc) =3D g= j (pb, kh); > + gj (pb, dst); > + } > + case os: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dp =3D kt (pb, &lc->dc); > + bn il =3D bld.dc (), pc =3D bld.dc (eo), im =3D bld.dc (eo); > + kh =3D bld.fu (fn::kk, il, pc, kh, bg (bf)); > + bld.kn (fn::mv, bn (dp), im, kh); > + mz (pb); > + } > + case cv: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dp =3D kt (pb, &lc->dc); > + bn lw =3D bld.dc (), in =3D bld.dc (eo), nn =3D bld.dc (), io = =3D bld.dc (eo), lx =3D bld.dc (), ip =3D bld.dc (eo), oi =3D bld.dc (eo); > + kh =3D bld.kn (fn::fo, lw, in, kh); > + kh =3D bld.fu (fn::kk, nn, io, kh, bg (bf)); > + kh =3D bld.kn (fn::mv, lx, ip, kh); > + bld.kn (fn::fo, bn (dp), oi, kh); > + mz (pb); > + } > + case cx: > + case cn: > + case cm: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dst =3D kt (pb, &lc->dc); > + unsigned dp =3D lc->dp ? af () : af (); > + if (ka () =3D=3D pb->di->dp) > + if (lc->dp) > + if (nc (pb, lc)) > + if (nc (pb, lc)) > + break; > + jv iq; > + kh =3D op (pb, kh, 0, iq); > + jz ly =3D la (ks, lc->kh[0].dp->cg); > + switch (lc->dp) > + { > + case cx: > + case cn: > + case cm: > + break; > + default: > + __builtin_unreachable (); > + } > + bool ir =3D ks =3D=3D bz || ks =3D=3D ev && dst.jx (); > + if (ir) > + lb (pb, ly, bn (dst), kh); > + gu (pb, dq, ly, dp, bn (dst), kh); > + mz (pb); > + } > + case fe: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dst =3D kt (pb, &lc->dc); > + if (gx) > + gt (pb, lc, kh); > + switch (lc->dp) > + { > + case kf: > + kj (); > + case cu: > + case ct: > + nw =3D kj (); > + case fe: > + nw =3D af (); > + nv &=3D ka (); > + case fd: > + nw =3D kj (); > + } > + if (lc->dc.cg) > + { > + bn dp =3D bld.dc (); > + bg lz; > + kh =3D bld.fx (ol, dp, lz, eq, kh); > + } > + if (lc->dc.cg) > + kh =3D gh (pb, kh); > + if (lc->dc.cg && lc->dp) > + { > + bn dp =3D bld.dc (), is =3D bld.dc (), no =3D bld.dc (eo), = it =3D bld.dc (), ma =3D bld.dc (eo), iu =3D bld.dc (eo); > + bg oj =3D bld.lm.av ()? bg::ep (kq) : bld.ft (jm, dp, bl, m= p); > + kh =3D bld.fu (fn::kk, is, no, kh, bg (bf)); > + kh =3D bld.fu (fn::kk, it, ma, oj, kh); > + bld.kn (fn::mv, bn (dst), iu, kh); > + } > + if (lc || lc->dc.cg) > + { > + unsigned iv =3D lc->dc.cg / 8; > + bn dc =3D iv || lc->dc.cg ? bld.dc () : bn (dst); > + if (pb->di->k) > + bld.oy (v, dc, kh, nw, 5, 5, true, nv); > + bld.ds (dp, dc, kh, 5 | nw); > + if (iv) > + { > + bn dp =3D bld.dc (); > + ed mb =3D dc.dp (); > + bld.ft (mj, bn (dst), dp, mb); > + } > + if (lc->dc.cg) > + { > + bg dp; > + ed iw =3D dc.dp (); > + bld.fw (dx, bn (dst), dp, iw); > + } > + } > + if (lc->dc.cg) > + { > + ed hg, hi =3D bld.ft (mj, bn (hg), hi, kh); > + if (pb->di->k) > + { > + bn dp =3D bld.dc (), np =3D bld.dc (); > + hg =3D bld.oy (v, dp, hg, nw, 5, 5, true, nv); > + hi =3D bld.oy (v, np, hi, nw, 5, 5, true, nv); > + } > + bn ix =3D bld.dc (), mc =3D bld.dc (); > + hg =3D bld.ds (dp, ix, hg, nw); > + hi =3D bld.ds (dp, mc, hi, 5 | nw); > + bld.ft (jm, bn (dst), hg, hi); > + gi (pb, dst, 2); > + } > + ge (pb, "", 4, &lc->db, ""); > + mz (pb); > + kh =3D kt (pb, lc->kh[0].dp) =3D kt (pb, &lc->dc); > + gt (pb, lc, kh); > + bool dp =3D ka (); > + if (lc->dc.cg) > + kh =3D gh (pb, kh); > + if (lc->dc.cg) > + { > + bn iy =3D bld.dc (); > + bg ow, iz; > + kh =3D bld.fx (ol, iy, ow, bm, kh); > + kh =3D ku (pb, bld, kh, ga, dp); > + bld.fw (dx, bn (dst), iz, kh); > + } > + if (dst.en ()) > + { > + ed bo =3D ku (pb, bld, kh, ga, dp); > + op (pb, bo, 0, dst); > + } > + if (dst.en () =3D=3D om) > + { > + ed bo =3D ku (pb, bld, kh, ga, dp); > + op (pb, bo, 0, dst); > + } > + if (dst.en () =3D=3D az) > + { > + ed md =3D ku (pb, bld, kh, ga, dp); > + bld.copy (bn (dst), md); > + } > + if (dst.en () =3D=3D em) > + { > + ed hg =3D bld.bo (az), hi =3D bld.bo (az); > + bld.ft (mj, bn (hg), hi, kh); > + hg =3D ku (pb, bld, hg, ga, dp) =3D ku (pb, bld, hi, ga, dp= ); > + bld.ft (jm, bn (dst), hg, hi); > + gi (pb, dst, 2); > + } > + ge (pb, "", 5, &lc->db, ""); > + mz (pb); > + } > + { > + ed dp =3D kt (pb, lc->kh[0].dp), kh =3D gh (pb, dp), ja =3D kt = (pb, lc->kh[1].dp), nq =3D bld.km (ja), jb =3D kt (pb, lc->kh[2].dp), lane = =3D bld.km (jb), dst =3D kt (pb, &lc->dc); > + if (dst.en ()) > + bld.nz (bn (dst), nq, lane, kh); > + if (dst.en ()) > + { > + ed dp =3D bld.bo (az), jc =3D bld.bo (az), me =3D bld.bo (a= x), jd =3D bld.bo (ax); > + bld.ft (mj, bn (dp), bn (jc), kh); > + bld.ft (mj, bn (me), bn (jd), nq); > + bn ok =3D bld.dc (), je =3D bld.dc (); > + ed hg =3D bld.nz (ok, me, lane, jc); > + ed hi =3D bld.nz (je, jd, lane, jc); > + bld.ft (jm, bn (dst), hg, hi); > + gi (pb, dst, 2); > + } > + ge (pb, "", 8, &lc->db, ""); > + } > + case cs: > + { > + ed kh =3D kt (pb, lc->kh[0].dp), dp =3D kt (pb, lc->kh[1].dp), = mf =3D gh (pb, dp), dst =3D kt (pb, &lc->dc) =3D op (pb, kh, 0, jv ()); > + gf (pb, dst, kh, mf); > + mz (pb); > + kh =3D kt (pb, lc->kh[0].dp) =3D kt (pb, &lc->dc); > + if (kh.en ()) > + bld.copy (bn (dst), kh); > + if (dst.en () && kh.en ()) > + { > + ed dp =3D kt (pb, lc->kh[1].dp), jf =3D bld.km (dp), nr =3D= kt (pb, lc->kh[2].dp), jg =3D bld.km (nr); > + bld.dp (w, bn (dst), kh, jf, jg); > + } > + ge (pb, "", 4, &lc->db, ""); > + kt (pb, &lc->dc); > + bld.ft (d, bn (dst), bg ()); > + } > + if (lc->dp) > + { > + ed kh =3D kt (pb, lc->kh[0].dp); > + bn dp =3D bld.dc (), mg =3D bld.dc (eo); > + er =3D bld.fu (fn::kk, dp, mg, kh, bg (bf)); > + } > + bld.ft (er); > + if (bt || pb->mu.dj.fk) > + pb->mu.dk =3D gw->dp |=3D ju; > + if (ki->dp.dp) > + ar =3D true; > + case cz: > + case ck: > + case cl: > + { > + bg cond =3D bg::ep (1); > + if (lc->dp =3D=3D cl || lc->dp =3D=3D cz) > + { > + ed kh =3D kt (pb, lc->kh[0].dp); > + bn dp =3D bld.dc (), jh =3D bld.dc (eo); > + cond =3D bld.fu (fn::kk, dp, jh, kh, bg (bf)); > + pb->mu.dp |=3D ka (); > + } > + bld.ft (cond); > + if (bt || pb->mu.dj.fk) > + pb->mu.dk =3D pb->mu.dp |=3D gl (pb); > + gw->dp |=3D ju; > + } > + case fa: > + { > + ed dp =3D kt (pb, &lc->dc); > + bld.kn (fn::kl, bn (dp), bg (bf)); > + } > + mz (pb); > + case co: > + { > + bn pa =3D bld.dc (), dp =3D bld.dc (eo); > + ed flbit =3D bld.kn (fn::fq, pa, bg (bf)), ji =3D kt (pb, &lc->= dc); > + bg mh =3D bg::ep (pb->di->dp - 1); > + bld.fu (dw, bn (ji), dp, mh, flbit); > + mz (pb); > + } > + case kd: > + { > + ed dp =3D kt (pb, &lc->dc); > + bld.ft (c, bn (dp), bg (bf)); > + } > + mz (pb); > + case kg: > + ed dst =3D kt (pb, &lc->dc); > + if (fi () && pb->dp->k) > + { > + bn jj =3D bld.dc (); > + ed clock =3D bld.mw (h, jj, 9); > + bg dp; > + bld.ft (jm, bn (dst), clock, dp); > + } > + if (fi () && pb->dp->k) > + { > + bg ns =3D bg::ep (dn); > + bld.kn (p, bn (dst), ns); > + E1 dp =3D fi ()? jo : n; > + bld.dp (dp, bn (dst), 0); > + } > + gi (pb, dst, 2); > + } > + } > + dh *jk; > + void mi (bool, bool, bool) > + { > + mm (); > + for (df * dp (ka ()? (df *) bx : __null); > + dp; dp =3D ka ()? (df *) bx : __null) > + switch (dp->jx) > + { > + case de: > + for (cf * db (ka ()? (cf *) bx : __null); > + db; db =3D ka ()? (cf *) bx : __null) > + switch (db->jx) > + { > + case mq: > + na (jk, gc); > + case kb: > + na (jk, my); > + case cc: > + gy (); > + case ew: > + mm (); > + case ce: > + mm (); > + case ex: > + mm (); > + case cb: > + case cd: > + mm (); > + ge (jk, "", 6, db, ""); > + } > + mm (); > + case ny: > + mm (); > + } > + } > +} > +void > +jl () > +{ > + dh ctx; > + if (gb) > + mi (as, ej, at); > +} > > Jakub >