* Fix new snapshot code on ARM.

src/serialize.cc

 // Copyright 2006-2008 the V8 project authors. 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.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1931 matching lines @@
         }
         current++;
         break;
       }
       case CODE_OBJECT_SERIALIZATION: {
         Object* new_code_object = NULL;
         ReadObject(&new_code_object);
         Code* code_object = reinterpret_cast<Code*>(new_code_object);
         // Setting a branch/call to another code object from code.
         Address location_of_branch_data = reinterpret_cast<Address>(current);
-        Assembler::set_target_address_at(location_of_branch_data,
-                                         code_object->instruction_start());
+        Assembler::set_target_at(location_of_branch_data,
+                                 code_object->instruction_start());
         location_of_branch_data += Assembler::kCallTargetSize;
         current = reinterpret_cast<Object**>(location_of_branch_data);
         break;
       }
       case BACKREF_SERIALIZATION: {
         // Write a backreference to an object we unpacked earlier.
         int backref_space = source_->Get();
         if (backref_space == NEW_SPACE && space != NEW_SPACE) {
           Heap::RecordWrite(address,
                             reinterpret_cast<Address>(current) - address);
         }
         *current++ = GetAddress(backref_space);
         break;
       }
       case CODE_BACKREF_SERIALIZATION: {
         int backref_space = source_->Get();
         // Can't use Code::cast because heap is not set up yet and assertions
         // will fail.
         Code* code_object = reinterpret_cast<Code*>(GetAddress(backref_space));
         // Setting a branch/call to previously decoded code object from code.
         Address location_of_branch_data = reinterpret_cast<Address>(current);
-        Assembler::set_target_address_at(location_of_branch_data,
-                                         code_object->instruction_start());
+        Assembler::set_target_at(location_of_branch_data,
+                                 code_object->instruction_start());
         location_of_branch_data += Assembler::kCallTargetSize;
         current = reinterpret_cast<Object**>(location_of_branch_data);
         break;
         }
       case EXTERNAL_REFERENCE_SERIALIZATION: {
         int reference_id = source_->GetInt();
         Address address = external_reference_decoder_->Decode(reference_id);
         *current++ = reinterpret_cast<Object*>(address);
         break;
       }
@@ skipping 179 matching lines @@
   Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
   serializer_->SerializeObject(target, CODE_TARGET_REPRESENTATION);
   bytes_processed_so_far_ += Assembler::kCallTargetSize;
 }
 
 
 void Serializer2::ObjectSerializer::OutputRawData(Address up_to) {
   Address object_start = object_->address();
   int up_to_offset = up_to - object_start;
   int skipped = up_to_offset - bytes_processed_so_far_;
+  // This assert will fail if the reloc info gives us the target_address_address
+  // locations in a non-ascending order.  Luckily that doesn't happen.
   ASSERT(skipped >= 0);
   if (skipped != 0) {
     sink_->Put(RAW_DATA_SERIALIZATION, "raw data");
     sink_->PutInt(skipped, "length");
     for (int i = 0; i < skipped; i++) {
       unsigned int data = object_start[bytes_processed_so_far_ + i];
       sink_->Put(data, "byte");
     }
   }
   bytes_processed_so_far_ += skipped;
@@ skipping 54 matching lines @@
       fullness_[space] = RoundUp(fullness_[space], Page::kPageSize);
     }
   }
   int allocation_address = fullness_[space];
   fullness_[space] = allocation_address + size;
   return allocation_address;
 }
 
 
 } }  // namespace v8::internal