target_x86.cc revision 766a5e5940b469ab40e52770862c81cfec1d835b 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "codegen_x86.h"
18#include "dex/compiler_internals.h"
19#include "dex/quick/mir_to_lir-inl.h"
20#include "x86_lir.h"
21
22#include <string>
23
24namespace art {
25
26// FIXME: restore "static" when usage uncovered
27/*static*/ int core_regs[] = {
28  rAX, rCX, rDX, rBX, rX86_SP, rBP, rSI, rDI
29#ifdef TARGET_REX_SUPPORT
30  r8, r9, r10, r11, r12, r13, r14, 15
31#endif
32};
33/*static*/ int ReservedRegs[] = {rX86_SP};
34/*static*/ int core_temps[] = {rAX, rCX, rDX, rBX};
35/*static*/ int FpRegs[] = {
36  fr0, fr1, fr2, fr3, fr4, fr5, fr6, fr7,
37#ifdef TARGET_REX_SUPPORT
38  fr8, fr9, fr10, fr11, fr12, fr13, fr14, fr15
39#endif
40};
41/*static*/ int fp_temps[] = {
42  fr0, fr1, fr2, fr3, fr4, fr5, fr6, fr7,
43#ifdef TARGET_REX_SUPPORT
44  fr8, fr9, fr10, fr11, fr12, fr13, fr14, fr15
45#endif
46};
47
48RegLocation X86Mir2Lir::LocCReturn() {
49  RegLocation res = X86_LOC_C_RETURN;
50  return res;
51}
52
53RegLocation X86Mir2Lir::LocCReturnWide() {
54  RegLocation res = X86_LOC_C_RETURN_WIDE;
55  return res;
56}
57
58RegLocation X86Mir2Lir::LocCReturnFloat() {
59  RegLocation res = X86_LOC_C_RETURN_FLOAT;
60  return res;
61}
62
63RegLocation X86Mir2Lir::LocCReturnDouble() {
64  RegLocation res = X86_LOC_C_RETURN_DOUBLE;
65  return res;
66}
67
68// Return a target-dependent special register.
69int X86Mir2Lir::TargetReg(SpecialTargetRegister reg) {
70  int res = INVALID_REG;
71  switch (reg) {
72    case kSelf: res = rX86_SELF; break;
73    case kSuspend: res =  rX86_SUSPEND; break;
74    case kLr: res =  rX86_LR; break;
75    case kPc: res =  rX86_PC; break;
76    case kSp: res =  rX86_SP; break;
77    case kArg0: res = rX86_ARG0; break;
78    case kArg1: res = rX86_ARG1; break;
79    case kArg2: res = rX86_ARG2; break;
80    case kArg3: res = rX86_ARG3; break;
81    case kFArg0: res = rX86_FARG0; break;
82    case kFArg1: res = rX86_FARG1; break;
83    case kFArg2: res = rX86_FARG2; break;
84    case kFArg3: res = rX86_FARG3; break;
85    case kRet0: res = rX86_RET0; break;
86    case kRet1: res = rX86_RET1; break;
87    case kInvokeTgt: res = rX86_INVOKE_TGT; break;
88    case kHiddenArg: res = rAX; break;
89    case kHiddenFpArg: res = fr0; break;
90    case kCount: res = rX86_COUNT; break;
91  }
92  return res;
93}
94
95// Create a double from a pair of singles.
96int X86Mir2Lir::S2d(int low_reg, int high_reg) {
97  return X86_S2D(low_reg, high_reg);
98}
99
100// Return mask to strip off fp reg flags and bias.
101uint32_t X86Mir2Lir::FpRegMask() {
102  return X86_FP_REG_MASK;
103}
104
105// True if both regs single, both core or both double.
106bool X86Mir2Lir::SameRegType(int reg1, int reg2) {
107  return (X86_REGTYPE(reg1) == X86_REGTYPE(reg2));
108}
109
110/*
111 * Decode the register id.
112 */
113uint64_t X86Mir2Lir::GetRegMaskCommon(int reg) {
114  uint64_t seed;
115  int shift;
116  int reg_id;
117
118  reg_id = reg & 0xf;
119  /* Double registers in x86 are just a single FP register */
120  seed = 1;
121  /* FP register starts at bit position 16 */
122  shift = X86_FPREG(reg) ? kX86FPReg0 : 0;
123  /* Expand the double register id into single offset */
124  shift += reg_id;
125  return (seed << shift);
126}
127
128uint64_t X86Mir2Lir::GetPCUseDefEncoding() {
129  /*
130   * FIXME: might make sense to use a virtual resource encoding bit for pc.  Might be
131   * able to clean up some of the x86/Arm_Mips differences
132   */
133  LOG(FATAL) << "Unexpected call to GetPCUseDefEncoding for x86";
134  return 0ULL;
135}
136
137void X86Mir2Lir::SetupTargetResourceMasks(LIR* lir, uint64_t flags) {
138  DCHECK_EQ(cu_->instruction_set, kX86);
139  DCHECK(!lir->flags.use_def_invalid);
140
141  // X86-specific resource map setup here.
142  if (flags & REG_USE_SP) {
143    lir->u.m.use_mask |= ENCODE_X86_REG_SP;
144  }
145
146  if (flags & REG_DEF_SP) {
147    lir->u.m.def_mask |= ENCODE_X86_REG_SP;
148  }
149
150  if (flags & REG_DEFA) {
151    SetupRegMask(&lir->u.m.def_mask, rAX);
152  }
153
154  if (flags & REG_DEFD) {
155    SetupRegMask(&lir->u.m.def_mask, rDX);
156  }
157  if (flags & REG_USEA) {
158    SetupRegMask(&lir->u.m.use_mask, rAX);
159  }
160
161  if (flags & REG_USEC) {
162    SetupRegMask(&lir->u.m.use_mask, rCX);
163  }
164
165  if (flags & REG_USED) {
166    SetupRegMask(&lir->u.m.use_mask, rDX);
167  }
168
169  if (flags & REG_USEB) {
170    SetupRegMask(&lir->u.m.use_mask, rBX);
171  }
172}
173
174/* For dumping instructions */
175static const char* x86RegName[] = {
176  "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
177  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
178};
179
180static const char* x86CondName[] = {
181  "O",
182  "NO",
183  "B/NAE/C",
184  "NB/AE/NC",
185  "Z/EQ",
186  "NZ/NE",
187  "BE/NA",
188  "NBE/A",
189  "S",
190  "NS",
191  "P/PE",
192  "NP/PO",
193  "L/NGE",
194  "NL/GE",
195  "LE/NG",
196  "NLE/G"
197};
198
199/*
200 * Interpret a format string and build a string no longer than size
201 * See format key in Assemble.cc.
202 */
203std::string X86Mir2Lir::BuildInsnString(const char *fmt, LIR *lir, unsigned char* base_addr) {
204  std::string buf;
205  size_t i = 0;
206  size_t fmt_len = strlen(fmt);
207  while (i < fmt_len) {
208    if (fmt[i] != '!') {
209      buf += fmt[i];
210      i++;
211    } else {
212      i++;
213      DCHECK_LT(i, fmt_len);
214      char operand_number_ch = fmt[i];
215      i++;
216      if (operand_number_ch == '!') {
217        buf += "!";
218      } else {
219        int operand_number = operand_number_ch - '0';
220        DCHECK_LT(operand_number, 6);  // Expect upto 6 LIR operands.
221        DCHECK_LT(i, fmt_len);
222        int operand = lir->operands[operand_number];
223        switch (fmt[i]) {
224          case 'c':
225            DCHECK_LT(static_cast<size_t>(operand), sizeof(x86CondName));
226            buf += x86CondName[operand];
227            break;
228          case 'd':
229            buf += StringPrintf("%d", operand);
230            break;
231          case 'p': {
232            EmbeddedData *tab_rec = reinterpret_cast<EmbeddedData*>(UnwrapPointer(operand));
233            buf += StringPrintf("0x%08x", tab_rec->offset);
234            break;
235          }
236          case 'r':
237            if (X86_FPREG(operand) || X86_DOUBLEREG(operand)) {
238              int fp_reg = operand & X86_FP_REG_MASK;
239              buf += StringPrintf("xmm%d", fp_reg);
240            } else {
241              DCHECK_LT(static_cast<size_t>(operand), sizeof(x86RegName));
242              buf += x86RegName[operand];
243            }
244            break;
245          case 't':
246            buf += StringPrintf("0x%08x (L%p)",
247                                reinterpret_cast<uintptr_t>(base_addr)
248                                + lir->offset + operand, lir->target);
249            break;
250          default:
251            buf += StringPrintf("DecodeError '%c'", fmt[i]);
252            break;
253        }
254        i++;
255      }
256    }
257  }
258  return buf;
259}
260
261void X86Mir2Lir::DumpResourceMask(LIR *x86LIR, uint64_t mask, const char *prefix) {
262  char buf[256];
263  buf[0] = 0;
264
265  if (mask == ENCODE_ALL) {
266    strcpy(buf, "all");
267  } else {
268    char num[8];
269    int i;
270
271    for (i = 0; i < kX86RegEnd; i++) {
272      if (mask & (1ULL << i)) {
273        snprintf(num, arraysize(num), "%d ", i);
274        strcat(buf, num);
275      }
276    }
277
278    if (mask & ENCODE_CCODE) {
279      strcat(buf, "cc ");
280    }
281    /* Memory bits */
282    if (x86LIR && (mask & ENCODE_DALVIK_REG)) {
283      snprintf(buf + strlen(buf), arraysize(buf) - strlen(buf), "dr%d%s",
284               DECODE_ALIAS_INFO_REG(x86LIR->flags.alias_info),
285               (DECODE_ALIAS_INFO_WIDE(x86LIR->flags.alias_info)) ? "(+1)" : "");
286    }
287    if (mask & ENCODE_LITERAL) {
288      strcat(buf, "lit ");
289    }
290
291    if (mask & ENCODE_HEAP_REF) {
292      strcat(buf, "heap ");
293    }
294    if (mask & ENCODE_MUST_NOT_ALIAS) {
295      strcat(buf, "noalias ");
296    }
297  }
298  if (buf[0]) {
299    LOG(INFO) << prefix << ": " <<  buf;
300  }
301}
302
303void X86Mir2Lir::AdjustSpillMask() {
304  // Adjustment for LR spilling, x86 has no LR so nothing to do here
305  core_spill_mask_ |= (1 << rRET);
306  num_core_spills_++;
307}
308
309/*
310 * Mark a callee-save fp register as promoted.  Note that
311 * vpush/vpop uses contiguous register lists so we must
312 * include any holes in the mask.  Associate holes with
313 * Dalvik register INVALID_VREG (0xFFFFU).
314 */
315void X86Mir2Lir::MarkPreservedSingle(int v_reg, int reg) {
316  UNIMPLEMENTED(WARNING) << "MarkPreservedSingle";
317#if 0
318  LOG(FATAL) << "No support yet for promoted FP regs";
319#endif
320}
321
322void X86Mir2Lir::FlushRegWide(int reg1, int reg2) {
323  RegisterInfo* info1 = GetRegInfo(reg1);
324  RegisterInfo* info2 = GetRegInfo(reg2);
325  DCHECK(info1 && info2 && info1->pair && info2->pair &&
326         (info1->partner == info2->reg) &&
327         (info2->partner == info1->reg));
328  if ((info1->live && info1->dirty) || (info2->live && info2->dirty)) {
329    if (!(info1->is_temp && info2->is_temp)) {
330      /* Should not happen.  If it does, there's a problem in eval_loc */
331      LOG(FATAL) << "Long half-temp, half-promoted";
332    }
333
334    info1->dirty = false;
335    info2->dirty = false;
336    if (mir_graph_->SRegToVReg(info2->s_reg) < mir_graph_->SRegToVReg(info1->s_reg))
337      info1 = info2;
338    int v_reg = mir_graph_->SRegToVReg(info1->s_reg);
339    StoreBaseDispWide(rX86_SP, VRegOffset(v_reg), info1->reg, info1->partner);
340  }
341}
342
343void X86Mir2Lir::FlushReg(int reg) {
344  RegisterInfo* info = GetRegInfo(reg);
345  if (info->live && info->dirty) {
346    info->dirty = false;
347    int v_reg = mir_graph_->SRegToVReg(info->s_reg);
348    StoreBaseDisp(rX86_SP, VRegOffset(v_reg), reg, kWord);
349  }
350}
351
352/* Give access to the target-dependent FP register encoding to common code */
353bool X86Mir2Lir::IsFpReg(int reg) {
354  return X86_FPREG(reg);
355}
356
357/* Clobber all regs that might be used by an external C call */
358void X86Mir2Lir::ClobberCallerSave() {
359  Clobber(rAX);
360  Clobber(rCX);
361  Clobber(rDX);
362  Clobber(rBX);
363}
364
365RegLocation X86Mir2Lir::GetReturnWideAlt() {
366  RegLocation res = LocCReturnWide();
367  CHECK(res.low_reg == rAX);
368  CHECK(res.high_reg == rDX);
369  Clobber(rAX);
370  Clobber(rDX);
371  MarkInUse(rAX);
372  MarkInUse(rDX);
373  MarkPair(res.low_reg, res.high_reg);
374  return res;
375}
376
377RegLocation X86Mir2Lir::GetReturnAlt() {
378  RegLocation res = LocCReturn();
379  res.low_reg = rDX;
380  Clobber(rDX);
381  MarkInUse(rDX);
382  return res;
383}
384
385/* To be used when explicitly managing register use */
386void X86Mir2Lir::LockCallTemps() {
387  LockTemp(rX86_ARG0);
388  LockTemp(rX86_ARG1);
389  LockTemp(rX86_ARG2);
390  LockTemp(rX86_ARG3);
391}
392
393/* To be used when explicitly managing register use */
394void X86Mir2Lir::FreeCallTemps() {
395  FreeTemp(rX86_ARG0);
396  FreeTemp(rX86_ARG1);
397  FreeTemp(rX86_ARG2);
398  FreeTemp(rX86_ARG3);
399}
400
401void X86Mir2Lir::GenMemBarrier(MemBarrierKind barrier_kind) {
402#if ANDROID_SMP != 0
403  // TODO: optimize fences
404  NewLIR0(kX86Mfence);
405#endif
406}
407/*
408 * Alloc a pair of core registers, or a double.  Low reg in low byte,
409 * high reg in next byte.
410 */
411int X86Mir2Lir::AllocTypedTempPair(bool fp_hint,
412                          int reg_class) {
413  int high_reg;
414  int low_reg;
415  int res = 0;
416
417  if (((reg_class == kAnyReg) && fp_hint) || (reg_class == kFPReg)) {
418    low_reg = AllocTempDouble();
419    high_reg = low_reg;  // only one allocated!
420    res = (low_reg & 0xff) | ((high_reg & 0xff) << 8);
421    return res;
422  }
423
424  low_reg = AllocTemp();
425  high_reg = AllocTemp();
426  res = (low_reg & 0xff) | ((high_reg & 0xff) << 8);
427  return res;
428}
429
430int X86Mir2Lir::AllocTypedTemp(bool fp_hint, int reg_class) {
431  if (((reg_class == kAnyReg) && fp_hint) || (reg_class == kFPReg)) {
432    return AllocTempFloat();
433  }
434  return AllocTemp();
435}
436
437void X86Mir2Lir::CompilerInitializeRegAlloc() {
438  int num_regs = sizeof(core_regs)/sizeof(*core_regs);
439  int num_reserved = sizeof(ReservedRegs)/sizeof(*ReservedRegs);
440  int num_temps = sizeof(core_temps)/sizeof(*core_temps);
441  int num_fp_regs = sizeof(FpRegs)/sizeof(*FpRegs);
442  int num_fp_temps = sizeof(fp_temps)/sizeof(*fp_temps);
443  reg_pool_ = static_cast<RegisterPool*>(arena_->Alloc(sizeof(*reg_pool_),
444                                                       ArenaAllocator::kAllocRegAlloc));
445  reg_pool_->num_core_regs = num_regs;
446  reg_pool_->core_regs =
447      static_cast<RegisterInfo*>(arena_->Alloc(num_regs * sizeof(*reg_pool_->core_regs),
448                                               ArenaAllocator::kAllocRegAlloc));
449  reg_pool_->num_fp_regs = num_fp_regs;
450  reg_pool_->FPRegs =
451      static_cast<RegisterInfo *>(arena_->Alloc(num_fp_regs * sizeof(*reg_pool_->FPRegs),
452                                                ArenaAllocator::kAllocRegAlloc));
453  CompilerInitPool(reg_pool_->core_regs, core_regs, reg_pool_->num_core_regs);
454  CompilerInitPool(reg_pool_->FPRegs, FpRegs, reg_pool_->num_fp_regs);
455  // Keep special registers from being allocated
456  for (int i = 0; i < num_reserved; i++) {
457    MarkInUse(ReservedRegs[i]);
458  }
459  // Mark temp regs - all others not in use can be used for promotion
460  for (int i = 0; i < num_temps; i++) {
461    MarkTemp(core_temps[i]);
462  }
463  for (int i = 0; i < num_fp_temps; i++) {
464    MarkTemp(fp_temps[i]);
465  }
466}
467
468void X86Mir2Lir::FreeRegLocTemps(RegLocation rl_keep,
469                     RegLocation rl_free) {
470  if ((rl_free.low_reg != rl_keep.low_reg) && (rl_free.low_reg != rl_keep.high_reg) &&
471      (rl_free.high_reg != rl_keep.low_reg) && (rl_free.high_reg != rl_keep.high_reg)) {
472    // No overlap, free both
473    FreeTemp(rl_free.low_reg);
474    FreeTemp(rl_free.high_reg);
475  }
476}
477
478void X86Mir2Lir::SpillCoreRegs() {
479  if (num_core_spills_ == 0) {
480    return;
481  }
482  // Spill mask not including fake return address register
483  uint32_t mask = core_spill_mask_ & ~(1 << rRET);
484  int offset = frame_size_ - (4 * num_core_spills_);
485  for (int reg = 0; mask; mask >>= 1, reg++) {
486    if (mask & 0x1) {
487      StoreWordDisp(rX86_SP, offset, reg);
488      offset += 4;
489    }
490  }
491}
492
493void X86Mir2Lir::UnSpillCoreRegs() {
494  if (num_core_spills_ == 0) {
495    return;
496  }
497  // Spill mask not including fake return address register
498  uint32_t mask = core_spill_mask_ & ~(1 << rRET);
499  int offset = frame_size_ - (4 * num_core_spills_);
500  for (int reg = 0; mask; mask >>= 1, reg++) {
501    if (mask & 0x1) {
502      LoadWordDisp(rX86_SP, offset, reg);
503      offset += 4;
504    }
505  }
506}
507
508bool X86Mir2Lir::IsUnconditionalBranch(LIR* lir) {
509  return (lir->opcode == kX86Jmp8 || lir->opcode == kX86Jmp32);
510}
511
512X86Mir2Lir::X86Mir2Lir(CompilationUnit* cu, MIRGraph* mir_graph, ArenaAllocator* arena)
513    : Mir2Lir(cu, mir_graph, arena) {
514  for (int i = 0; i < kX86Last; i++) {
515    if (X86Mir2Lir::EncodingMap[i].opcode != i) {
516      LOG(FATAL) << "Encoding order for " << X86Mir2Lir::EncodingMap[i].name
517                 << " is wrong: expecting " << i << ", seeing "
518                 << static_cast<int>(X86Mir2Lir::EncodingMap[i].opcode);
519    }
520  }
521}
522
523Mir2Lir* X86CodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph,
524                          ArenaAllocator* const arena) {
525  return new X86Mir2Lir(cu, mir_graph, arena);
526}
527
528// Not used in x86
529int X86Mir2Lir::LoadHelper(ThreadOffset offset) {
530  LOG(FATAL) << "Unexpected use of LoadHelper in x86";
531  return INVALID_REG;
532}
533
534uint64_t X86Mir2Lir::GetTargetInstFlags(int opcode) {
535  DCHECK(!IsPseudoLirOp(opcode));
536  return X86Mir2Lir::EncodingMap[opcode].flags;
537}
538
539const char* X86Mir2Lir::GetTargetInstName(int opcode) {
540  DCHECK(!IsPseudoLirOp(opcode));
541  return X86Mir2Lir::EncodingMap[opcode].name;
542}
543
544const char* X86Mir2Lir::GetTargetInstFmt(int opcode) {
545  DCHECK(!IsPseudoLirOp(opcode));
546  return X86Mir2Lir::EncodingMap[opcode].fmt;
547}
548
549/*
550 * Return an updated location record with current in-register status.
551 * If the value lives in live temps, reflect that fact.  No code
552 * is generated.  If the live value is part of an older pair,
553 * clobber both low and high.
554 */
555// TODO: Reunify with common code after 'pair mess' has been fixed
556RegLocation X86Mir2Lir::UpdateLocWide(RegLocation loc) {
557  DCHECK(loc.wide);
558  DCHECK(CheckCorePoolSanity());
559  if (loc.location != kLocPhysReg) {
560    DCHECK((loc.location == kLocDalvikFrame) ||
561         (loc.location == kLocCompilerTemp));
562    // Are the dalvik regs already live in physical registers?
563    RegisterInfo* info_lo = AllocLive(loc.s_reg_low, kAnyReg);
564    if (loc.fp) {
565      bool match = (info_lo != NULL);
566
567      // Is it FP?
568      match = match && IsFpReg(info_lo->reg);
569
570      // We can't match a FP register with a pair of Core registers.
571      match = match && (info_lo->pair == 0);
572
573      if (match) {
574        // We can reuse;update the register usage info.
575        loc.low_reg = info_lo->reg;
576        loc.high_reg = info_lo->reg;  // Play nice with existing code.
577        loc.location = kLocPhysReg;
578        loc.vec_len = kVectorLength8;
579        DCHECK(IsFpReg(loc.low_reg));
580        return loc;
581      }
582      // We can't easily reuse; clobber and free any overlaps.
583      if (info_lo) {
584        Clobber(info_lo->reg);
585        FreeTemp(info_lo->reg);
586        if (info_lo->pair)
587          Clobber(info_lo->partner);
588      }
589    } else {
590      RegisterInfo* info_hi = AllocLive(GetSRegHi(loc.s_reg_low), kAnyReg);
591      bool match = true;
592      match = match && (info_lo != NULL);
593      match = match && (info_hi != NULL);
594      // Are they both core or both FP?
595      match = match && (IsFpReg(info_lo->reg) == IsFpReg(info_hi->reg));
596      // If a pair of floating point singles, are they properly aligned?
597      if (match && IsFpReg(info_lo->reg)) {
598        match &= ((info_lo->reg & 0x1) == 0);
599        match &= ((info_hi->reg - info_lo->reg) == 1);
600      }
601      // If previously used as a pair, it is the same pair?
602      if (match && (info_lo->pair || info_hi->pair)) {
603        match = (info_lo->pair == info_hi->pair);
604        match &= ((info_lo->reg == info_hi->partner) &&
605              (info_hi->reg == info_lo->partner));
606      }
607      if (match) {
608        // Can reuse - update the register usage info
609        loc.low_reg = info_lo->reg;
610        loc.high_reg = info_hi->reg;
611        loc.location = kLocPhysReg;
612        MarkPair(loc.low_reg, loc.high_reg);
613        DCHECK(!IsFpReg(loc.low_reg) || ((loc.low_reg & 0x1) == 0));
614        return loc;
615      }
616      // Can't easily reuse - clobber and free any overlaps
617      if (info_lo) {
618        Clobber(info_lo->reg);
619        FreeTemp(info_lo->reg);
620        if (info_lo->pair)
621          Clobber(info_lo->partner);
622      }
623      if (info_hi) {
624        Clobber(info_hi->reg);
625        FreeTemp(info_hi->reg);
626        if (info_hi->pair)
627          Clobber(info_hi->partner);
628      }
629    }
630  }
631  return loc;
632}
633
634// TODO: Reunify with common code after 'pair mess' has been fixed
635RegLocation X86Mir2Lir::EvalLocWide(RegLocation loc, int reg_class, bool update) {
636  DCHECK(loc.wide);
637  int32_t new_regs;
638  int32_t low_reg;
639  int32_t high_reg;
640
641  loc = UpdateLocWide(loc);
642
643  /* If it is already in a register, we can assume proper form.  Is it the right reg class? */
644  if (loc.location == kLocPhysReg) {
645    DCHECK_EQ(IsFpReg(loc.low_reg), loc.IsVectorScalar());
646    if (!RegClassMatches(reg_class, loc.low_reg)) {
647      /* It is the wrong register class.  Reallocate and copy. */
648      if (IsFpReg(loc.low_reg) && reg_class != kCoreReg) {
649        // Allocate this into any FP reg, and mark it with the right size.
650        low_reg = AllocTypedTemp(true, reg_class);
651        OpVectorRegCopyWide(low_reg, loc.low_reg, loc.high_reg);
652        CopyRegInfo(low_reg, loc.low_reg);
653        Clobber(loc.low_reg);
654        Clobber(loc.high_reg);
655        loc.low_reg = low_reg;
656        loc.high_reg = low_reg;  // Play nice with existing code.
657        loc.vec_len = kVectorLength8;
658      } else {
659        new_regs = AllocTypedTempPair(loc.fp, reg_class);
660        low_reg = new_regs & 0xff;
661        high_reg = (new_regs >> 8) & 0xff;
662        OpRegCopyWide(low_reg, high_reg, loc.low_reg, loc.high_reg);
663        CopyRegInfo(low_reg, loc.low_reg);
664        CopyRegInfo(high_reg, loc.high_reg);
665        Clobber(loc.low_reg);
666        Clobber(loc.high_reg);
667        loc.low_reg = low_reg;
668        loc.high_reg = high_reg;
669        MarkPair(loc.low_reg, loc.high_reg);
670        DCHECK(!IsFpReg(loc.low_reg) || ((loc.low_reg & 0x1) == 0));
671      }
672    }
673    return loc;
674  }
675
676  DCHECK_NE(loc.s_reg_low, INVALID_SREG);
677  if (IsFpReg(loc.low_reg) && reg_class != kCoreReg) {
678    // Need a wide vector register.
679    low_reg = AllocTypedTemp(true, reg_class);
680    loc.low_reg = low_reg;
681    loc.high_reg = low_reg;  // Play nice with existing code.
682    loc.vec_len = kVectorLength8;
683    if (update) {
684      loc.location = kLocPhysReg;
685      MarkLive(loc.low_reg, loc.s_reg_low);
686    }
687    DCHECK(IsFpReg(loc.low_reg));
688  } else {
689    DCHECK_NE(GetSRegHi(loc.s_reg_low), INVALID_SREG);
690
691    new_regs = AllocTypedTempPair(loc.fp, reg_class);
692    loc.low_reg = new_regs & 0xff;
693    loc.high_reg = (new_regs >> 8) & 0xff;
694
695    MarkPair(loc.low_reg, loc.high_reg);
696    if (update) {
697      loc.location = kLocPhysReg;
698      MarkLive(loc.low_reg, loc.s_reg_low);
699      MarkLive(loc.high_reg, GetSRegHi(loc.s_reg_low));
700    }
701    DCHECK(!IsFpReg(loc.low_reg) || ((loc.low_reg & 0x1) == 0));
702  }
703  return loc;
704}
705
706// TODO: Reunify with common code after 'pair mess' has been fixed
707RegLocation X86Mir2Lir::EvalLoc(RegLocation loc, int reg_class, bool update) {
708  int new_reg;
709
710  if (loc.wide)
711    return EvalLocWide(loc, reg_class, update);
712
713  loc = UpdateLoc(loc);
714
715  if (loc.location == kLocPhysReg) {
716    if (!RegClassMatches(reg_class, loc.low_reg)) {
717      /* Wrong register class.  Realloc, copy and transfer ownership. */
718      new_reg = AllocTypedTemp(loc.fp, reg_class);
719      OpRegCopy(new_reg, loc.low_reg);
720      CopyRegInfo(new_reg, loc.low_reg);
721      Clobber(loc.low_reg);
722      loc.low_reg = new_reg;
723      if (IsFpReg(loc.low_reg) && reg_class != kCoreReg)
724        loc.vec_len = kVectorLength4;
725    }
726    return loc;
727  }
728
729  DCHECK_NE(loc.s_reg_low, INVALID_SREG);
730
731  new_reg = AllocTypedTemp(loc.fp, reg_class);
732  loc.low_reg = new_reg;
733  if (IsFpReg(loc.low_reg) && reg_class != kCoreReg)
734    loc.vec_len = kVectorLength4;
735
736  if (update) {
737    loc.location = kLocPhysReg;
738    MarkLive(loc.low_reg, loc.s_reg_low);
739  }
740  return loc;
741}
742
743int X86Mir2Lir::AllocTempDouble() {
744  // We really don't need a pair of registers.
745  return AllocTempFloat();
746}
747
748// TODO: Reunify with common code after 'pair mess' has been fixed
749void X86Mir2Lir::ResetDefLocWide(RegLocation rl) {
750  DCHECK(rl.wide);
751  RegisterInfo* p_low = IsTemp(rl.low_reg);
752  if (IsFpReg(rl.low_reg)) {
753    // We are using only the low register.
754    if (p_low && !(cu_->disable_opt & (1 << kSuppressLoads))) {
755      NullifyRange(p_low->def_start, p_low->def_end, p_low->s_reg, rl.s_reg_low);
756    }
757    ResetDef(rl.low_reg);
758  } else {
759    RegisterInfo* p_high = IsTemp(rl.high_reg);
760    if (p_low && !(cu_->disable_opt & (1 << kSuppressLoads))) {
761      DCHECK(p_low->pair);
762      NullifyRange(p_low->def_start, p_low->def_end, p_low->s_reg, rl.s_reg_low);
763    }
764    if (p_high && !(cu_->disable_opt & (1 << kSuppressLoads))) {
765      DCHECK(p_high->pair);
766    }
767    ResetDef(rl.low_reg);
768    ResetDef(rl.high_reg);
769  }
770}
771
772void X86Mir2Lir::GenConstWide(RegLocation rl_dest, int64_t value) {
773  // Can we do this directly to memory?
774  rl_dest = UpdateLocWide(rl_dest);
775  if ((rl_dest.location == kLocDalvikFrame) ||
776      (rl_dest.location == kLocCompilerTemp)) {
777    int32_t val_lo = Low32Bits(value);
778    int32_t val_hi = High32Bits(value);
779    int rBase = TargetReg(kSp);
780    int displacement = SRegOffset(rl_dest.s_reg_low);
781
782    LIR * store = NewLIR3(kX86Mov32MI, rBase, displacement + LOWORD_OFFSET, val_lo);
783    AnnotateDalvikRegAccess(store, (displacement + LOWORD_OFFSET) >> 2,
784                              false /* is_load */, true /* is64bit */);
785    store = NewLIR3(kX86Mov32MI, rBase, displacement + HIWORD_OFFSET, val_hi);
786    AnnotateDalvikRegAccess(store, (displacement + HIWORD_OFFSET) >> 2,
787                              false /* is_load */, true /* is64bit */);
788    return;
789  }
790
791  // Just use the standard code to do the generation.
792  Mir2Lir::GenConstWide(rl_dest, value);
793}
794}  // namespace art
795