MIPS: Added support for Loongson architectures.

src/mips/ic-mips.cc

 // Copyright 2012 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 770 matching lines @@
   // to the unmapped lookup with the parameter map in scratch1.
   __ lw(scratch2, FieldMemOperand(scratch1, FixedArray::kLengthOffset));
   __ Subu(scratch2, scratch2, Operand(Smi::FromInt(2)));
   __ Branch(unmapped_case, Ugreater_equal, key, Operand(scratch2));
 
   // Load element index and check whether it is the hole.
   const int kOffset =
       FixedArray::kHeaderSize + 2 * kPointerSize - kHeapObjectTag;
 
   __ li(scratch3, Operand(kPointerSize >> 1));
-  __ mul(scratch3, key, scratch3);
+  __ Mul(scratch3, key, scratch3);
   __ Addu(scratch3, scratch3, Operand(kOffset));
 
   __ Addu(scratch2, scratch1, scratch3);
   __ lw(scratch2, MemOperand(scratch2));
   __ LoadRoot(scratch3, Heap::kTheHoleValueRootIndex);
   __ Branch(unmapped_case, eq, scratch2, Operand(scratch3));
 
   // Load value from context and return it. We can reuse scratch1 because
   // we do not jump to the unmapped lookup (which requires the parameter
   // map in scratch1).
   __ lw(scratch1, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
   __ li(scratch3, Operand(kPointerSize >> 1));
-  __ mul(scratch3, scratch2, scratch3);
+  __ Mul(scratch3, scratch2, scratch3);
   __ Addu(scratch3, scratch3, Operand(Context::kHeaderSize - kHeapObjectTag));
   __ Addu(scratch2, scratch1, scratch3);
   return MemOperand(scratch2);
 }
 
 
 static MemOperand GenerateUnmappedArgumentsLookup(MacroAssembler* masm,
                                                   Register key,
                                                   Register parameter_map,
                                                   Register scratch,
                                                   Label* slow_case) {
   // Element is in arguments backing store, which is referenced by the
   // second element of the parameter_map. The parameter_map register
   // must be loaded with the parameter map of the arguments object and is
   // overwritten.
   const int kBackingStoreOffset = FixedArray::kHeaderSize + kPointerSize;
   Register backing_store = parameter_map;
   __ lw(backing_store, FieldMemOperand(parameter_map, kBackingStoreOffset));
   Handle<Map> fixed_array_map(masm->isolate()->heap()->fixed_array_map());
   __ CheckMap(backing_store, scratch, fixed_array_map, slow_case,
               DONT_DO_SMI_CHECK);
   __ lw(scratch, FieldMemOperand(backing_store, FixedArray::kLengthOffset));
   __ Branch(slow_case, Ugreater_equal, key, Operand(scratch));
   __ li(scratch, Operand(kPointerSize >> 1));
-  __ mul(scratch, key, scratch);
+  __ Mul(scratch, key, scratch);
   __ Addu(scratch,
           scratch,
           Operand(FixedArray::kHeaderSize - kHeapObjectTag));
   __ Addu(scratch, backing_store, scratch);
   return MemOperand(scratch);
 }
 
 
 void KeyedLoadIC::GenerateNonStrictArguments(MacroAssembler* masm) {
   // ---------- S t a t e --------------
@@ skipping 909 matching lines @@
     Register reg = Register::from_code(Assembler::GetRs(instr_at_patch));
     patcher.masm()->andi(at, reg, kSmiTagMask);
     patcher.ChangeBranchCondition(eq);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS