As a first step towards implementing thumb2, add code for...

src/arm/assembler-thumb2.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 //
 // - Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
 //
@@ skipping 353 matching lines @@
   reloc_info_writer.Reposition(buffer_ + buffer_size, pc_);
   num_prinfo_ = 0;
   next_buffer_check_ = 0;
   no_const_pool_before_ = 0;
   last_const_pool_end_ = 0;
   last_bound_pos_ = 0;
   current_statement_position_ = RelocInfo::kNoPosition;
   current_position_ = RelocInfo::kNoPosition;
   written_statement_position_ = current_statement_position_;
   written_position_ = current_position_;
+  thumb_mode_ = false;
 }
 
 
 Assembler::~Assembler() {
   if (own_buffer_) {
     if (spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) {
       spare_buffer_ = buffer_;
     } else {
       DeleteArray(buffer_);
     }
@@ skipping 168 matching lines @@
       // L is empty, simply use appendix
       *L = *appendix;
     }
   }
   appendix->Unuse();  // appendix should not be used anymore
 }
 
 
 void Assembler::bind(Label* L) {
   ASSERT(!L->is_bound());  // label can only be bound once
+  if (thumb_mode_)

[Erik Corry, 2009/12/17 14:05:50]

I think we should assert here that we are not in a bit of code that should have
a predictable size.   Also we prefer to use {} on multiline ifs in V8.

+    forceArmMode();
   bind_to(L, pc_offset());
 }
 
 
 void Assembler::next(Label* L) {
   ASSERT(L->is_linked());
   int link = target_at(L->pos());
   if (link > 0) {
     L->link_to(link);
   } else {
@@ skipping 37 matching lines @@
 #ifdef DEBUG
     if (!Serializer::enabled()) {
       Serializer::TooLateToEnableNow();
     }
 #endif
     return Serializer::enabled();
   } else if (rmode == RelocInfo::NONE) {
     return false;
   }
   return true;
 }

[Erik Corry, 2009/12/17 14:05:50]

Double blank lines between functions.

 
+void Assembler::forceThumbMode() {

[Erik Corry, 2009/12/17 14:05:50]

Google style is to use CaptializedCamelCase for functions.  This file (which
predates V8) also has lower_case_with_underscores.  This new function uses
neither convention.  I suggest you choose whichever convention makes it blend in
best with the rest of the file.
I would prefer 'Ensure' to 'Force' since we are not overriding anything here.

+  if (thumb_mode_)
+    return;

[Erik Corry, 2009/12/17 14:05:50]

Multiline if.

+  // PC is at the current instruction + 8 bytes in ARM mode, so we
+  // need to subtract 3 to get the next thumb instruction and enter
+  // thumb mode. We encoder this by hand, because the sub()

[Erik Corry, 2009/12/17 14:05:50]

encoder -> encode
sub() -> sub

+  // instruction should thumb

[Erik Corry, 2009/12/17 14:05:50]

its nose?

+  ASSERT((pc_offset() & 1) == 0);
+  emit(al | B25 | B22 | pc.code() * B16 | pc.code() * B12 | 3);
+  thumb_mode_ = true;
+  // The thumb instructions follow at once with no padding

[Erik Corry, 2009/12/17 14:05:50]

Please use full stops at the end of comments.

+  ASSERT((pc_offset() & 1) == 0);
+}
+
+void Assembler::forceArmMode() {

[Erik Corry, 2009/12/17 14:05:50]

CamelCase.

+  if (!thumb_mode_)

[Erik Corry, 2009/12/17 14:05:50]

Multiline if.

+    return;
+  // PC is 4 bytes ahead of the current instruction, and the instruction

[Erik Corry, 2009/12/17 14:05:50]

4 or 8?

+  // we emit will always be 4 bytes.
+  ASSERT((pc_offset() & 1) == 0);
+  if (pc_offset() & 2) {
+    // ADD pc, pc, #1
+    emitThumb(16*B12| 8 * B5 | pc.code());
+    emitThumb(pc.code() * B8 | 1);
+    pc_ += 2;  // Padding
+  } else {
+    // SUB pc, pc, #1
+    emitThumb(16*B12| 13 * B5 | pc.code());
+    emitThumb(pc.code() * B8 | 1);
+  }
+  thumb_mode_ = false;
+  ASSERT((pc_offset() & 3) == 0);
+}
 
 void Assembler::addrmod1(Instr instr,
                          Register rn,
                          Register rd,
                          const Operand& x) {
   CheckBuffer();
   ASSERT((instr & ~(CondMask | OpCodeMask | S)) == 0);
   if (!x.rm_.is_valid()) {
     // immediate
     uint32_t rotate_imm;
     uint32_t immed_8;
     if (MustUseIp(x.rmode_) ||
         !fits_shifter(x.imm32_, &rotate_imm, &immed_8, &instr)) {
       // The immediate operand cannot be encoded as a shifter operand, so load
       // it first to register ip and change the original instruction to use ip.
       // However, if the original instruction is a 'mov rd, x' (not setting the
       // condition code), then replace it with a 'ldr rd, [pc]'
+      forceArmMode();

[Erik Corry, 2009/12/17 14:05:50]

Why do we need this here.  It deserves a comment explaining.

       RecordRelocInfo(x.rmode_, x.imm32_);
       CHECK(!rn.is(ip));  // rn should never be ip, or will be trashed
       Condition cond = static_cast<Condition>(instr & CondMask);
       if ((instr & ~CondMask) == 13*B21) {  // mov, S not set
         ldr(rd, MemOperand(pc, 0), cond);
       } else {
         ldr(ip, MemOperand(pc, 0), cond);
         addrmod1(instr, rn, rd, Operand(ip));
       }
       return;
@@ skipping 209 matching lines @@
 
 
 void Assembler::eor(Register dst, Register src1, const Operand& src2,
                     SBit s, Condition cond) {
   addrmod1(cond | 1*B21 | s, src1, dst, src2);
 }
 
 
 void Assembler::sub(Register dst, Register src1, const Operand& src2,
                     SBit s, Condition cond) {
+  // For testing purposes, a gratuitous diversion into thumb

[Erik Corry, 2009/12/17 14:05:50]

This isn't for testing, this is for real!
(But you might want to point out that the addrmod1 call switches it back at the
moment).

+  if (no_const_pool_before_ < pc_offset())
+    forceThumbMode();
   addrmod1(cond | 2*B21 | s, src1, dst, src2);
 }
 
 
 void Assembler::rsb(Register dst, Register src1, const Operand& src2,
                     SBit s, Condition cond) {
   addrmod1(cond | 3*B21 | s, src1, dst, src2);
 }
 
 
@@ skipping 935 matching lines @@
     bind(&after_pool);
   }
 
   // Since a constant pool was just emitted, move the check offset forward by
   // the standard interval.
   next_buffer_check_ = pc_offset() + kCheckConstInterval;
 }
 
 
 } }  // namespace v8::internal