A bunch of changes to get the ARM port compiling again.

src/codegen-arm.h

 // 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 144 matching lines @@
                               int end_position,
                               bool is_expression,
                               bool is_toplevel,
                               Handle<Script> script);
 
   // Accessors
   MacroAssembler* masm() { return masm_; }
 
   VirtualFrame* frame() const { return frame_; }
 
-  void set_frame(VirtualFrame* frame) { frame_ = frame; }
+  bool has_valid_frame() const { return frame_ != NULL; }
 
-  void delete_frame() {
-    delete frame_;
-    frame_ = NULL;
-  }
+  void SetFrame(VirtualFrame* frame);
+
+  void DeleteFrame();
 
   CodeGenState* state() { return state_; }
   void set_state(CodeGenState* state) { state_ = state; }
 
   void AddDeferred(DeferredCode* code) { deferred_.Add(code); }
 
  private:
   // Construction/Destruction
   CodeGenerator(int buffer_size, Handle<Script> script, bool is_eval);
   virtual ~CodeGenerator() { delete masm_; }
@@ skipping 131 matching lines @@
   // is optimal compared to the default code generated for a switch statement
   // on that platform.
   int FastCaseSwitchMinCaseCount();
 
   // Allocate a jump table and create code to jump through it.
   // Should call GenerateFastCaseSwitchCases to generate the code for
   // all the cases at the appropriate point.
   void GenerateFastCaseSwitchJumpTable(SwitchStatement* node,
                                        int min_index,
                                        int range,
-                                       JumpTarget* fail_label,
-                                       Vector<JumpTarget*> case_targets,
-                                       Vector<JumpTarget> case_labels);
+                                       Label* default_label,
+                                       Vector<Label*> case_targets,
+                                       Vector<Label> case_labels);
 
   // Generate the code for cases for the fast case switch.
   // Called by GenerateFastCaseSwitchJumpTable.
   void GenerateFastCaseSwitchCases(SwitchStatement* node,
-                                   Vector<JumpTarget> case_labels,
-                                   JumpTarget* table_start);
+                                   Vector<Label> case_labels,
+                                   VirtualFrame* start_frame);
 
   // Fast support for constant-Smi switches.
   void GenerateFastCaseSwitchStatement(SwitchStatement* node,
                                        int min_index,
                                        int range,
                                        int default_index);
 
   // Fast support for constant-Smi switches. Tests whether switch statement
   // permits optimization and calls GenerateFastCaseSwitch if it does.
   // Returns true if the fast-case switch was generated, and false if not.
   bool TryGenerateFastCaseSwitchStatement(SwitchStatement* node);
 
 
   // Methods used to indicate which source code is generated for. Source
   // positions are collected by the assembler and emitted with the relocation
   // information.
-  void CodeForStatement(Node* node);
+  void CodeForFunctionPosition(FunctionLiteral* fun);
+  void CodeForStatementPosition(Node* node);
   void CodeForSourcePosition(int pos);
 
   // Is the given jump target the actual (ie, non-shadowed) function return
   // target?
   bool IsActualFunctionReturn(JumpTarget* target);
 
   bool is_eval_;  // Tells whether code is generated for eval.
+
+#ifdef DEBUG
+  // True if the registers are valid for entry to a block.
+  bool HasValidEntryRegisters();
+#endif
+
   Handle<Script> script_;
   List<DeferredCode*> deferred_;
 
   // Assembler
   MacroAssembler* masm_;  // to generate code
 
   // Code generation state
   Scope* scope_;
   VirtualFrame* frame_;
   Condition cc_reg_;
@@ skipping 12 matching lines @@
   friend class VirtualFrame;
   friend class JumpTarget;
   friend class Reference;
 
   DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODEGEN_ARM_H_