System for extending software calls to functions on another processor by means of a communications buffer

Abstract

A method is provided for adding extended functions to a multiprocessor system, specifically, functions that may be called from programming running on a first processor and executed by a second processor. A set of generic entry point commands is provided. Each extended function is associated with an entry point command, that is appropriate for the function's argument format and return requirements, if any. Each entry point command invokes a communications routine that handles the transfer of argument data and return values, if any, between processors.

Claims

What is claimed is:

1. A method of using a multiprocessor computer system having a first processor and a second processor in data communication with each other via a communications buffer, to call and execute an extended function, wherein said extended function is called by programing of said first processor, but executed by said second processor with function arguments transferred from said first processor to said second processor, comprising the steps of:

storing a communications program in memory of said first processor, wherein said communications program has a predetermined number of a plurality of different routines for transferring different types of function arguments to said communications buffer, and wherein each routine has an entry point for receiving entry point arguments;

providing an application program having a plurality of extended function calls;

redefining said extended function call as an entry point call, wherein said entry point call comprises an entry point command, said entry point command representing an entry point of said communications program of a corresponding one of said routines, and an entry point argument, said entry point argument having values representing a function identifier of said extended function and said types of function arguments corresponding to said corresponding one of said routines;

using said first processor to execute said application program having said redefined extended function call;

using said first processor to execute a selected one of said routines of said communications program at said entry point corresponding to said entry point command in accordance with said entry point argument, such that said function identifier and data represented by said extended function arguments are uploaded to said communications buffer;

using said second processor to download said extended function identifier from said communications buffer;

using said second processor to select an extended function definition associated with said extended function identifier from memory of said second processor system;

using said second processor to pass arguments to said extended function by passing to said extended function a buffer pointer to said communications buffer; and

using said second processor to execute said extended function.

2. The method of claim 1, wherein said extended function has at least one argument in the form of a pointer to data, and wherein said step of using said first processor to execute said selected one of said routines of said communications program such that data represented by said extended function arguments are uploaded, comprises uploading the length of said data as well as said data corresponding to each pointer into said communications buffer.

3. The method of claim 2, wherein said extended function has at least one argument in the form of an immediate argument, and wherein said step of using said first processor to execute said selected one of said routines of said communications program such that data represented by said extended function arguments is uploaded, comprises uploading each immediate argument into said communications buffer.

4. The method of claim 2, wherein said extended function has a return value, and wherein said step of using said second processor to execute said extended function is in response to receipt of the length of said data, and further comprising the step of using said second processor to store said return value in said communications buffer.

5. The method of claim 2, wherein:

said step of storing said communications program having a plurality of routines for transferring different types of function arguments includes storing said communications program having routines for differing predetermined combinations of types of function arguments for transmission to said communications buffer and types of function returns for recall from said communications buffer;

said extended function has a function return;

said step of using said second processor to execute said extended function includes uploading a return value into said communications buffer; and

further comprising the step of using said first processor to download said return value from said communications buffer after said step of using said second processor to execute said extended function.

6. The method of claim 5 wherein:

at least one of said routines of said communications program has a function return in the form of at least one immediate return;

said step of uploading a return value into said communications buffer includes uploading a return immediate value corresponding to each immediate return into said communications buffer; and

said step of using said first processor to download said return value from said communications buffer includes downloading each return immediate value from said communications buffer.

7. The method of claim 5 wherein:

at least one of said routines of said communications program has a function return in the form of at least one return pointer to data;

said step of uploading a return value into said communications buffer includes uploading the length of said data as well as data corresponding to each return pointer to data into said communications buffer; and

said step of using said first processor to download said return value from said communications buffer includes downloading said each length of said data and each return pointer to data from said communications buffer.

8. The method of claim 5 wherein:

at least one of said routines of said communications program has a function return in the form of at least one immediate return and at least one return pointer to data;

said step of uploading a return value into said communications buffer includes uploading a return immediate value corresponding to each immediate return and the length of said data as well as data corresponding to each return pointer to data into said communications buffer; and

said step of using said first processor to download said return value from said communications buffer includes downloading each return immediate value and each length of said data and each return pointer to data from said communications buffer.

9. The method of claim 1, wherein said step of using said second processor to execute said extended function comprises using a stack memory area to provide said second processor with a pointer to said communications buffer.

Description

TECHNICAL FIELD OF THE INVENTION

This invention generally relates to computer processing and more particularly to a method, used with a multiprocessor system, of calling a software function from a program running on a first processor, such that the function is executed by a second processor.

BACKGROUND OF THE INVENTION

An important development in computer processing has been systems having more than one processor, each capable of independent action to execute applications programming. Different program tasks may be assigned to different processors, with the result that the execution time of the programming is substantially reduced. One approach to dividing tasks in a multiprocessor system is designating subprograms, which link into a main program running on a first processor, for execution by a second processor.

When designated functions are to be executed by a second processor, a problem with implementing such a division of tasks is that the processors need a means for exchanging data. The physical system requirements of transmitting data in bits, such as communications buffers and data lines, are known--the difficulty lies in the fact that a function's arguments and return values are not determined until run time. The size and type of this data determine how the data may be communicated. Thus, the communications routine must accomplish the run time exchange of values associated with the function.

Because of the difficulty in programming communications programming to solve this problem, some multiprocessor systems have a second processor whose functions are fixed. The user cannot add new functions and is limited to the functions provided with the processor.

In other multiprocessor systems, a programmer may add functions, but must either create a support routine to permit the second processor to execute the function, or use a nonstandard format when defining the function. For this reason, regardless of whether the programmer wrote his or her own function definitions or obtained pre-written function definitions from another, substantial programming effort was required to ensure that the added function would operate in the multiprocessor system.

Thus, a need exists for a multiprocessor system in which functions are extensible. The programmer should not be limited to using only a set number of functions that the second processor is capable of understanding and should be able to add functions to be executed by the second processor with a minimum of programming effort.

SUMMARY OF THE INVENTION

One aspect of the invention is a method of modifying a software program for use with a multiprocessor computer system, such that a function may be called from a program running on a first processor but be executed by a second processor. The method involves selecting a function appropriate for the second processor, selecting a special entry point that is associated with a certain argument format and return requirements, defining the function consistently with that entry point, programming a communications routine consistent with the entrypoint, and adding a function call to the main program.

Another aspect of the invention is a method of programming extended functions for use on a multiprocessor system. The steps of the method are generally the same as those of modifying an existing program, as set out in the preceding paragraph, except that the function is originally coded to conform to properties of a selected entry point.

Another aspect of the invention is a method of using a multiprocessor computer system to divide program tasks between processors. A function to be executed by a second processor is called from a program being executed on a first processor. The function's call is directed to a special entry point that invokes a communications routine. The function's argument data is structured in a format consistent with the entry point. The communications routine invoked at the entry point uses a communications buffer for handshaking between processors, and for passing information to identify and invoke the function. The second processor downloads data for identifying the function and a means for locating its argument data. The entry point may also be associated with a return requirement, which invokes an associated communications routine for transferring a return value, if any, and for modifying data used by the host, if that is required.

Another aspect of the invention is a computer system that permits functions called from a main program running on one processor to be executed by a second processor. Each one of a set of entry points is associated with various function properties. Each entry point is also associated with communications programming that enables the processors to exchange values for function arguments and return values, if any.

A technical advantage of the invention is that a user may program extended functions for a multiprocessor system without substantial programming effort. Special entry points avoid the need to program a special communications routine for each function. Using these entry points, the two processors may use generalized communications routines to exchange values associated with executing the function.

BRIEF DESCRIPTION OF THE DRAWINGS

The novel features characteristic of the invention are set forth in the appended claims. The invention itself, however, as well as modes of use and further advantages, is best understood by reference to the following description of illustrative embodiments when read in conjunction with the accompanying drawings.

FIG. 1 is a flow diagram of the steps of creating an extended software function for a multiprocessor system.

FIG. 1A is a logic diagram illustrating the selection of entry points in accordance with the invention.

FIG. 2 is a flow diagram of the steps of using a multiprocessor system to run a program on a first processor, which calls a function executed by a second processor.

FIG. 3 is a block diagram of a multiprocessor system typical of a system with which the invention is used.

FIGS. 4a, 4b, and 4c illustrate a communication buffer used to transfer argument data of the function to be executed by a subprocessor of the system of FIG. 3.

FIG. 5 is a block diagram illustrating a substep of FIG. 2 and post downloading activity on the second processor.

DETAILED DESCRIPTION OF THE INVENTION

Environment of the Invention

The description of the invention is primarily directed to implementation of the invention with programs written in the C programming language. However, the programming environment in which the invention will operate is not unique to C. Some common programming language characteristics are described below, both for definitional purposes, and for the purpose of setting out those characteristics that permit the invention to be used with other languages.

The structuring of tasks into program modules, i.e., subprograms, is a useful feature of higher level programming languages. A subprogram permits a main program to execute the process that the subprogram represents without the need to explicitly set out all the steps. This is accomplished by calling the subprogram from within the main program.

A subprogram definition is a collection of statements that describes the actions of the subprogram. A subprogram header is the first line of the subprogram definition, and serves several purposes. First, it may specify that the following syntactic unit is a subprogram definition of some kind. Second, it provides a name for the subprogram. Third, it may optionally supply a list of formal parameters.

Parameters are used to pass values between subprograms. The use of parameters is related to a further feature of subprograms, i.e., their reusability. This is accomplished by the use of parameters in subprogram headings, rather than specific values. The same subprogram may be used more than once in the program, or may be used in a different program, without being entirely redefined. The words "parameter" and "argument" are often used synonymously.

A subprogram call is the explicit request in the main program for the subprogram to be executed. Subprogram calls include the name of the subprogram and a list of the actual parameters to be bound to the formal parameters of the subprogram.

Generally, there are two types of subprograms: procedures and functions. Procedures, known as subroutines in FORTRAN, modify variables and parameters in the calling program. Functions, which are modeled after math functions, do not modify their parameters or outside variables, but rather simply return a value to the calling program.

Apart from the above characteristics, many characteristics of subprograms and their calls are language unique. For example, the headers of subprograms written in FORTRAN or Pascal have special words that identify the subprogram as such, i.e., "subroutine" or "procedure", respectively. On the other hand, the header of a C subprogram has no such special word. Furthermore, in C, all subprograms are functions and the header of a function is recognized by context rather than by a special word. In C, a function is equivalent to a subroutine or function in FORTRAN or a procedure in Pascal. However, in C, it is possible to arrange for a function to modify a variable in a calling routine so that the function operates like a procedure of other languages.

Embodiments of the Invention

For purposes of this description, a subprogram that a user might desire to add to a multiprocessor system, is referred to as an "extended function". More specifically, an extended function is a function that is to be called by a main program running on a first processor of a multiprocessor system, but executed by a second processor. The system running the main program is referred to as the "host processor system" or "host system". The system on which the extended function is to be executed is the "subprocessor system" or "subsystem".

It is assumed that the multiprocessor system has a communications system for handling the passing of data between processors. Hardware features of the multiprocessor system, including the communications system, are discussed below, in connection with FIG. 3.

The "user" of the invention may be various persons who provide parts of a multiprocessor system. For example, the user may be a programmer who desires to add extended functions to a program being prepared for use on the system. Or, the user may be a programmer who supplies extended functions for use by other programmers. The user may be someone actually running a program having extended functions. Furthermore, the invention may be made or sold by any one of these users. The various aspects of the invention discussed below are directed to different users and different physical embodiments of the invention.

The invention is based on a premise that to use extended functions on a multiprocessor system, the host system and the subsystem must have a means for communicating arguments and return values, if any. Yet, arguments and return requirements are two properties that can vary greatly, and thus require different communications programming to handle such transfers. The function's return requirements determine whether the function needs no return value, needs a return value, or modifies variables. The format of the function's arguments, including its argument types, determine how the arguments are passed on the stack.

A basic concept of all aspects of the invention is that a multiprocessor system can accommodate functions having different properties by providing special entry points. An entry point of a subprogram is where the subprogram accepts messages, and is any instruction that may be executed after an instruction not in the subprogram. In the invention, the entry point is used to establish certain properties of data to be exchanged between processor so that both processors know what to expect.

In accordance with this concept, with respect to an extended function's return requirements, the invention accommodates the following cases:

Case 1. No host processor data is modified and no return value is required.

Case 2. No host processor data is modified, but the host requires a return value from the subprocessor.

Case 3. Host processor data is modified by the subprocessor and must be retrieved from subprocessor memory into host memory after the command has executed.

In terms of speed of execution, Case 1 is fastest, Case 2 is slower, and Case 3 is slowest.

With respect to the extended function's argument format, the invention accommodates both immediate reference and reference by one level of indirection, more specifically, the following cases:

Case 1. Argument list with immediate arguments.

Case 2. Argument with pointer(s) to array or structure.

Case 3. Pointer to null terminated string.

Case 4. Argument list with immediate arguments and pointer(s) to array or structure.

As explained below, the argument format affects how the argument data is passed, but generally, rather than passing arguments on the stack, the invention operates by using a pointer on the stack to fetch argument data from a communications buffer.

Because functions may exhibit numerous combinations of return requirements and argument formats, the invention provides entry points that represent combinations of the two sets of cases listed above. The result is a set of entry points that represent various combinations of return requirements and argument formats. This set of entry points is used to ensure that the argument data loaded to a communications buffer by the host processor has the properties expected by the subprocessor system. Each entry point is an entry point to programming associated with the communications system that handles the transfer of data to and from the communications buffer. In the preferred embodiment, each entry point is further associated with an entry point command, which is used to invoke the communications programming.

FIG. 1 shows one aspect of the invention, a method of modifying a software program for use with a multiprocessor system. It is assumed that the user is defining, or has defined, a subprogram that is desired to be executed on a subsystem of a multiprocessor system.

In step 11, the user selects an existing subprogram or prepares a new subprogram, which is desired to be executed by a subprocessor. If not already in subprogram form, in a distinct module, the code is manipulated so that a distinct code module representing the function can be extracted.

In step 12, the user assigns an identifier to the function. In the preferred embodiment, the function identifier has two parts: a module number and a function number. The identifier permits the user to add more than one extended function, by identifying the function to both processor systems. The module number permits the user to group selected functions into modules. If more than one module is loaded to the subsystem, the module number provides a means for the subsystem to select the proper module. For example, the module number provides a means for the subprocessor system to index into an array of module pointers. Thus, the function number provides a means for selecting the proper extended function to be executed at run time.

In step 13, the user selects an entry point from a number of entry points recognized by the communications system. As discussed above, these entry points are each associated with certain communications programming that handles the transfer of data between processors. In the preferred embodiment, each entry point is associated with a command, which is common to both the entry point code in the subprogram and its call in the main program. The entry point is, in effect, a function whose arguments are the extended function's identifier and information about its arguments.

The following examples are representative implementations of entry points and their commands, in accordance with the invention, shown in C language syntax. In each of the entry points, the "cmd.sub.-- number" is the function identifier discussed above in connection with step 12. The "length" is the number of binary words or bytes that are to be sent in connection with transferring the function's argument data. Immediate value arguments are identified as arg.sub.-- 1, arg.sub.-- 2, . . . , arg.sub.-- n.

1. Standard Command

This entry point is used when the function has no return value. The argument list has single length and is comprised of immediate value arguments. The length is in words. An implementation is:

    ______________________________________
    void cmd (cmd.sub.-- number, length, arg.sub.-- 1, arg.sub.-- 2,
    . . . arg.sub.-- n);
    short          cmd.sub.-- number;
    short          length;
    short          arg.sub.-- 1, arg.sub.-- 2, . . . arg.sub.-- n;
    ______________________________________

    ______________________________________
    unsigned long ret (cmc.sub.-- number, length,
    arg.sub.-- 1, arg.sub.-- 2, . . . arg.sub.-- n);
    short          cmd.sub.-- number;
    short          length;
    short          arg.sub.-- 1, arg.sub.-- 2, . . . arg.sub.-- n;
    ______________________________________

    ______________________________________
    void psnd (cmd.sub.-- number, length, ptr)
    short               cmd.sub.-- number;
    short               length;
    char far            *ptr;
    ______________________________________

    ______________________________________
    unsigned long pget (cmd.sub.-- number, length, ptr);
    short               cmd.sub.-- number;
    short               length;
    char far            *ptr;
    ______________________________________

    ______________________________________
    void pstr (cmd.sub.-- number, ptr);
    short               cmd.sub.-- number;
    char far            *ptr;
    ______________________________________

    ______________________________________
    unsigned long palt (cmd.sub.-- number, length, ptr);
    short               cmd.sub.-- number;
    short               length;
    char far            *ptr;
    ______________________________________

    ______________________________________
    unsigned long ptrx (cmd.sub.-- number, send.sub.-- length,
    send.sub.-- ptr, return.sub.-- length, return.sub.-- ptr);
    short              cmd.sub.-- number;
    short              send.sub.-- length;
    char far           *send.sub.-- ptr;
    short              *return.sub.-- length;
    char far           *return.sub.-- ptr;
    ______________________________________

    ______________________________________
    void pcmd (cmd.sub.-- number, num.sub.-- words, word1,
    word2, . . ., wordn, num.sub.-- ptrs, cnt1, ptr1,
    ptr2, . . ., cntn, ptrn)
    short               cmd.sub.-- number;
    short               num.sub.-- words;
    short               word1;
    short               word2;
    .
    .
    short               num.sub.-- ptrs;
    short               cnt1;
    char far            *ptr1;
    short               cnt2;
    char far            *ptr2;
    .
    .
    .
    short               cntn
    char far            *ptrn;
    ______________________________________

    ______________________________________
    Standard Command
    move       A0,*-SP,1    ; save A0
    move       *-A14,A8,1   ; get data.sub.-- ptr
    setf       16,1,0       ; get field size 0 to 16
                            ; bits
    move       *A8+,A0,0    ; get arg.sub.-- 1 into A0
    move       *A8,A8,1     ; get arg.sub.-- 2 into A8
    Standard Memory Send Command
    move       *-A14,A11,1  ; get data.sub.-- ptr
    setf       16,1,0       ; set field size 0 to 16
                            ; bits
    move       *A11+,A10,0  ; first word is number
                            ; of bytes the post
                            ; increment of All
                            ; means that it is
                            ; now a pointer to
                            ; arg.sub.-- 2 [0]
    srl        2,A10        ; convert to arg.sub.-- 1
    ______________________________________

                                      TABLE 1
    __________________________________________________________________________
    MOVE Rs, Rd       Move - Register to Register
                      Operation: Rs .fwdarw. Rd
                      Move the contents of the source register into the
                      destination
                      register. It is not necessary for the registers to be
                      in the same
                      file.
    MOVE Rs, *Rd [.F] Move Field - Register to Indirect
                      Operation: field in Rs .fwdarw. field in *Rd
                      Move a field from the source register into a memory
                      location
                      specified by the contents of the destination register.
    MOVE Rs, *Rd+ [.F]
                      Move Field - Register to Indirect (Postincrement)
                      Operation: field in Rs .fwdarw. field in *Rd
                            Rd + field size .fwdarw. Rd
                      Move a field from the source register into a memory
                      location
                      specified by the contents of the destination register.
                      After the
                      move, increment the contents of Rd by the field size.
    MOVE Rs, - *Rd [.F]
                      Move field - Register to Indirect (Predecrement)
                      Operation: Rd - field size .fwdarw. Rd
                            field in Rs .fwdarw. field in *Rd
                      Decrement the contents of Rd by the field size. Move a
                      field from
                      the source register into a memory location specified by
                      the
                      contents of the destination register.
    MOVE Rs, *Rd(offset) [.F]
                      Move Field - Register to Indirect with Offset
                      Operation: field in Rs .fwdarw. field in * (Rd +
                      offset)
                      Move a field from the source register into a memory
                      location. The
                      destination address is formed by adding an offset to
                      the contents
                      of the destination register.
    MOVE Rs, @DAddress [.F]
                      Move Field - Register to Absolute
                      Operation: field in Rs .fwdarw. field in memory
                      Move a field from the source register into the
                      specified
                      destination address.
    MOVE *Rs, Rd [.F] Move Field - Indirect to Register
                      Operation: field in *Rs .fwdarw. field in Rd
                      Move a field from contents of a memory address into the
                      destination
                      register. The source address is specified by the
                      contents of the
                      source register.
    MOVE *Rs, *Rd [.F]
                      Move Field - Indirect to Indirect
                      Operation: field in *Rs .fwdarw. field in *Rd
                      Move a field from the contents of a memory address into
                      another
                      memory address. The source address is specified by the
                      contents of
                      the source register, and the destination address is
                      specified by
                      the contents of the destination register.
    MOVE *Rs+, Rd [.F]
                      Move Field - Indirect (Postincrement) to Register
                      Operation: field in *Rs .fwdarw. field in Rd
                            Rs + field size .fwdarw. Rs
                      Move a field from the contents of a memory address into
                      the
                      destination register. The source address is specified
                      by the
                      contents of the source register. After the move,
                      increment the
                      contents of the source register by the field size.
    MOVE *Rs+,*Rd+ [.F]
                      Move Field - Indirect (Postincrement) to Indirect
                      (Postdecrement)
                      Operation: field in *Rs .fwdarw. field in *Rd
                            Rs + field size .fwdarw. Rs
                            Rd + field size .fwdarw. Rd
                      Move a field from the contents of a memory address into
                      another
                      memory address. The source address is specified by the
                      contents of
                      the source register, and the destination address is
                      specified by
                      the contents of the destination register. After the
                      move,
                      increment the contents of both the source register and
                      the
                      destination register by the field size.
    MOVE -*Rs, Rd [.F]
                      Move Field - Indirect (Predecrement) to Register
                      Operation: Rs - field size .fwdarw. Rs
                            field in *Rs .fwdarw. field in Rd
                      Decrement the contents of the source register by the
                      field size.
                      Move a field from the contents of a memory address into
                      the
                      destination register. The source address is specified
                      by the
                      contents of the source register.
    MOVE -*Rs, Rd [.F]
                      Move Field - Indirect (Predecrement) to Indirect
                      (Predecrement)
                      Operation: Rs - field size .fwdarw. Rs
                            Rd - field size .fwdarw. Rd
                            field in *Rs .fwdarw. field in *Rd
                      Decrement the contents of both the source register and
                      the
                      destination register by the field size. Move a field
                      from the
                      contents of a memory address into another memory
                      address. The
                      source address is specified by the contents of the
                      source register
                      and the destination address is specified by the
                      contents of the
                      destination register.
    MOVE *Rs(offset), Rd [.F]
                      Move Field - Indirect with Offset to Register
                      Operation: field in *(Rs - offset) .fwdarw. field in
                      Rd
                      Move a field from the contents of a memory address into
                      the
                      destination register. The source address is formed by
                      adding an
                      offset to the contents of the source register.
    MOVE *Rs(offset), *Rd+ [.F]
                      Move Field - Indirect with Offset to Indirect
                      (Postincrement)
                      Operation: field in *)Rs + offset) .fwdarw. field in
                      (Rd
                      Move a field from the contents of a memory address into
                      the
                      destination register. The source address is formed by
                      adding an
                      offset to the contents of the source register. After
                      the move,
                      increment the contents of the destination register by
                      the field
                      size.
    MOVE *Rs(offset), *Rd(offset) [.F]
                      Move Field - Indirect with Offset to Indirect with
                      Offset
                      Operation: field in *(Rs + offset) .fwdarw. field in
                      *(Rd + offset)
                      Move a field from the contents of a memory address into
                      another
                      memory address. The source address is formed by adding
                      an offset
                      to the contents of the source register, and the
                      destination address
                      is formed by adding an offset to the contents of the
                      destination
                      register.
    MOVE @SAddress, Rd [.F]
                      Move Field - Absolute to Register
                      Operation: field in source address .fwdarw. field in
                      Rd
                      Move a field from the contents of the specified memory
                      address into
                      the destination register.
    MOVE @SAddress, *Rd+ [.F]
                      Move Field - Absolute to Indirect (Postincrement)
                      Operation: field in source address .fwdarw. field in
                      *Rd
                            Rd + field size .fwdarw. Rd
                      Move a field from the contents of the specified source
                      address into
                      the memory address specified by the contents of the
                      destination
                      register. After the move, increment the contents of
                      the
                      destination register by the field size.
    MOVE @SAddress, @DAddress [.F]
                      Move Field - Absolute to Absolute
                      Operation: field in source address .fwdarw. field in
                      destination address
                      Move a field from the contents of the specified source
                      address into
                      the specified destination address
    SETF FS, FE [.F]  Set Field Parameters
                      Operation: (FS, FE) .fwdarw. ST
                      Load the values specified for the field size and field
                      extension
                      bits into the status register. The remainder of the
                      status
                      register is not affected.
    SRL K, Rd         Shift Right Logical - Constant
                      Operation: right-shift Rd by K .fwdarw. Rd
                      Right-shift the contents of the destination register by
                      the value
                      of K. (K specified=s a value between 0-31.) Os are
                      shifted into the
                      MSBs of Rd. and the last bit shifted out is shifted
                      into the carry
                      bit.
    SRL Rs, Rd        Shift Right Logical - Register
                      Operation: right-shift Rd by Rs .fwdarw. Rd
                      Right-shift the contents of the destination register by
                      the 2s
                      complement value of the 5 LSBs in the source register.
                      (The 5 LSBs
                      of the source register specify a value between 0-31:



                      the 27 MSBs
                      are ignored.) Os are shifted into the MSBs of Rd. and
                      the last bit
                      shifted out is shifted into the carry
    __________________________________________________________________________
                      bit.
     Key:
     Rs--Source register
     Rd--Destination register
     RsX, Rdx--X half (16 LSBS) of Rs or Rd
     RsY, RdY--Y half (16 MSBs) of Rs or Rd
     SAddress--32bit source address
     DAddress--32bit destination address
     IW--16bit (short) immediate value
     IL--32bit (long) immediate value
     Address--32bit address (label)
     F--Field select: defaults to 0
     K--5bit constant
     PC'--Next instruction
     F=0 selects FS0 and FE0
     F=1 selects FS1 and FE1

• Inventors
  Denio, Michael A.;
• Assignee
  Texas Instruments Incorporated (Dallas, TX)
• Published
  Apr-4-1995
• Current US Classes:
  703/25
  703/27
  719/313
  719/328
• Application #
  025910
• International Classes
  G06F 009/40
• Field of Search
  364/DIG. 395/200 395/650 395/700 395/500
• Examiner
  Black; Thomas G.
• Agent
  Marshall, Jr.; Robert D., Kesterson; James C., Donaldson; Richard L.
• US Patent References:
  4530051
  4564901
  4567562
  4646231
  4649473
  4768150
  4825354
  4849877
  4851988
  4882674
  4901231
  4914570
  4920483
  5056003
  5062040
  5073852
  5124909
  5146593
  5218699
  5249293