
The following Optimized Selectors are always compiled
to a special bytecode and never do a message send.
  selector            bytecode semantics
  --------            -----------------
   #==                  Object >> ==
   #~~                  Object >> ~~
   #isKindOf:           Object>>isKindOf:
   #_isArray            Object >> _isArray
   #_isExceptionClass   Object >> _isExceptionClass
   #_isExecBlock        Object >> _isExecBlock
   #_isFloat            Object >> _isFloat
   #_isInteger          Object >> _isInteger
   #_isNumber           Object >> _isNumber
   #_isOneByteString    Object >> _isOneByteString
   #_isRange            Object >> _isRange
   #_isRegexp           Object >> _isRegexp
   #_isRubyHash         Object >> _isRubyHash
   #_isScaledDecimal    Object >> _isScaledDecimal
   #_isSmallInteger     Object >> _isSmallInteger
   #_isSymbol           Object >> _isSymbol
   #_stringCharSize     Object >> _stringCharSize


The selector #_isRubyString is always compiled
to a special bytecode and never does a message send.
There is no implementation of Object >> _isRubyString
in the Smalltalk base image.
_isRubyString bytecode returns true if receiver's class
is a subclass of String and is not identical to Symbol.


Special arithmetic sends for SmallInteger .
For these selectors, if receiver and argument are both instances
of SmallInteger, and if the result would be a SmallInteger, the bytecode
performs the arithmetic operation without doing a message send.
Otherwise a message send is done in the environment specified by
any @env prefix, or the environment in which the method is compiled.
  selector    bytecode semantics
  --------    -----------------
   #+         SmallInteger >> +
   #-         SmallInteger >> -
   #*         SmallInteger >> *
   #bitAnd:   SmallInteger >> bitAnd:
   #bitXor:   SmallInteger >> bitXor:


Reserved selectors for Loops .

The following Reserved Selectors are compiled direct to bytecodes
  selector         bytecode semantics
  --------         -----------------
  #timesRepeat:    Number >> timesRepeat:
  #_downTo:by:do:  Number >> _downTo:by:do:
  #_downTo:do:     Number >> _downTo:do:
  #to:by:do:       Object >> to:by:do:
  #to:do:          Object >> to:do:

The Loop implementations make use of the following arithmetic bytecodes .
  SEND_SPECIAL_LT          SmallInteger >> <
  SEND_SPECIAL_PLUS        SmallInteger >> +
  SEND_SPECIAL_MINUS,      SmallInteger >> -
  SEND_SPECIAL_nonZeroGTE  Number >> nonZeroGte:
For these bytecodes, if receiver and argument are both instances
of SmallInteger, and if the result would be a SmallInteger, the bytecode
performs the arithmetic operation without doing a message send.
Otherwise a message send is done in the environment specified by
any @env prefix of the Loop selector,
or the environment in which the method is compiled.

The Loop implementations make use of the following compare bytecodes
  SEND_SPECIAL_GTE      SmallInteger >> >=
  SEND_SPECIAL_Lte      SmallInteger >> <=
If the receiver and argument of the compare are both instances of
SmallInteger the compare is done without doing a message send.
Otherwise a message send is done in the environment specified by
any @env prefix of the Loop selector,
or the environment in which the method is compiled.

