A64: Handle a few TODOs.

src/a64/code-stubs-a64.cc

 // Copyright 2013 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 1806 matching lines @@
   Isolate* isolate = masm->isolate();
 
   // Build an entry frame.
   int marker = is_construct ? StackFrame::ENTRY_CONSTRUCT : StackFrame::ENTRY;
   int64_t bad_frame_pointer = -1L;  // Bad frame pointer to fail if it is used.
   __ Mov(x13, bad_frame_pointer);
   __ Mov(x12, Operand(Smi::FromInt(marker)));
   __ Mov(x11, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate)));
   __ Ldr(x10, MemOperand(x11));
 
-  // TODO(all): Pushing the marker twice seems unnecessary.
-  // In this case perhaps we could push xzr in the slot for the context
-  // (see MAsm::EnterFrame).
-  __ Push(x13, x12, x12, x10);
+  __ Push(x13, xzr, x12, x10);
   // Set up fp.
   __ Sub(fp, jssp, EntryFrameConstants::kCallerFPOffset);
 
   // Push the JS entry frame marker. Also set js_entry_sp if this is the
   // outermost JS call.
   Label non_outermost_js, done;
   ExternalReference js_entry_sp(Isolate::kJSEntrySPAddress, isolate);
   __ Mov(x10, Operand(ExternalReference(js_entry_sp)));
   __ Ldr(x11, MemOperand(x10));
   __ Cbnz(x11, &non_outermost_js);
@@ skipping 25 matching lines @@
   // checking for constant pool emission, but we do not want to depend on
   // that.
   {
     Assembler::BlockPoolsScope block_pools(masm);
     __ bind(&handler_entry);
     handler_offset_ = handler_entry.pos();
     // Caught exception: Store result (exception) in the pending exception
     // field in the JSEnv and return a failure sentinel. Coming in here the
     // fp will be invalid because the PushTryHandler below sets it to 0 to
     // signal the existence of the JSEntry frame.
-    // TODO(jbramley): Do this in the Assembler.
     __ Mov(x10, Operand(ExternalReference(Isolate::kPendingExceptionAddress,
            isolate)));
   }
   __ Str(code_entry, MemOperand(x10));
   __ Mov(x0, Operand(reinterpret_cast<int64_t>(Failure::Exception())));
   __ B(&exit);
 
   // Invoke: Link this frame into the handler chain.  There's only one
   // handler block in this code object, so its index is 0.
   __ Bind(&invoke);
@@ skipping 2247 matching lines @@
   // Sliced string. Fetch parent and correct start index by offset.
   __ Ldrsw(temp,
            UntagSmiFieldMemOperand(input_string, SlicedString::kOffsetOffset));
   __ Add(from, from, temp);
   __ Ldr(unpacked_string,
          FieldMemOperand(input_string, SlicedString::kParentOffset));
 
   __ Bind(&update_instance_type);
   __ Ldr(temp, FieldMemOperand(unpacked_string, HeapObject::kMapOffset));
   __ Ldrb(input_type, FieldMemOperand(temp, Map::kInstanceTypeOffset));
-  // TODO(all): This generates "b #+0x4". Can these be optimised out?
-  __ B(&underlying_unpacked);
+  // Now control must go to &underlying_unpacked. Since the no code is generated
+  // before then we fall through instead of generating a useless branch.
 
   __ Bind(&seq_or_external_string);
   // Sequential or external string. Registers unpacked_string and input_string
   // alias, so there's nothing to do here.
+  // Note that if code is added here, the above code must be updated.
 
   //   x0   result_string    pointer to result string object (uninit)
   //   x1   result_length    length of substring result
   //   x10  unpacked_string  pointer to unpacked string object
   //   x11  input_length     length of input string
   //   x12  input_type       instance type of input string
   //   x15  from             substring start character offset
   __ Bind(&underlying_unpacked);
 
   if (FLAG_string_slices) {
@@ skipping 106 matching lines @@
   __ bind(&single_char);
   // x1: result_length
   // x10: input_string
   // x12: input_type
   // x15: from (untagged)
   __ SmiTag(from);
   StringCharAtGenerator generator(
       input_string, from, result_length, x0,
       &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
   generator.GenerateFast(masm);
-  // TODO(jbramley): Why doesn't this jump to return_x0?
   __ Drop(3);
   __ Ret();
   generator.SkipSlow(masm, &runtime);
 }
 
 
 void StringCompareStub::GenerateFlatAsciiStringEquals(MacroAssembler* masm,
                                                       Register left,
                                                       Register right,
                                                       Register scratch1,
@@ skipping 216 matching lines @@
     __ Peek(value, (argc - 1) * kPointerSize);
     __ JumpIfNotSmi(value, &with_write_barrier);
 
     // Store the value.
     // We may need a register containing the address end_elements below,
     // so write back the value in end_elements.
     __ Add(end_elements, elements,
            Operand::UntagSmiAndScale(length, kPointerSizeLog2));
     __ Str(value, MemOperand(end_elements, kEndElementsOffset, PreIndex));
   } else {
-    // TODO(all): ARM has a redundant cmp here.
     __ B(gt, &call_builtin);
 
     __ Peek(value, (argc - 1) * kPointerSize);
     __ StoreNumberToDoubleElements(value, length, elements, x10, d0, d1,
                                    &call_builtin, argc * kDoubleSize);
   }
 
   // Save new length.
   __ Str(length, FieldMemOperand(receiver, JSArray::kLengthOffset));
 
@@ skipping 1176 matching lines @@
   // not controlled by GC.
   const int kApiStackSpace = 4;
 
   // Allocate space for CallApiFunctionAndReturn can store some scratch
   // registeres on the stack.
   const int kCallApiFunctionSpillSpace = 4;
 
   FrameScope frame_scope(masm, StackFrame::MANUAL);
   __ EnterExitFrame(false, x10, kApiStackSpace + kCallApiFunctionSpillSpace);
 
-  // TODO(all): Optimize this with stp and suchlike.
   ASSERT(!AreAliased(x0, api_function_address));
   // x0 = FunctionCallbackInfo&
   // Arguments is after the return address.
   __ Add(x0, masm->StackPointer(), 1 * kPointerSize);
   // FunctionCallbackInfo::implicit_args_ and FunctionCallbackInfo::values_
   __ Add(x10, args, Operand((FCA::kArgsLength - 1 + argc) * kPointerSize));
   __ Stp(args, x10, MemOperand(x0, 0 * kPointerSize));
   // FunctionCallbackInfo::length_ = argc and
   // FunctionCallbackInfo::is_construct_call = 0
   __ Mov(x10, argc);
@@ skipping 72 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64