((cite: hotspot/src/share/vm/runtime/sharedRuntime.hpp))
    // Runtime is the base class for various runtime interfaces
    // (InterpreterRuntime, CompilerRuntime, etc.). It provides
    // shared functionality such as exception forwarding (C++ to
    // Java exceptions), locking/unlocking mechanisms, statistical
    // information, etc.

    class SharedRuntime: AllStatic {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrans.cpp))
    // This file contains copies of the fdlibm routines used by
    // StrictMath. It turns out that it is almost always required to use
    // these runtime routines; the Intel CPU doesn't meet the Java
    // specification for sin/cos outside a certain limited argument range,
    // and the SPARC CPU doesn't appear to have sin/cos instructions. It
    // also turns out that avoiding the indirect call through function
    // pointer out to libjava.so in SharedRuntime speeds these routines up
    // by roughly 15% on both Win32/x86 and Solaris/SPARC.

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrans.cpp))
    static double __ieee754_log(double x) {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrans.cpp))
    static double __ieee754_log10(double x) {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrans.cpp))
    static double __ieee754_exp(double x) {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrans.cpp))
    double __ieee754_pow(double x, double y) {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrig.cpp))
    static SAFEBUF int __ieee754_rem_pio2(double x, double *y) {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrig.cpp))
    static double __kernel_sin(double x, double y, int iy)

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrig.cpp))
    static double __kernel_cos(double x, double y)

    ((cite: hotspot/src/share/vm/runtime/sharedRuntimeTrig.cpp))
    static double __kernel_tan(double x, double y, int iy)

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.hpp))
    // ---------------------------------------------------------------------------
    // Implementation of AdapterHandlerLibrary
    //
    // This library manages argument marshaling adapters and native wrappers.
    // There are 2 flavors of adapters: I2C and C2I.
    //
    // The I2C flavor takes a stock interpreted call setup, marshals the
    // arguments for a Java-compiled call, and jumps to Rmethod-> code()->
    // code_begin().  It is broken to call it without an nmethod assigned.
    // The usual behavior is to lift any register arguments up out of the
    // stack and possibly re-pack the extra arguments to be contigious.
    // I2C adapters will save what the interpreter's stack pointer will be
    // after arguments are popped, then adjust the interpreter's frame
    // size to force alignment and possibly to repack the arguments.
    // After re-packing, it jumps to the compiled code start.  There are
    // no safepoints in this adapter code and a GC cannot happen while
    // marshaling is in progress.
    //
    // The C2I flavor takes a stock compiled call setup plus the target method in
    // Rmethod, marshals the arguments for an interpreted call and jumps to
    // Rmethod->_i2i_entry.  On entry, the interpreted frame has not yet been
    // setup.  Compiled frames are fixed-size and the args are likely not in the
    // right place.  Hence all the args will likely be copied into the
    // interpreter's frame, forcing that frame to grow.  The compiled frame's
    // outgoing stack args will be dead after the copy.
    //
    // Native wrappers, like adapters, marshal arguments.  Unlike adapters they
    // also perform an offical frame push & pop.  They have a call to the native
    // routine in their middles and end in a return (instead of ending in a jump).
    // The native wrappers are stored in real nmethods instead of the BufferBlobs
    // used by the adapters.  The code generation happens here because it's very
    // similar to what the adapters have to do.

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.hpp))
    class AdapterHandlerLibrary: public AllStatic {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.hpp))
    class AdapterHandlerEntry : public BasicHashtableEntry {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.cpp))
    // A simple wrapper class around the calling convention information
    // that allows sharing of adapters for the same calling convention.
    class AdapterFingerPrint : public CHeapObj {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.cpp))
    // A hashtable mapping from AdapterFingerPrints to AdapterHandlerEntries
    class AdapterHandlerTable : public BasicHashtable {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.cpp))
    class AdapterHandlerTableIterator : public StackObj {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.cpp))
      AdapterHandlerTableIterator iter(_adapters);
      while (iter.has_next()) {
        AdapterHandlerEntry* a = iter.next();
    ...
      }

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.cpp))
    #ifndef PRODUCT

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.cpp))
    class MethodArityHistogram {

    ((cite: hotspot/src/share/vm/runtime/sharedRuntime.cpp))
      MethodArityHistogram() {
        MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
        _max_arity = _max_size = 0;
        for (int i = 0; i < MAX_ARITY; i++) _arity_histogram[i] = _size_histogram [i] = 0;
        CodeCache::nmethods_do(add_method_to_histogram);
        print_histogram();
      }