Perl5 リファレンス

       goto LABEL

       goto EXPR

       goto &NAME
               The `goto-LABEL' form finds the statement labeled
               with LABEL and resumes execution there.  It may
               not be used to go into any construct that requires
               initialization, such as a subroutine or a
               `foreach' loop.  It also can't be used to go into
               a construct that is optimized away, or to get out
               of a block or subroutine given to `sort'.  It can
               be used to go almost anywhere else within the
               dynamic scope, including out of subroutines, but
               it's usually better to use some other construct
               such as `last' or `die'.  The author of Perl has
               never felt the need to use this form of `goto' (in
               Perl, that is--C is another matter).

               The `goto-EXPR' form expects a label name, whose
               scope will be resolved dynamically.  This allows
               for computed `goto's per FORTRAN, but isn't
               necessarily recommended if you're optimizing for

                   goto ("FOO", "BAR", "GLARCH")[$i];

               The `goto-&NAME' form is quite different from the
               other forms of `goto'.  In fact, it isn't a goto
               in the normal sense at all, and doesn't have the
               stigma associated with other gotos.  Instead, it
               substitutes a call to the named subroutine for the
               currently running subroutine.  This is used by
               `AUTOLOAD' subroutines that wish to load another
               subroutine and then pretend that the other
               subroutine had been called in the first place
               (except that any modifications to `@_' in the
               current subroutine are propagated to the other
               subroutine.)  After the `goto', not even `caller'
               will be able to tell that this routine was called

               NAME needn't be the name of a subroutine; it can
               be a scalar variable containing a code reference,
               or a block which evaluates to a code reference.