Factor out legalization of undef, and handle more cases for ARM.

Factor out legalization of undef, and handle more cases for ARM.

By factoring out legalizeUndef(), we can use the same
logic in prelowerPhis which may help if we ever change the
value used (though if we switch from zero-ing out regs to
using uninitialized regs, it'll take more work -- e.g.,
can't return a 64-bit reg).

For x86, use legalizeUndef where it's clear that the value
is immediately fed to loOperand/hiOperand then another
legalize() call. Otherwise, leave the general
X = legalize(X); alone where the code is counting on that
being the sole legalization.

For x86 legalize(const64) is a pass-through, which can then
be passed to loOperand/hiOperand nicely. However, for ARM,
legalize(const64) may end up trying to copy the const64 to
a register, but we don't have 64-bit registers. Instead do
legalizeUndef(X) where x86 would have just done
legalize(X). This happens to work because legalizeUndef
doesn't try to copy to reg, and we immediately pass the
result to loOperand/hiOperand() which then passes the
result to a real legalization call.

Add a few more undef tests.

BUG= https://code.google.com/p/nativeclient/issues/detail?id=4076
R=stichnot@chromium.org

Committed: https://gerrit.chromium.org/gerrit/gitweb?p=native_client/pnacl-subzero.git;a=commit;h=fbdd244013aad0808220386eb6bd17eb0635dd4c

[jvoung (off chromium), 2015-07-13 18:28:54]

jvoung@chromium.org changed reviewers:
+ jpp@chromium.org, stichnot@chromium.org

[Jim Stichnoth, 2015-07-13 22:37:04]

LGTM

That said, this change makes me nervous because for new lowering code, I'm not
sure I would reliably use the right versions of legalize, or that it's
sufficiently tested, given that many of the problems arise from advanced phi
lowering.

It deserves another look once the register allocator can handle forcible
spilling for phi lowering.

[jvoung (off chromium), 2015-07-14 17:11:23]

On 2015/07/13 22:37:04, stichnot wrote:
> LGTM
> 
> That said, this change makes me nervous because for new lowering code, I'm not
> sure I would reliably use the right versions of legalize, or that it's
> sufficiently tested, given that many of the problems arise from advanced phi
> lowering.

Yeah, it can take a while to decide legalize() to use and the heuristics are
different from x86 to ARM.

For x86 legalize(x, Legal_All) is probably okay any time. legalizeUndef() can be
used if you know it's just prior to loOperand/hiOperand and then followed by
another legalize()/legalizeToVar().

For ARM, most of the time legalize(x, Legal_All) is not the right thing because
only a few instructions do allow a Mem operand. So I use legalizeUndef() prior
to loOperand/hiOperand and expect that there will be a more specific legalize(x,
Legal_Reg | Legal_Flex) coming up.



> 
> It deserves another look once the register allocator can handle forcible
> spilling for phi lowering.

[jvoung (off chromium), 2015-07-15 19:36:24]

Committed patchset #5 (id:80001) manually as
fbdd244013aad0808220386eb6bd17eb0635dd4c (presubmit successful).