Abstract:
The present invention provides a data processing apparatus and method for performing data processing operations on floating point data elements. The data processing apparatus has processing logic for performing data processing operations on the floating point data elements, and decode logic operable to decode a data processing instruction in order to determine a corresponding data processing operation to be performed by the processing logic. The data processing instruction has an m-bit immediate value encoded therein. Further, constant generation logic is provided to perform a logical operation on the m-bit immediate value in order to generate an n-bit floating point constant for use as at least one input floating point data element for the processing logic when performing the corresponding data processing operation. The values “n” and “m” are integers, and n is greater than m. This approach provides a particularly efficient technique for generating floating point constants.

Description:
BACKGROUND OF THE INVENTION  
       [0001]     1. Field of the Invention  
         [0002]     The present invention relates to a data processing apparatus and method for performing data processing operations on floating point data elements.  
         [0003]     2. Background of the Invention  
         [0004]     When performing data processing operations on floating point data elements, it is often the case that a floating point constant is required as one of the input floating point data elements. In the execution of any particular program, it is likely that a number of such floating point constants will be required. If a program is considered as having an instruction area containing the instructions making up the program, and a data area containing data required when executing the program, then typically any required floating point constants will be specified in the data area of the program. When the program is installed on a data processing apparatus, these various floating point constants will be stored within memory, and accordingly will occupy valuable space within the memory.  
         [0005]     Furthermore, when during the execution of a program a particular floating point constant is required, it will first be necessary to load that floating point constant from memory into a specified register. Typically, the required floating point constant will be identified by the generation of a pointer to the location in memory storing that constant. It will be appreciated that this will have an adverse effect on the performance of the program, since it will take time to establish the required pointer, and additional time to then load the floating point constant from memory into the required register, and these steps need to be taken before the operation that is to make use of that floating point constant can be performed.  
         [0006]     In addition, it can be seen that the need to provide a load instruction in order to load the floating point constant from memory to a specified register adversely impacts code density. Further, the width of the bus connecting the data processing apparatus with the memory system will determine the bandwidth available for performing load operations, and accordingly it can be seen that each time a load operation is required to move a floating point constant from memory to a register, this will use a portion of that load bandwidth, which is then not available for use in performing other load operations required by the program.  
         [0007]     Whilst the above technique has been described in connection with the loading of floating point constants from a memory into a register prior to its use within a data processing apparatus, the same process can also be used to load integer constants from memory into a register. However, for integer constants a more efficient process has been developed. In particular, it is known to encode within a particular instruction an immediate value which can be used to produce an integer constant for storing within a register. For example, a move instruction may have encoded therein an immediate value, and execution of the move instruction will cause the immediate value to be expanded as required to the size of a register, and then stored within a particular register identified by the move instruction.  
         [0008]     As a particular example, in situations where a 32-bit instruction set is used, a certain number of bits of the instruction encoding space, for example 8 bits or 12 bits of the 32-bit instruction, will be used to specify an immediate value. If the register into which the integer constant specified by that immediate value is to be placed is a 32-bit register, then the immediate value can be zero extended (in the example of an unsigned integer constant) or sign extended (in the example of a signed integer constant) to 32-bits and then stored within the specified register. It has been found that such an approach enables a useful range of integer constants to be specified by an immediate value encoded within an instruction. It will be appreciated that the range of possible immediate values defines a corresponding continuous range of integer constants, and it is often the case that that continuous range of integer constants includes most integer constants that are considered useful in integer processing operations.  
         [0009]     As a further enhancement to the above approach, ARM Limited have provided in their instruction set an instruction encoding which allows an 8-bit immediate value to be specified, and then a further 4-bits to be specified to identify a rotation to be applied to the immediate value in order to specify its location within a register (with the remaining bits of the register being filled with a predetermined sequence of ones or zeros). By allowing an immediate value to be specified, along with a rotation to be applied to that immediate value in order to determine its location within the register, further flexibility in the choice of integer constants is provided.  
         [0010]     It will be appreciated that the use of an immediate value encoded within an instruction as the means for specifying an integer constant provides significant performance improvements over the earlier described prior art, where the constant was first stored in memory, and then loaded from memory into a register as required. In particular, by encoding the immediate value within the instruction, there is no need to perform a load operation, thereby improving code density, and increasing performance. Further, space in memory does not need to be set aside for the storing of such constants.  
         [0011]     However, whilst useful integer constants can readily be specified by an immediate value encoded within an instruction, since there is a clear correspondence between the range of immediate values specifiable within the instruction encoding and the corresponding range of integer constants, this is not the case for floating point constants. In particular, floating point numbers have a more complex representation than integer numbers, a floating point number having a sign field, an exponent field, and a fraction field contained therein. In addition, the useful floating point numbers that are likely to be required as floating point constants do not follow any clear sequence, and accordingly it has up to now been considered not possible to represent a useful range of floating point constants through use of an immediate value encoded within an instruction.  
         [0012]     Accordingly, up to now, when floating point constants are required, they are first loaded from memory into a register using the earlier described prior art techniques. However, as mentioned earlier, such an approach has an adverse effect on performance and code density, and also causes valuable memory space to be used for storage of required floating point constants. Accordingly, it will be desirable to provide an improved technique for providing floating point constants for use in floating point operations.  
       SUMMARY OF THE INVENTION  
       [0013]     Viewed from a first aspect, the present invention provides a data processing apparatus, comprising: processing logic operable to perform data processing operations on floating point data elements; decode logic operable to decode a data processing instruction in order to determine a corresponding data processing operation to be performed by the processing logic, the data processing instruction having an m-bit immediate value encoded therein; and constant generation logic operable to perform a logical operation on the m-bit immediate value in order to generate an n-bit floating point constant for use as at least one input floating point data element for the processing logic when performing the corresponding data processing operation, where n and m are integers and n is greater than m.  
         [0014]     In accordance with the present invention, constant generation logic is provided within a data processing apparatus that is operable to perform a logical operation on an m-bit immediate value encoded within a data processing instruction in order to generate an n-bit floating point constant for use as at least one input floating point data element for processing logic used to perform a data processing operation. The inventors of the present invention have realised that a logical operation can be used to expand an m-bit immediate value into an n-bit floating point constant, which allows the possible range of m-bit immediate values to specify a useful set of n-bit floating point constants. This provides a particularly efficient technique for generating n-bit floating point constants, which avoids the need for storing the required floating point constants in memory and then loading those constants from memory to registers as required.  
         [0015]     It will be appreciated that the logical operation may take a variety of forms. However, in one embodiment, the logical operation causes a first predetermined portion of the m-bit immediate value to be used in generating an exponent portion of the floating point constant, and a second predetermined portion of the m bit immediate value to be used in generating a fraction portion of the floating point constant, the second predetermined portion being non-overlapping with the first predetermined portion. Hence, in accordance with this embodiment, different parts of the m-bit immediate value are used in the generation of the exponent and fraction of the floating point constant. It has been found that this approach allows for a relatively simple implementation of the logical operation, whilst still enabling a useful set of floating point constants to be generated.  
         [0016]     In one embodiment, the logical operation allocates a preselected value as a sign bit of the generated floating point constant. Hence, as an example, the logical operation may be arranged to only generate positive floating point constants, and accordingly all of the generated floating point constants will be arranged to have the same value of sign bit. However, in an alternative embodiment, the logical operation causes a third predetermined portion of the m-bit immediate value to be used in generating a sign bit of the floating point constant, the third predetermined portion being non-overlapping with the first and second predetermined portions. Whilst this reduces the number of bits available for use in determining the exponent portion and fraction portion of the floating point constant, it does provide flexibility as to the choice of sign bit, and accordingly the same logical operation can generate both positive and negative floating point constants.  
         [0017]     It will be appreciated that there are a number of different ways in which the various bits of the immediate value can be used to generate the various bits of the floating point constant. However, in one embodiment, the logical operation causes selected bits of the n-bit floating point constant to be generated from associated subsets of bits of the m-bit immediate value. In one particular embodiment, each associated subset of bits comprises one bit, such that each selected bit of the n-bit floating point constant is generated from an associated bit of the m-bit immediate value. This provides a particularly simple implementation of the logical operation, which has been found to enable a useful set of n-bit floating point constants to be generated.  
         [0018]     Whilst in certain embodiments the value of each bit of the n-bit floating point constant will be dependent on at least one of the bits of the m-bit immediate value, this is not a requirement, and in alternative embodiments at least one of the bits of the n-bit floating point constant is not dependent on the m-bit immediate value. In one particular embodiment, a number of least significant bits of the fraction portion of the floating point constant are not dependent on the m-bit immediate value, but rather are generated by the logical operation in a predetermined manner. As a particular example, a certain number of the least significant bits of the fraction portion of the floating point constant may be set to zero irrespective of the value of the m-bit immediate value.  
         [0019]     It will be appreciated that in one embodiment the constant generation logic may be arranged to generate a single n-bit floating point constant which is used only once in the corresponding data processing operation. However, in a more general embodiment, the constant generation logic is operable to perform the logical operation on the m-bit immediate value in order to generate at least one n-bit floating point constant for use as input floating point data elements for the processing logic when performing the corresponding data processing operation. Hence, as an example, one floating point constant may be generated that is used multiple times by the data processing operation, for example in each iteration of a multiple iteration data processing operation. Alternatively, multiple floating point constants may be generated which are used as input floating point data elements, for example a different floating point constant being used in each iteration of a multiple iteration data processing operation. Alternatively, multiple of the generated n-bit floating point constants may be used in the same iteration.  
         [0020]     In one embodiment of the present invention, the processing logic has a number of lanes of parallel processing, and is operable in response to the data processing instruction to perform in parallel the corresponding data processing operation within each said lane of parallel processing. Such processing is often referred to as Single Instruction Multiple Data (SIMD) processing, and in accordance with the SIMD approach, multiple data elements are placed in different lanes, and then an operation is performed in parallel on those data elements. In one embodiment, within each said lane of parallel processing one of said at least one floating point constants is used as an input floating point data element. Hence, it may be the case that the same generated floating point constant is used as an input floating point data element in each lane, or alternatively it may be the case that different floating point constants are used as input floating point data elements in each lane. Further, it is possible that one generated floating point constant is used as an input floating point data element in certain lanes, whilst a different floating point constant is used in other lanes, such functionality being useful for example in performing mask type functions, logical OR operations on particular lanes, etc.  
         [0021]     The data processing instruction can take a variety of forms. In one embodiment, the data processing instruction is an OR instruction, the processing logic being operable in response to the OR instruction to perform a logical OR operation on first and second source operands, the first source operand being identified by the OR instruction and comprising a plurality of first input data elements, and the second operand being generated by the constant generation logic and comprising a corresponding plurality of n-bit floating point constants forming second input floating point data elements, such that each said lane of parallel processing contains one of said first input data elements and a corresponding second input floating point data element. In such embodiments, it will be appreciated that the first input data elements may also be floating point data elements, but there is no requirement for them to be so. Indeed, in other embodiments, the first input data elements may be integers.  
         [0022]     In one embodiment, the data processing apparatus further comprises a register data store having a plurality of registers operable to store floating point data elements for access by the processing logic. This provides for efficient access to the floating point data elements by the processing logic as and when required, avoiding the need to access those data elements from memory each time they are needed.  
         [0023]     In one embodiment, the data processing instruction is a move instruction specifying the m-bit immediate value and a register identifier, the constant generation logic being operable to generate the n-bit floating point constant from the m-bit immediate value specified by the move instruction, and the processing logic being operable to cause that n-bit floating point constant to be stored in a register of the register data store as determined from the register identifier. Hence in this particular instance, the corresponding data processing operation performed by the processing logic involves merely the handling of the movement of the floating point constant(s) generated by the constant generation logic into one or more specified registers of the register data store. These generated floating point constants may be routed through the processing logic to the register data store, or alternatively may be routed directly from the constant generation logic to the register store under the control of the processing logic.  
         [0024]     It will be appreciated that the register identifier may identify a single register, or may alternatively identify more than one register.  
         [0025]     In embodiments where multiple lanes of parallel processing are provided, the constant generation logic can be arranged to be operable to generate from the m-bit immediate value a different n-bit floating point constant for each said lane of parallel processing, and the processing logic is then operable to cause those n-bit floating point constants to be stored in respective lanes of one or more registers of the register data store as determined from the register identifier.  
         [0026]     In an alternative embodiment, the data processing instruction is an arithmetic instruction, the processing logic being operable in response to the arithmetic instruction to perform an arithmetic operation on a plurality of input floating point data elements, at least one of the input floating point data elements comprising the n-bit floating point constant as generated by the constant generation logic. As with the other described embodiments of the data processing instruction, this arithmetic instruction may optionally be arranged to cause the corresponding arithmetic operation to be performed in parallel within each of a plurality of lanes of parallel processing.  
         [0027]     It will be appreciated that the logical operation performed by the constant generation logic may be fixed. However, in alternative embodiments, the logical operation may be selected from one of a plurality of predetermined logical operations. The actual logical operation performed by the constant generation logic may then be selected dependent on the instruction decoded by the decode logic.  
         [0028]     Viewed from a second aspect, the present invention provides a method of operating a data processing apparatus to perform data processing operations on floating point data elements, the method comprising the steps of: (a) decoding a data processing instruction in order to determine a corresponding data processing operation to be performed, the data processing instruction having an m-bit immediate value encoded therein; (b) performing a logical operation on the m-bit immediate value in order to generate an n-bit floating point constant, where n and m are integers and n is greater than m; and (c) using the n-bit floating point constant as at least one input floating point data element when performing the corresponding data processing operation.  
         [0029]     Viewed from a third aspect, the present invention provides a computer program product comprising a computer program including at least one data processing instruction which when executed causes a data processing apparatus to operate in accordance with the method of the second aspect of the present invention. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0030]      FIG. 1  is a block diagram schematically illustrating a data processing system in accordance with one embodiment of the present invention;  
         [0031]      FIG. 2  illustrates the input and output from the constant generation logic of  FIG. 1  in accordance with one embodiment;  
         [0032]      FIGS. 3 and 4  schematically illustrate two different forms of logical operation that may be performed by the constant generation logic of  FIG. 1 ;  
         [0033]      FIG. 5  schematically illustrates the processing of a move instruction used to generate floating point constants in accordance with one embodiment of the present invention; and  
         [0034]      FIG. 6  schematically illustrates a data processing instruction which includes the generation of at least one floating point constant in accordance with one embodiment of the present invention.  
     
    
     DESCRIPTION OF EMBODIMENTS  
       [0035]      FIG. 1  schematically illustrates a data processing system (integrated circuit)  10  incorporating both integer processing logic and floating point processing logic. The integer processing portion can be considered to be a standard ARM processor core incorporating an integer register data store  50 , a multiplier  55 , a shifter  60 , an adder  65 , as well as many other circuit elements which have not, for the sake of clarity, been illustrated. In operation, such an integer processor core stores fixed length 32-bit data values within the register data store  50  and manipulates these data values using the multiplier  55 , shifter  60  and adder  65  under control of data processing instructions, passed via the instruction register  15  to the decode and control logic  20 . The decode and control logic  20  produces control signals over path  26  which control the operation of the integer processing elements in a conventional way.  
         [0036]     As also illustrated in  FIG. 1 , the integrated circuit  10  includes various floating point processing logic, including a register data store  40  and dedicated processing logic  35 . If a data processing instruction received by the decode and control logic  20  specifies an operation to be performed with respect to floating point data elements, then the decode and control logic  20  is arranged to issue the necessary control signals over path  22  to the floating point processing logic in order to cause the processing logic  35  to execute the required operation.  
         [0037]     The data processing system  10  is coupled with memory via the load store unit (LSU)  45 . The LSU&#39;s operation is controlled by the decode and control logic  20  via control signals issued over path  24  dependent on instructions decoded by the decode and control logic  20 . By this approach, data elements can be loaded from memory into either the data store  40  or the register data store  50  as required, and further any data elements held within either of the register data stores  40 ,  50  can be stored to memory when they are no longer required by the data processing system  10 .  
         [0038]     In accordance with embodiments of the present invention, certain floating point data processing instructions are able to specify an m-bit immediate value which can be used to generate one or more floating point constants. In particular, the constant generation logic  30 , which can be considered to be adjacent to, or forming part of, the decode and control logic  20 , is arranged to receive an immediate value decoded by the decode and control logic  20  from such a floating point data processing instruction, and to apply a logical operation to that m-bit immediate value in order to generate one or more floating point constants. The one or more floating point constants produced can then either be sent directly to the register data store  40  (as indicated by the dotted line  32 ), or if the floating point data processing instruction requires additional operations to be performed, the generated floating point constant(s) may be routed via path  34  and multiplexer  37  to one of the inputs of the processing logic  35 . As can be seen from  FIG. 1 , the processing logic  35  can either receive two data elements retrieved from the data store  40 , or alternatively may receive one data element from the data store  40 , whilst receiving a floating point constant from the constant generation logic  30  (via the multiplexer  37 ) as a second input data element.  
         [0039]     Whilst the data store  40  will typically store floating point data elements, it will be appreciated that there is no requirement that only floating point data elements are stored within the data store  40 , and indeed in some embodiments certain integer data elements will also be stored within the data store  40 , since certain of the operations performed by the processing logic  35  may require both an integer input data element and a floating point input data element.  
         [0040]     As shown in  FIG. 2 , in one embodiment the constant generation logic  30  is arranged to receive from the decode and control logic  20  an 8-bit immediate value decoded from a floating point data processing instruction. Based thereon, the constant generation logic  30  is arranged to perform a logical operation on that 8-bit immediate value in order to generate a 32-bit floating point constant. Two particular example of such a logical operation that may be performed by the constant generation logic  30  are illustrated schematically in  FIGS. 3 and 4 . As is apparent from  FIG. 3 , if the 8 bits of the immediate value are “ABCDEFGH” (with A being the most significant bit and H being the least significant bit), then it can be seen that the logical operation results in the generation of a floating point constant of the following form:  
                                           Biased   Mantissa       Sign   exponent   fraction                   0   ˜AAAAABCD   EFGH0000000000000000000                  
 
         [0041]     In accordance with this logical operation, the value of the sign bit is preset to be zero, and accordingly only positive floating point constants are produced. In particular, the following table illustrates the values of floating point constants that can be produced dependent on the values of ABCDEFGH:  
                                                                                                                                                                   TABLE 1                                       ABCD            EFGH   0000   0001   0010   0011   0100   0101   0110   0111   1000   1001   1010   1011   1100   1101   1110   1111                    0000   2.0   4.0   8.0   16.0   32.0   64.0   128.0   256.0   *   *   0.03125   0.0625   0.125   0.25   0.5   1.0       0001   2.125   4.25   8.5   17.0   34.0   68.0   136.0   272.0   *   *   *   *   *   *   0.53125   1.0625       0010   2.25   4.5   9.0   18.0   36.0   72.0   144.0   288.0   *   *   *   *   *   0.28125   0.5625   1.125       0011   2.375   4.75   9.5   19.0   38.0   76.0   152.0   304.0   *   *   *   *   *   *   0.59375   1.1875       0100   2.5   5.0   10.0   20.0   40.0   80.0   160.0   320.0   *   *   *   *   0.15625   0.3125   0.625   1.25       0101   2.625   5.25   10.5   21.0   42.0   84.0   168.0   336.0   *   *   *   *   *   *   0.65625   1.3125       0110   2.75   5.5   11.0   22.0   44.0   88.0   176.0   352.0   *   *   *   *   *   0.34375   0.6875   1.375       0111   2.875   5.75   11.5   23.0   46.0   92.0   184.0   368.0   *   *   *   *   *   *   0.71875   1.4375       1000   3.0   6.0   12.0   24.0   48.0   96.0   192.0   384.0   *   *   *   0.09375   0.1875   0.375   0.75   1.5       1001   3.125   6.25   12.5   25.0   50.0   100.0   200.0   400.0   *   *   *   *   *   *   0.78125   1.5625       1010   3.25   6.5   13.0   26.0   52.0   104.0   208.0   416.0   *   *   *   *   *   0.40625   0.8125   1.625       1011   3.375   6.75   13.5   27.0   54.0   108.0   216.0   432.0   *   *   *   *   *   *   0.84375   1.6875       1100   3.5   7.0   14.0   28.0   56.0   112.0   224.0   448.0   *   *   *   *   0.21875   0.4375   0.875   1.75       1101   3.625   7.25   14.5   29.0   58.0   116.0   232.0   464.0   *   *   *   *   *   *   0.90625   1.8125       1110   3.75   7.5   15.0   30.0   60.0   120.0   240.0   480.0   *   *   *   *   *   0.46875   0.9375   1.875       1111   3.875   7.75   15.5   31.0   62.0   124.0   248.0   496.0   *   *   *   *   *   *   0.96875   1.9375                  
 
         [0042]     In the above table, the asterisks are used for constants that need more than five decimal places to represent them precisely.  
         [0043]     It has been found that the set of floating point constants illustrated in the above table includes a significant number of useful floating point constants for many floating point data processing operations. Accordingly, through implementation of the simple logical operation illustrated with reference to  FIG. 3 , many different useful floating point constants can be generated from the 8 bit immediate value. As an example, if the 8 bit immediate value is “00000000”, this will cause a floating point constant of 2.0 to be produced. Alternatively, if the immediate value is of the form 00100100, this will cause a floating point constant of 10.0 to be produced.  
         [0044]      FIG. 4  illustrates an alternative logical operation that may be performed by the constant generation logic  30 , which will result in a floating point constant of the following form being generated:  
                                           Biased   Mantissa       Sign   exponent   fraction                   A   ˜BBBBBBCD   EFGH0000000000000000000                    
         [0045]     This alternative form of logical operation enables floating point constants from the left half of the upper portion of Table 1, plus the right half of the lower portion of Table 1, to be produced, along with the negated versions of all of those floating point constants. Again, it has been found that this enables a useful set of floating point constants to be generated from the 8-bit immediate value using a simple logical operation performed by the constant generation logic  30 .  
         [0046]     The principles of the embodiment of the present invention described above can be extended for use in SIMD implementations, where the floating point data processing instruction specifies a data processing operation to be performed in parallel in multiple lanes of parallel processing within the processing logic  35 .  FIG. 5  illustrates an example situation where a SIMD move instruction is to be executed. This instruction will specify an m-bit immediate value, which the constant generation logic  30  would then use to generate an n-bit floating point constant. The move instruction may then specify that this floating point constant should be replicated across four lanes of parallel processing, to then cause the resultant data to be stored in a single register Qd.  
         [0047]     In a particular implementation, 32-bit floating point constants are produced, and the register Qd is 128 bits in length. The function f(x)  100  illustrated in  FIG. 5  identifies the operation to be performed by the constant generation logic and the subsequent data processing operation to be performed under the control of the processing logic  35 . In this instance, the constant generation logic  30  produces a single floating point constant which is then replicated across four lanes so as to cause the floating point constant to be stored repetitively at locations  105 ,  110 ,  115  and  120  within the register Qd. As discussed earlier, the data stored into the register Qd can be stored directly over path  32  into the data store  40  under the control of the processing logic  35 , or alternatively may be routed through the processing logic  35  via path  34 , before then being output to the data store  40 . In the particular example illustrated in  FIG. 5 , it is assumed that the floating point constant produced represents the value 0.125, but clearly any of the other values specified in Table 1 could be produced dependent on the value of the immediate value m and dependent on whether the logical operation performed by the constant generation logic  30  is that illustrated in  FIG. 3  or that illustrated in  FIG. 4 .  
         [0048]      FIG. 6  illustrates the operation of an alternative floating point data processing instruction, which specifies an operation  175 ,  180 ,  185 ,  190  to be performed in parallel across four different lanes of parallel processing. In preferred embodiments, the operations  175 ,  180 ,  185  and  190  are identical, each operation taking as one of its input data elements a data element from a corresponding lane within a source register Qn. The other input data element to each lane is determined by the floating point constant generated by the constant generation logic  30 . In this particular example, the constant generation logic  30  again produces a floating point constant representing the value 0.125, but in this example, that floating point constant is only input into the second lane of parallel processing, with the other three lanes receiving a floating point constant representing the value zero.  
         [0049]     It will be appreciated that there are a number of ways in which the multiple floating point constants may be generated. In one embodiment, the instruction may specify that the floating point constant to be generated from the immediate value is to be provided to only a subset of the lanes, for example one specified lane. The instruction may also provide information indicative of a floating point constant to be used for the other lanes, which can be forwarded as a control value by the decode logic to the constant generation logic. The constant generation logic may then be arranged to generate one of a number of floating point constants dependent on the value of that control signal.  
         [0050]     As an example, an ADD instruction may specify one lane that is to receive the floating point constant derived from the immediate, whilst also indicating that the other lanes should receive a value of 0.0. An appropriate control signal can then be issued to the constant generation logic to cause a floating point constant of 0.0 to be provided as an input to the remaining lanes. As another example, a multiply instruction may specify one lane that is to receive the floating point constant derived from the immediate, whilst also indicating that the other lanes should receive a value of 1.0. An appropriate control signal can then be issued to the constant generation logic to cause a floating point constant of 1.0 to be provided as an input to the remaining lanes.  
         [0051]     As an alternative to the control value, different floating point constants may be generated by the constant generation logic by using different bits of the immediate value, or alternatively more than one immediate value may be specified by the instruction.  
         [0052]     It can be seen that through the above described approach a mask function can be provided, such that the generated floating point constant is only utilised in one of the lanes. It will be appreciated that the operation  175 ,  180 ,  185 ,  190  may take a variety of forms, for example a logical OR or AND operation, an arithmetic operation such as an addition, subtraction, multiplication, division, etc.  
         [0053]     The logical operation f(x)  130  illustrated in  FIG. 6  represents the entirety of the operation to be performed following decode of the floating point data processing operation by the decode and control logic  20 . It hence incorporates the performance of the logical operation by the constant generation logic  30  in order to generate the required floating point constants, and the subsequent data processing operations required to be performed by the processing logic  35 .  
         [0054]     Although a particular embodiment has been described herein, it will be appreciated that the invention is not limited thereto and that many modifications and additions thereto may be made within the scope of the invention. For example, various combinations of the features of the following dependent claims could be made with the features of the independent claims without departing from the scope of the present invention.