![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rtl.def CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to rtl.def CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: /* This file contains the definitions and documentation for the ! 2: Register Transfer Expressions (rtx's) that make up the ! 3: Register Transfer Language (rtl) used in the Back End of the GNU compiler. ! 4: Copyright (C) 1987, 1988 Free Software Foundation, Inc. ! 5: ! 6: This file is part of GNU CC. ! 7: ! 8: GNU CC is distributed in the hope that it will be useful, ! 9: but WITHOUT ANY WARRANTY. No author or distributor ! 10: accepts responsibility to anyone for the consequences of using it ! 11: or for whether it serves any particular purpose or works at all, ! 12: unless he says so in writing. Refer to the GNU CC General Public ! 13: License for full details. ! 14: ! 15: Everyone is granted permission to copy, modify and redistribute ! 16: GNU CC, but only under the conditions described in the ! 17: GNU CC General Public License. A copy of this license is ! 18: supposed to have been given to you along with GNU CC so you ! 19: can know your rights and responsibilities. It should be in a ! 20: file named COPYING. Among other things, the copyright notice ! 21: and this notice must be preserved on all copies. */ ! 22: ! 23: ! 24: /* Expression definitions and descriptions for all targets are in this file. ! 25: Some will not be used for some targets. ! 26: ! 27: The fields in the cpp macro call "DEF_RTL_EXPR()" ! 28: are used to create declarations in the C source of the compiler. ! 29: ! 30: The fields are: ! 31: ! 32: 1. The internal name of the rtx used in the C source. ! 33: It is a tag in the enumeration "enum rtx_code" defined in "rtl.h". ! 34: By convention these are in UPPER_CASE. ! 35: ! 36: 2. The name of the rtx in the external ASCII format read by ! 37: rtl.read_rtl(), and printed by rtl.print_rtl(). ! 38: These names are stored in rtl.rtx_name[]. ! 39: By convention these are the internal (field 1) names in lower_case. ! 40: ! 41: 3. The print format, and type of each rtx->fld[] (field) in this rtx. ! 42: These formats are stored in rtl.rtx_format[]. ! 43: The meaning of the formats is documented in front of this array in rtl.c ! 44: ! 45: */ ! 46: ! 47: /* --------------------------------------------------------------------- ! 48: Expressions (and "meta" expressions) used for structuring the ! 49: rtl representation of a program. ! 50: --------------------------------------------------------------------- */ ! 51: ! 52: /* an expression code name unknown to the reader */ ! 53: DEF_RTL_EXPR(UNKNOWN, "UnKnown", "*") ! 54: ! 55: /* (NIL) is used by rtl reader and printer to represent a null pointer. */ ! 56: ! 57: DEF_RTL_EXPR(NIL, "nil", "*") ! 58: ! 59: /* --------------------------------------------------------------------- ! 60: Expressions used in constructing lists. ! 61: --------------------------------------------------------------------- */ ! 62: ! 63: /* a linked list of expressions */ ! 64: DEF_RTL_EXPR(EXPR_LIST, "expr_list", "ee") ! 65: ! 66: /* a linked list of instructions. ! 67: The insns are represented in print by their uids. */ ! 68: DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue") ! 69: ! 70: /* ---------------------------------------------------------------------- ! 71: Expression types for machine descripions. ! 72: These do not appear in actual rtl code in the compiler. ! 73: ---------------------------------------------------------------------- */ ! 74: ! 75: /* Appears only in machine descriptions. ! 76: Means use the function named by the second arg (the string) ! 77: as a predicate; if matched, store the structure that was matched ! 78: in the operand table at index specified by the first arg (the integer). ! 79: If the second arg is the null string, the structure is just stored. ! 80: ! 81: A third string argument indicates to the register allocator restrictions ! 82: on where the operand can be allocated. ! 83: ! 84: If the target needs no restriction on any instruction this field should ! 85: be the null string. ! 86: ! 87: The string is prepended by: ! 88: '=' to indicate the operand is only written to. ! 89: '+' to indicate the operand is both read and written to. ! 90: ! 91: Each character in the string represents an allocatable class for an operand. ! 92: 'g' indicates the operand can be any valid class. ! 93: 'i' indicates the operand can be immeadiate (in the instruction) data. ! 94: 'r' indicates the operand can be in a register. ! 95: 'm' indicates the operand can be in memory. ! 96: 'o' a subset of the 'm' class. Those memory addressing modes that ! 97: can be offset at compile time (have a constant added to them). ! 98: ! 99: Other characters indicate target dependent operand classes and ! 100: are described in each target's machine description. ! 101: ! 102: For instructions with more than one operand, sets of classes can be ! 103: separated by a comma to indicate the appropriate multi-operand constraints. ! 104: There must be a 1 to 1 correspondence between these sets of classes in ! 105: all operands for an instruction. ! 106: */ ! 107: DEF_RTL_EXPR(MATCH_OPERAND, "match_operand", "iss") ! 108: ! 109: /* Appears only in machine descriptions. ! 110: Means match only something equal to what is stored in the operand table ! 111: at the index specified by the argument. */ ! 112: DEF_RTL_EXPR(MATCH_DUP, "match_dup", "i") ! 113: ! 114: /* Appears only in machine descriptions. ! 115: Defines the pattern for one kind of instruction. ! 116: Operand: ! 117: 0: names this instruction. ! 118: If the name is the null string, the instruction is in the ! 119: machine description just to be recognized, and will never be emitted by ! 120: the tree to rtl expander. ! 121: 1: is the pattern. ! 122: 2: is a string which is a C expression ! 123: giving an additional condition for recognizing this pattern. ! 124: A null string means no extra condition. ! 125: 3: is the action to execute if this pattern is matched. ! 126: If this assembler code template starts with a * then it is a fragment of ! 127: C code to run to decide on a template to use. Otherwise, it is the ! 128: template to use. ! 129: */ ! 130: DEF_RTL_EXPR(DEFINE_INSN, "define_insn", "sEss") ! 131: ! 132: /* Definition of a peephole optimization. ! 133: 1st operand: vector of insn patterns to match ! 134: 2nd operand: C expression that must be true ! 135: 3rd operand: template or C code to produce assembler output. */ ! 136: DEF_RTL_EXPR(DEFINE_PEEPHOLE, "define_peephole", "Ess") ! 137: ! 138: /* Definition of a combiner pattern. ! 139: Operands not defined yet. */ ! 140: DEF_RTL_EXPR(DEFINE_COMBINE, "define_combine", "Ess") ! 141: ! 142: /* Define how to generate multiple insns for a standard insn name. ! 143: 1st operand: the insn name. ! 144: 2nd operand: vector of insn-patterns. ! 145: Use match_operand to substitute an element of `recog_operand'. ! 146: 3rd operand: C expression that must be true for this to be available. ! 147: This may not test any operands. ! 148: 4th operand: Extra C code to execute before generating the insns. ! 149: This might, for example, create some RTX's and store them in ! 150: elements of `recog_operand' for use by the vector of insn-patterns. ! 151: (`operands' is an alias here for `recog_operand'). */ ! 152: DEF_RTL_EXPR(DEFINE_EXPAND, "define_expand", "sEss") ! 153: ! 154: /* SEQUENCE appears in the result of a `gen_...' function ! 155: for a DEFINE_EXPAND that wants to make several insns. ! 156: Its elements are the bodies of the insns that should be made. ! 157: `emit_insn' takes the SEQUENCE apart and makes separate insns. */ ! 158: DEF_RTL_EXPR(SEQUENCE, "sequence", "E") ! 159: ! 160: /* Refers to the address of its argument. ! 161: This appears only in machine descriptions, indicating that ! 162: any expression that would be acceptable as the operand of MEM ! 163: should be matched. */ ! 164: DEF_RTL_EXPR(ADDRESS, "address", "e") ! 165: ! 166: /* ---------------------------------------------------------------------- ! 167: Expressions types used for things in the instruction chain. ! 168: ! 169: All formats must start with "iuu" to handle the chain. ! 170: Each insn expression holds an rtl instruction and its semantics ! 171: during back-end processing. ! 172: See macros's in "rtl.h" for the meaning of each rtx->fld[]. ! 173: ! 174: ---------------------------------------------------------------------- */ ! 175: ! 176: /* An instruction that cannot jump. */ ! 177: DEF_RTL_EXPR(INSN, "insn", "iuueiee") ! 178: ! 179: /* An instruction that can possibly jump. ! 180: Fields ( rtx->fld[] ) have exact same meaning as INSN's ! 181: except field 3 is also used in jump.c to point to the label jumped to. ! 182: Field 7 is used in jump.c as the JUMP_LABEL. */ ! 183: DEF_RTL_EXPR(JUMP_INSN, "jump_insn", "iuueiee0") ! 184: ! 185: /* An instruction that can possibly call a subroutine ! 186: but which will not change which instruction comes next ! 187: in the current function. ! 188: Fields ( rtx->fld[] ) have exact same meaning as INSN's. */ ! 189: DEF_RTL_EXPR(CALL_INSN, "call_insn", "iuueiee") ! 190: ! 191: /* A marker that indicates that control will not flow through. */ ! 192: DEF_RTL_EXPR(BARRIER, "barrier", "iuu") ! 193: ! 194: /* Holds a label that is followed by instructions. ! 195: Operand: ! 196: 3: is a number that is unique in the entire compilation. ! 197: 4: is used in jump.c for the use-count of the label. ! 198: and in flow.c to point to the chain of label_ref's to this label. */ ! 199: DEF_RTL_EXPR(CODE_LABEL, "code_label", "iuui0") ! 200: ! 201: /* Say where in the code a source line starts, for symbol table's sake. ! 202: Contains a filename and a line number. Line numbers <= 0 are special: ! 203: 0 is used in a dummy placed at the front of every function ! 204: just so there will never be a need to delete the first insn; ! 205: -1 indicates a dummy; insns to be deleted by flow analysis and combining ! 206: are really changed to NOTEs with a number of -1. ! 207: -2 means beginning of a name binding contour; output N_LBRAC. ! 208: -3 means end of a contour; output N_RBRAC. */ ! 209: DEF_RTL_EXPR(NOTE, "note", "iuusi") ! 210: ! 211: /* INLINE_HEADER is use by inline function machinery. The information ! 212: it contains helps to build the mapping function between the rtx's of ! 213: the function to be inlined and the current function being expanded. */ ! 214: ! 215: DEF_RTL_EXPR(INLINE_HEADER, "inline_header", "iuuiiiiiiii") ! 216: ! 217: /* ---------------------------------------------------------------------- ! 218: Top level constituents of INSN, JUMP_INSN and CALL_INSN. ! 219: ---------------------------------------------------------------------- */ ! 220: ! 221: /* Several operations to be done in parallel. */ ! 222: DEF_RTL_EXPR(PARALLEL, "parallel", "E") ! 223: ! 224: /* A string that is passed through to the assembler as input. ! 225: One can obviously pass comments through by using the ! 226: assembler comment syntax. ! 227: These occur in an insn all by themselves as the PATTERN. ! 228: They also appear inside an ASM_OPERANDS ! 229: as a convenient way to hold a string. */ ! 230: DEF_RTL_EXPR(ASM_INPUT, "asm_input", "s") ! 231: ! 232: /* An assembler instruction with operands. ! 233: 1st operand is the instruction template. ! 234: 2nd operand is the constraint for the output. ! 235: 3rd operand is the number of the output this expression refers to. ! 236: When an insn stores more than one value, a separate ASM_OPERANDS ! 237: is made for each output; this integer distinguishes them. ! 238: 5th is a vector of values of input operands. ! 239: 4th is a vector of modes and constraints for the input operands. ! 240: Each element is an ASM_INPUT containing a constraint string ! 241: and whose mode indicates the mode of the input operand. */ ! 242: DEF_RTL_EXPR(ASM_OPERANDS, "asm_operands", "ssiEE") ! 243: ! 244: /* Vector of addresses, stored as full words. */ ! 245: /* Each element is a LABEL_REF to a CODE_LABEL whose address we want. */ ! 246: DEF_RTL_EXPR(ADDR_VEC, "addr_vec", "E") ! 247: ! 248: /* Vector of address differences X0 - BASE, X1 - BASE, ... ! 249: First operand is BASE; the vector contains the X's. ! 250: The machine mode of this rtx says how much space to leave ! 251: for each difference. */ ! 252: /* Appears inside a DEFINE_DATA. */ ! 253: DEF_RTL_EXPR(ADDR_DIFF_VEC, "addr_diff_vec", "eE") ! 254: ! 255: /* ---------------------------------------------------------------------- ! 256: At the top level of an instruction (perhaps under PARALLEL). ! 257: ---------------------------------------------------------------------- */ ! 258: ! 259: /* Assignment. ! 260: Operand 1 is the location (REG, MEM, PC, CC0 or whatever) assigned to. ! 261: Operand 2 is the value stored there. ! 262: ALL assignment must use SET. ! 263: Instructions that do multiple assignments must use multiple SET, ! 264: under PARALLEL. */ ! 265: DEF_RTL_EXPR(SET, "set", "ee") ! 266: ! 267: /* Indicate something is used in a way that we don't want to explain. ! 268: For example, subroutine calls will use the register ! 269: in which the static chain is passed. */ ! 270: DEF_RTL_EXPR(USE, "use", "e") ! 271: ! 272: /* Indicate something is clobbered in a way that we don't want to explain. ! 273: For example, subroutine calls will clobber some physical registers ! 274: (the ones that are by convention not saved). */ ! 275: DEF_RTL_EXPR(CLOBBER, "clobber", "e") ! 276: ! 277: /* Call a subroutine. ! 278: Operand 1 is the address to call. ! 279: Operand 2 is the number of arguments. */ ! 280: ! 281: DEF_RTL_EXPR(CALL, "call", "ee") ! 282: ! 283: /* Return from a subroutine. */ ! 284: ! 285: DEF_RTL_EXPR(RETURN, "return", "") ! 286: ! 287: /* ---------------------------------------------------------------------- ! 288: Primitive values for use in expressions. ! 289: ---------------------------------------------------------------------- */ ! 290: ! 291: /* numeric integer constant */ ! 292: DEF_RTL_EXPR(CONST_INT, "const_int", "i") ! 293: ! 294: /* numeric double constant. ! 295: The double is stored in two "integer" operands. ! 296: The third operand is the MEM that stores this constant in memory. ! 297: The fourth is used to chain together these rtx's for uniquization. */ ! 298: DEF_RTL_EXPR(CONST_DOUBLE, "const_double", "iie00") ! 299: ! 300: /* This is used to encapsulate an expression whose value is constant ! 301: (such as the sum of a SYMBOL_REF and a CONST_INT) so that it will be ! 302: recognized as a constant operand rather than by arithmetic instructions. */ ! 303: ! 304: DEF_RTL_EXPR(CONST, "const", "e") ! 305: ! 306: /* program counter. Ordinary jumps are represented ! 307: by a SET whose first operand is (PC). */ ! 308: DEF_RTL_EXPR(PC, "pc", "") ! 309: ! 310: /* A register. The "operand" is the register number, accessed ! 311: with the REGNO macro. If this number is less than FIRST_PSEUDO_REGISTER ! 312: than a hardware register is being referred to. */ ! 313: DEF_RTL_EXPR(REG, "reg", "i") ! 314: ! 315: /* One word of a multi-word value. ! 316: The first operand is the complete value; the second says which word. ! 317: The WORDS_BIG_ENDIAN flag controls whether word number 0 ! 318: (as numbered in a SUBREG) is the most or least significant word. ! 319: ! 320: This is also used to refer to a value in a different machine mode. ! 321: For example, it can be used to refer to a SImode value as if it were ! 322: Qimode, or vice versa. Then the word number is always 0. */ ! 323: DEF_RTL_EXPR(SUBREG, "subreg", "ei") ! 324: ! 325: /* This one-argument rtx is used for move instructions ! 326: that are guaranteed to alter only the low part of a destination. ! 327: Thus, (SET (SUBREG:HI (REG...)) (MEM:HI ...)) ! 328: has an unspecified effect on the high part of REG, ! 329: but (SET (STRICT_LOW_PART (SUBREG:HI (REG...))) (MEM:HI ...)) ! 330: is guaranteed to alter only the bits of REG that are in HImode. ! 331: ! 332: The actual instruction used is probably the same in both cases, ! 333: but the register constraints may be tighter when STRICT_LOW_PART ! 334: is in use. */ ! 335: ! 336: DEF_RTL_EXPR(STRICT_LOW_PART, "strict_low_part", "e") ! 337: ! 338: /* A memory location; operand is the address. ! 339: Can be nested inside a VOLATILE. */ ! 340: DEF_RTL_EXPR(MEM, "mem", "e") ! 341: ! 342: /* Reference to an assembler label in the code for this function. ! 343: The operand is a CODE_LABEL found in the insn chain. ! 344: The unprinted fields 1 and 2 are used in flow.c for the ! 345: LABEL_NEXTREF and CONTAINING_INSN. */ ! 346: DEF_RTL_EXPR(LABEL_REF, "label_ref", "u00") ! 347: ! 348: /* Reference to a named label: the string that is the first operand, ! 349: with `_' added implicitly in front. ! 350: Exception: if the first character explicitly given is `*', ! 351: to give it to the assembler, remove the `*' and do not add `_'. */ ! 352: DEF_RTL_EXPR(SYMBOL_REF, "symbol_ref", "s") ! 353: ! 354: /* The condition code register is represented, in our imagination, ! 355: as a register holding a value that can be compared to zero. ! 356: In fact, the machine has already compared them and recorded the ! 357: results; but instructions that look at the condition code ! 358: pretend to be looking at the entire value and comparing it. */ ! 359: DEF_RTL_EXPR(CC0, "cc0", "") ! 360: ! 361: /* ===================================================================== ! 362: A QUEUED expression really points to a member of the queue of instructions ! 363: to be output later for postincrement/postdecrement. ! 364: QUEUED expressions never become part of instructions. ! 365: When a QUEUED expression would be put into an instruction, ! 366: instead either the incremented variable or a copy of its previous ! 367: value is used. ! 368: ! 369: Operands are: ! 370: 0. the variable to be incremented (a REG rtx). ! 371: 1. the incrementing instruction, or 0 if it hasn't been output yet. ! 372: 2. A REG rtx for a copy of the old value of the variable, or 0 if none yet. ! 373: 3. the body to use for the incrementing instruction ! 374: 4. the next QUEUED expression in the queue. ! 375: ====================================================================== */ ! 376: ! 377: DEF_RTL_EXPR(QUEUED, "queued", "eeeee") ! 378: ! 379: /* ---------------------------------------------------------------------- ! 380: Expressions for operators in an rtl pattern ! 381: ---------------------------------------------------------------------- */ ! 382: ! 383: /* if_then_else. This is used in representing ordinary ! 384: conditional jump instructions. ! 385: Operand: ! 386: 0: condition ! 387: 1: then expr ! 388: 2: else expr */ ! 389: DEF_RTL_EXPR(IF_THEN_ELSE, "if_then_else", "eee") ! 390: ! 391: /* plus */ ! 392: DEF_RTL_EXPR(PLUS, "plus", "ee") ! 393: ! 394: /* Operand 0 minus operand 1. */ ! 395: DEF_RTL_EXPR(MINUS, "minus", "ee") ! 396: ! 397: /* Minus operand 0. */ ! 398: DEF_RTL_EXPR(NEG, "neg", "e") ! 399: ! 400: DEF_RTL_EXPR(MULT, "mult", "ee") ! 401: ! 402: /* Operand 0 divided by operand 1. */ ! 403: DEF_RTL_EXPR(DIV, "div", "ee") ! 404: /* Remainder of operand 0 divided by operand 1. */ ! 405: DEF_RTL_EXPR(MOD, "mod", "ee") ! 406: ! 407: /* Unsigned multiply and divide. */ ! 408: ! 409: DEF_RTL_EXPR(UMULT, "umult", "ee") ! 410: DEF_RTL_EXPR(UDIV, "udiv", "ee") ! 411: DEF_RTL_EXPR(UMOD, "umod", "ee") ! 412: ! 413: /* Bitwise operations. */ ! 414: DEF_RTL_EXPR(AND, "and", "ee") ! 415: ! 416: DEF_RTL_EXPR(IOR, "ior", "ee") ! 417: ! 418: DEF_RTL_EXPR(XOR, "xor", "ee") ! 419: ! 420: DEF_RTL_EXPR(NOT, "not", "e") ! 421: ! 422: /* Operand: ! 423: 0: value to be shifted. ! 424: 1: number of bits. ! 425: ASHIFT and LSHIFT are distinguished because on some machines ! 426: these allow a negative operand and shift right in that case. */ ! 427: DEF_RTL_EXPR(LSHIFT, "lshift", "ee") ! 428: DEF_RTL_EXPR(ASHIFT, "ashift", "ee") ! 429: DEF_RTL_EXPR(ROTATE, "rotate", "ee") ! 430: ! 431: /* Right shift operations, for machines where these are not the same ! 432: as left shifting with a negative argument. */ ! 433: ! 434: DEF_RTL_EXPR(ASHIFTRT, "ashiftrt", "ee") ! 435: DEF_RTL_EXPR(LSHIFTRT, "lshiftrt", "ee") ! 436: DEF_RTL_EXPR(ROTATERT, "rotatert", "ee") ! 437: ! 438: /* These unary operations are used to represent incrementation ! 439: and decrementation as they occur in memory addresses. ! 440: The amount of increment or decrement are not represented ! 441: because they can be understood from the machine-mode of the ! 442: containing MEM. These operations exist in only two cases: ! 443: 1. pushes onto the stack. ! 444: 2. created automatically by the life_analysis pass in flow.c. */ ! 445: DEF_RTL_EXPR(PRE_DEC, "pre_dec", "e") ! 446: DEF_RTL_EXPR(PRE_INC, "pre_inc", "e") ! 447: DEF_RTL_EXPR(POST_DEC, "post_dec", "e") ! 448: DEF_RTL_EXPR(POST_INC, "post_inc", "e") ! 449: ! 450: /* Comparison operations. The ordered comparisons exist in two ! 451: flavors, signed and unsigned. */ ! 452: DEF_RTL_EXPR(NE, "ne", "ee") ! 453: DEF_RTL_EXPR(EQ, "eq", "ee") ! 454: DEF_RTL_EXPR(GE, "ge", "ee") ! 455: DEF_RTL_EXPR(GT, "gt", "ee") ! 456: DEF_RTL_EXPR(LE, "le", "ee") ! 457: DEF_RTL_EXPR(LT, "lt", "ee") ! 458: DEF_RTL_EXPR(GEU, "geu", "ee") ! 459: DEF_RTL_EXPR(GTU, "gtu", "ee") ! 460: DEF_RTL_EXPR(LEU, "leu", "ee") ! 461: DEF_RTL_EXPR(LTU, "ltu", "ee") ! 462: ! 463: /* Represents the result of sign-extending the sole operand. ! 464: The machine modes of the operand and of the SIGN_EXTEND expression ! 465: determine how much sign-extension is going on. */ ! 466: DEF_RTL_EXPR(SIGN_EXTEND, "sign_extend", "e") ! 467: ! 468: /* Similar for zero-extension (such as unsigned short to int). */ ! 469: DEF_RTL_EXPR(ZERO_EXTEND, "zero_extend", "e") ! 470: ! 471: /* Similar but here the operand has a wider mode. */ ! 472: DEF_RTL_EXPR(TRUNCATE, "truncate", "e") ! 473: ! 474: /* Similar for extending floating-point values (such as SFmode to DFmode). */ ! 475: DEF_RTL_EXPR(FLOAT_EXTEND, "float_extend", "e") ! 476: DEF_RTL_EXPR(FLOAT_TRUNCATE, "float_truncate", "e") ! 477: ! 478: /* Conversion of fixed point operand to floating point value. */ ! 479: DEF_RTL_EXPR(FLOAT, "float", "e") ! 480: ! 481: /* With fixed-point machine mode: ! 482: Conversion of floating point operand to fixed point value. ! 483: Value is defined only when the operand's value is an integer. ! 484: With floating-point machine mode (and operand with same mode): ! 485: Operand is rounded toward zero to produce an integer value ! 486: represented in floating point. */ ! 487: DEF_RTL_EXPR(FIX, "fix", "e") ! 488: ! 489: /* Conversion of unsigned fixed point operand to floating point value. */ ! 490: DEF_RTL_EXPR(UNSIGNED_FLOAT, "unsigned_float", "e") ! 491: ! 492: /* With fixed-point machine mode: ! 493: Conversion of floating point operand to *unsigned* fixed point value. ! 494: Value is defined only when the operand's value is an integer. */ ! 495: DEF_RTL_EXPR(UNSIGNED_FIX, "unsigned_fix", "e") ! 496: ! 497: /* Absolute value */ ! 498: DEF_RTL_EXPR(ABS, "abs", "e") ! 499: ! 500: /* Square root */ ! 501: DEF_RTL_EXPR(SQRT, "sqrt", "e") ! 502: ! 503: /* Find first bit that is set. ! 504: Value is 1 + number of trailing zeros in the arg., ! 505: or 0 if arg is 0. */ ! 506: DEF_RTL_EXPR(FFS, "ffs", "e") ! 507: ! 508: /* Reference to a signed bit-field of specified size and position. ! 509: Operand 0 is the memory unit (usually SImode or QImode) which ! 510: contains the field's first bit. Operand 1 is the width, in bits. ! 511: Operand 2 is the number of bits in the memory unit before the ! 512: first bit of this field. ! 513: If BITS_BIG_ENDIAN is defined, the first bit is the msb and ! 514: operand 2 counts from the msb of the memory unit. ! 515: Otherwise, the first bit is the lsb and operand 2 counts from ! 516: the lsb of the memory unit. */ ! 517: DEF_RTL_EXPR(SIGN_EXTRACT, "sign_extract", "eee") ! 518: ! 519: /* Similar for unsigned bit-field. */ ! 520: DEF_RTL_EXPR(ZERO_EXTRACT, "zero_extract", "eee") ! 521: ! 522: /* ! 523: Local variables: ! 524: mode:c ! 525: version-control: t ! 526: End: ! 527: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.