Main Page   Class Hierarchy   Compound List   File List   Header Files   Compound Members   File Members  


This is the verbatim text of the frame.h include file.
/* Sun-$Revision: 23.12 $ */

/* Copyright 1992-9 Sun Microsystems, Inc. and Stanford University.
   See the LICENSE file for license information. */

# pragma interface

/* Portability strategy:
   Each platform needs its own frame class.
   Yet each one shares much in common.
   Our solution is to #include the machine-dependent part into the
   class definition, and have a platform.frame.c for the machine-dependent

// in addition to fwded routines
//  a new platform must typedef frame

typedef void (*returnTrapHandlerFn)(...);

class Conversion; // for friend declaration below

class frame {

  // here are platform-dependent routines that must be supplied for
  //  each platform
  // I think the "inner" refers to inner in the Beta sense; these are override

 public:      frame* sender();

 protected:   char**   real_return_addr_addr();
 public:      void** location_addr(Location r, RegisterLocator* rl = NULL);

 protected:   void  copy_to(char* sp, char* caller, char* pc, bool adjust);
 protected:   frame* copy(fint nsenders = 0, bool adjustBlocks = false);

 protected:  void adjust_blocks(frame* oldScope,  frame* newScope, RegisterLocator* rl);
 public:     void fix_frame(char* pc, char* sp);

 public:      frame* home_frame_of_block_scope(frame* hint = NULL);
 public:      frame* block_scope_of_home_frame();
 public:      frame* home_frame_of_vfo_locals(frame* hint = NULL);
 public:      frame* vfo_locals_of_home_frame();

 protected:   int32 frame_size_of_uncopied_frame();

 public:      char* c_entry_point();
 public:      char* c_return_pc();

 public:      frame* make_full_frame(char* pc); // return this on 68k
 public:      frame* make_full_frame_after_trap(char* pc); // return this on 68k
 public:      frame* make_full_frame_on_user_stack(); // return this on 68k

 public:      sendDesc* send_desc();

 public:     void scavenge_contents(RegisterLocator*);
 public:     void gc_mark_contents(RegisterLocator*);
 public:     void gc_unmark_contents(RegisterLocator*);
 public:     void verify_oops(RegisterLocator*);
 public:     void switch_pointers(oop from, oop to, RegisterLocator*);
 public:     void oops_do(oopsDoFn f, RegisterLocator*);
 public:     void stack_locations_do(oopsDoFn f, RegisterLocator*); // iterates through marked locs
 public:     void zap(RegisterString mask, RegisterLocator*); // zap all locations unmarked in mask

 protected:  RegisterString mask_if_present(); // helper for above fns
// used for scavenging, must return allocated location
//  for every interpreter state struct that may exist
//  return IllegalLocation for non-interp frame
// (the 2nd fn does the same for block scope (one up in sparc))

 protected:  static Location location_of_interpreter_of_block_scope(void* entry_point);

 protected:  void print_compiled();
 protected:   oop get_lookup_arg(fint index);

  // now the platform-independent ones:

 public:     frame* sendee(frame* hint = NULL);
 public:     void verify(int n, RegisterLocator* rl);

// nmethod_frame_chain methods
 protected:   frame** nmethod_frame_chain_addr();

  frame*     nmethod_frame_chain();
  void   set_nmethod_frame_chain(frame* f);

  // currentPC methods: Sometimes, we need to regain control before
  //  a given frame is returned INTO. So we patch the return address
  //  that would return into this frame to go somewhere else, and
  //  store what was there in the frame's currentPC.

  char** currentPC_addr();
  char* currentPC();
  void  set_currentPC(char* p);

  // real return address, where the pc for returning TO ME is


  char*      real_return_addr();
  void   set_real_return_addr(char* x);

  // return address routines (deal with patching)
  // NB: this is the address where I will resume in my method,
  //   upon return to me, not the address I will return TO. -- dmu

  char* return_addr();
  void set_return_addr(char* addr);
  void adjust_return_addr(int32 delta);
  void fix_current_return_address(char* addr);
 public:    void  patch(frame* prev, bool forceSelfFrame = false);
 public:    void  patch_profiler_trap();
 protected: void  patch_interpreted_self_frame(bool forProfiling);
 protected: void  patch_compiled_self_frame(returnTrapHandlerFn new_fn);
 protected: returnTrapHandlerFn
                  return_addr_for_patching(bool forceSelfFrame, frame* sendee);
 protected: void  trace_patch(returnTrapHandlerFn new_fn);

  bool is_patched();
  void remove_patch();
  void remove_patches_up_to_C();
  frame* get_patched_self_frame(char* sp_of_patched_frame);

// registers

// conversion & recompilation routines

  frame* selfSender();
  frame* immediateSelfSender();         // same, but don't skip C frames
  Stack* my_stack();
  int32 frame_size();           // in oops

  // testers
  bool is_compiled_self_frame();
  bool is_interpreted_self_frame();
  interpreter* get_interpreter();
  interpreter* get_interpreter_of_block_scope();
  bool is_self_frame();
  bool is_first_self_frame();
  fint vdepth(bool includePrologueVframe = false);

  bool is_in_prologue();

// operations


  nmethod* code();
  void nmethod_moved_by(int32 delta);
  // tracing operations
  void trace(oop receiver, nmethod* c);
  void traceAssignment(oop receiver, nmethod* c);
  void traceLookup(oop receiver, nmethod* c);
  void print_trace_indent();
  void print();  
  void printVerbose();
  void printVerbose_on_this_platform();
  void printRegs();
  // helpers for copy:
  frame* find_last_frame_to_copy(fint nsenders);
  frame* copy_frames_through(frame* last_frame_to_copy);
  int32  copy_through_oop_count(frame* last_frame_to_copy);
  void   adjust_blocks_of_copied_frames(fint, frame*);
  void   adjust_frame_links_of_copied_frames(   frame*, frame*);

  friend struct Profiler;
  friend struct Recompilation;
  friend class ::Conversion; //  currently platform-dependent
# include "_frame_pd.h.incl"

inline bool  isPatchedReturnAddress(char* r) {
    return r == first_inst_addr(ReturnTrap)
        || r == first_inst_addr(PrimCallReturnTrap)
        || r == first_inst_addr(ProfilerTrap); 

// called from assembly glue
extern "C" {
  void HandleReturnTrap(oop result, char* sp,
                        bool nlr, frame* home, int32 homeID);
# if defined(FAST_COMPILER) || defined(SIC_COMPILER)
  char *HandleProfilerTrap(char* return_address);
# endif

# define SavedFrameChain ((frame*)1)
# define NoFrameChain    NULL

Generated at Tue Jun 27 12:13:45 2000 for SelfVM by doxygen 1.0.0 written by Dimitri van Heesch, © 1997-1999