Iasm and obj lowering for advanced switch lowering.

src/IceAssemblerX86BaseImpl.h

 //===- subzero/src/IceAssemblerX86BaseImpl.h - base x86 assembler -*- C++ -*-=//
 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
@@ skipping 13 matching lines @@
 #include "IceCfg.h"
 #include "IceOperand.h"
 
 namespace Ice {
 namespace X86Internal {
 
 template <class Machine>
 AssemblerX86Base<Machine>::~AssemblerX86Base<Machine>() {
   if (BuildDefs::asserts()) {
     for (const Label *Label : CfgNodeLabels) {
-      Label->FinalCheck();
+      Label->finalCheck();
     }
     for (const Label *Label : LocalLabels) {
-      Label->FinalCheck();
+      Label->finalCheck();
     }
   }
 }
 
 template <class Machine> void AssemblerX86Base<Machine>::alignFunction() {
-  SizeT Align = 1 << getBundleAlignLog2Bytes();
+  const SizeT Align = 1 << getBundleAlignLog2Bytes();
   SizeT BytesNeeded = Utils::OffsetToAlignment(Buffer.getPosition(), Align);
-  const SizeT HltSize = 1;
+  constexpr SizeT HltSize = 1;
   while (BytesNeeded > 0) {
     hlt();
     BytesNeeded -= HltSize;
   }
 }
 
+template <class Machine> void AssemblerX86Base<Machine>::alignCfgNode() {
+  const SizeT Align = 1 << getBundleAlignLog2Bytes();
+  padWithNop(Utils::OffsetToAlignment(Buffer.getPosition(), Align));
+}
+
 template <class Machine>
-Label *AssemblerX86Base<Machine>::GetOrCreateLabel(SizeT Number,
+Label *AssemblerX86Base<Machine>::getOrCreateLabel(SizeT Number,
                                                    LabelVector &Labels) {
   Label *L = nullptr;
   if (Number == Labels.size()) {
     L = new (this->allocate<Label>()) Label();
     Labels.push_back(L);
     return L;
   }
   if (Number > Labels.size()) {
     Labels.resize(Number + 1);
   }
   L = Labels[Number];
   if (!L) {
     L = new (this->allocate<Label>()) Label();
     Labels[Number] = L;
   }
   return L;
 }
 
 template <class Machine>
-Label *AssemblerX86Base<Machine>::GetOrCreateCfgNodeLabel(SizeT NodeNumber) {
-  return GetOrCreateLabel(NodeNumber, CfgNodeLabels);
+Label *AssemblerX86Base<Machine>::getOrCreateCfgNodeLabel(SizeT NodeNumber) {
+  return getOrCreateLabel(NodeNumber, CfgNodeLabels);
 }
 
 template <class Machine>
-Label *AssemblerX86Base<Machine>::GetOrCreateLocalLabel(SizeT Number) {
-  return GetOrCreateLabel(Number, LocalLabels);
+Label *AssemblerX86Base<Machine>::getOrCreateLocalLabel(SizeT Number) {
+  return getOrCreateLabel(Number, LocalLabels);
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::bindCfgNodeLabel(SizeT NodeNumber) {
   assert(!getPreliminary());
-  Label *L = GetOrCreateCfgNodeLabel(NodeNumber);
+  Label *L = getOrCreateCfgNodeLabel(NodeNumber);
   this->bind(L);
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::BindLocalLabel(SizeT Number) {
-  Label *L = GetOrCreateLocalLabel(Number);
+  Label *L = getOrCreateLocalLabel(Number);
   if (!getPreliminary())
     this->bind(L);
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::call(typename Traits::GPRRegister reg) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitUint8(0xFF);
   emitRegisterOperand(2, reg);
 }
@@ skipping 2671 matching lines @@
 template <class Machine> void AssemblerX86Base<Machine>::ud2() {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitUint8(0x0F);
   emitUint8(0x0B);
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::j(typename Traits::Cond::BrCond condition,
                                   Label *label, bool near) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
-  if (label->IsBound()) {
+  if (label->isBound()) {
     static const int kShortSize = 2;
     static const int kLongSize = 6;
-    intptr_t offset = label->Position() - Buffer.size();
+    intptr_t offset = label->getPosition() - Buffer.size();
     assert(offset <= 0);
     if (Utils::IsInt(8, offset - kShortSize)) {
       // TODO(stichnot): Here and in jmp(), we may need to be more
       // conservative about the backward branch distance if the branch
       // instruction is within a bundle_lock sequence, because the
       // distance may increase when padding is added.  This isn't an
       // issue for branches outside a bundle_lock, because if padding
       // is added, the retry may change it to a long backward branch
       // without affecting any of the bookkeeping.
       emitUint8(0x70 + condition);
@@ skipping 26 matching lines @@
 template <class Machine>
 void AssemblerX86Base<Machine>::jmp(typename Traits::GPRRegister reg) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitUint8(0xFF);
   emitRegisterOperand(4, reg);
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::jmp(Label *label, bool near) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
-  if (label->IsBound()) {
+  if (label->isBound()) {
     static const int kShortSize = 2;
     static const int kLongSize = 5;
-    intptr_t offset = label->Position() - Buffer.size();
+    intptr_t offset = label->getPosition() - Buffer.size();
     assert(offset <= 0);
     if (Utils::IsInt(8, offset - kShortSize)) {
       emitUint8(0xEB);
       emitUint8((offset - kShortSize) & 0xFF);
     } else {
       emitUint8(0xE9);
       emitInt32(offset - kLongSize);
     }
   } else if (near) {
     emitUint8(0xEB);
@@ skipping 105 matching lines @@
     bytes_needed -= MAX_NOP_SIZE;
   }
   if (bytes_needed) {
     nop(bytes_needed);
   }
   assert(((offset + Buffer.getPosition()) & (alignment - 1)) == 0);
 }
 
 template <class Machine> void AssemblerX86Base<Machine>::bind(Label *label) {
   intptr_t bound = Buffer.size();
-  assert(!label->IsBound()); // Labels can only be bound once.
-  while (label->IsLinked()) {
-    intptr_t position = label->LinkPosition();
+  assert(!label->isBound()); // Labels can only be bound once.
+  while (label->isLinked()) {
+    intptr_t position = label->getLinkPosition();
     intptr_t next = Buffer.load<int32_t>(position);
     Buffer.store<int32_t>(position, bound - (position + 4));
-    label->position_ = next;
+    label->Position = next;
   }
-  while (label->HasNear()) {
-    intptr_t position = label->NearPosition();
+  while (label->hasNear()) {
+    intptr_t position = label->getNearPosition();
     intptr_t offset = bound - (position + 1);
     assert(Utils::IsInt(8, offset));
     Buffer.store<int8_t>(position, offset);
   }
-  label->BindTo(bound);
+  label->bindTo(bound);
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::emitOperand(
     int rm, const typename Traits::Operand &operand) {
   assert(rm >= 0 && rm < 8);
   const intptr_t length = operand.length_;
   assert(length > 0);
   // Emit the ModRM byte updated with the given RM value.
   assert((operand.encoding_[0] & 0x38) == 0);
@@ skipping 55 matching lines @@
   } else {
     emitUint8(0x81);
     emitOperand(rm, operand);
     emitImmediate(Ty, immediate);
   }
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::emitLabel(Label *label,
                                           intptr_t instruction_size) {
-  if (label->IsBound()) {
-    intptr_t offset = label->Position() - Buffer.size();
+  if (label->isBound()) {
+    intptr_t offset = label->getPosition() - Buffer.size();
     assert(offset <= 0);
     emitInt32(offset - instruction_size);
   } else {
     emitLabelLink(label);
   }
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::emitLabelLink(Label *Label) {
-  assert(!Label->IsBound());
+  assert(!Label->isBound());
   intptr_t Position = Buffer.size();
-  emitInt32(Label->position_);
+  emitInt32(Label->Position);
   if (!getPreliminary())
-    Label->LinkTo(Position);
+    Label->linkTo(Position);
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::emitNearLabelLink(Label *label) {
-  assert(!label->IsBound());
+  assert(!label->isBound());
   intptr_t position = Buffer.size();
   emitUint8(0);
   if (!getPreliminary())
-    label->NearLinkTo(position);
+    label->nearLinkTo(position);
 }
 
 template <class Machine>
 void AssemblerX86Base<Machine>::emitGenericShift(
     int rm, Type Ty, typename Traits::GPRRegister reg, const Immediate &imm) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   assert(imm.is_int8());
   if (Ty == IceType_i16)
     emitOperandSizeOverride();
   if (imm.value() == 1) {
@@ skipping 14 matching lines @@
   assert(shifter == Traits::Encoded_Reg_Counter);
   (void)shifter;
   if (Ty == IceType_i16)
     emitOperandSizeOverride();
   emitUint8(isByteSizedArithType(Ty) ? 0xD2 : 0xD3);
   emitOperand(rm, operand);
 }
 
 } // end of namespace X86Internal
 } // end of namespace Ice