Open64: osprey/dipa/rta/open64/opcode

00001 /*
00002  * Copyright 2005, 2006 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /*
00006 
00007   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00008 
00009   This program is free software; you can redistribute it and/or modify it
00010   under the terms of version 2 of the GNU General Public License as
00011   published by the Free Software Foundation.
00012 
00013   This program is distributed in the hope that it would be useful, but
00014   WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00016 
00017   Further, this software is distributed without any warranty that it is
00018   free of the rightful claim of any third person regarding infringement 
00019   or the like.  Any license provided herein, whether implied or 
00020   otherwise, applies only to this software file.  Patent licenses, if 
00021   any, provided herein do not apply to combinations of this program with 
00022   other software, or any other product whatsoever.  
00023 
00024   You should have received a copy of the GNU General Public License along
00025   with this program; if not, write the Free Software Foundation, Inc., 59
00026   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00027 
00028   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00029   Mountain View, CA 94043, or:
00030 
00031   http://www.sgi.com
00032 
00033   For further information regarding this notice, see:
00034 
00035   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00036 
00037 */
00038 
00039 
00040 /* Inlines for looking up attribute values */
00041 
00042 /*REFERENCED*/
00043 inline mUINT32
00044 OPERATOR_is_scf (OPERATOR op)
00045 {
00046   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00047   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_scf;
00048 }
00049 
00050 /*REFERENCED*/
00051 inline mUINT32
00052 OPERATOR_is_stmt (OPERATOR op)
00053 {
00054   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00055   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_stmt;
00056 }
00057 
00058 /*REFERENCED*/
00059 inline mUINT32
00060 OPERATOR_is_expression(OPERATOR op)
00061 {
00062   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00063   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_expression;
00064 }
00065 
00066 /*REFERENCED*/
00067 inline mUINT32
00068 OPERATOR_is_leaf (OPERATOR op)
00069 {
00070   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00071   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_leaf;
00072 }
00073 
00074 /*REFERENCED*/
00075 inline mUINT32
00076 OPERATOR_is_store (OPERATOR op)
00077 {
00078   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00079   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_store;
00080 }
00081 
00082 /*REFERENCED*/
00083 inline mUINT32
00084 OPERATOR_is_load (OPERATOR op)
00085 {
00086   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00087   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_load;
00088 }
00089 
00090 /*REFERENCED*/
00091 inline mUINT32
00092 OPERATOR_is_call(OPERATOR op)
00093 {
00094   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00095   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_call;
00096 }
00097 
00098 /*REFERENCED*/
00099 inline mUINT32
00100 OPERATOR_is_compare (OPERATOR op)
00101 {
00102   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00103   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_compare;
00104 }
00105 
00106 /*REFERENCED*/
00107 inline mUINT32
00108 OPERATOR_is_non_scf (OPERATOR op)
00109 {
00110   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00111   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_non_scf;
00112 }
00113 
00114 /*REFERENCED*/
00115 inline mUINT32
00116 OPERATOR_is_boolean (OPERATOR op)
00117 {
00118   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00119   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_boolean;
00120 }
00121 
00122 /*REFERENCED*/
00123 inline mUINT32
00124 OPERATOR_is_endsbb (OPERATOR op)
00125 {
00126   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00127   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_endsbb;
00128 }
00129 
00130 /*REFERENCED*/
00131 inline mUINT32
00132 OPERATOR_is_comp_unit_if (OPERATOR op)
00133 {
00134   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00135   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_comp_unit_if;
00136 }
00137 
00138 /*REFERENCED*/
00139 inline mUINT32
00140 OPERATOR_is_not_executable (OPERATOR op)
00141 {
00142   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00143   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_not_executable;
00144 }
00145 
00146 /*REFERENCED*/
00147 inline mUINT32
00148 OPERATOR_is_prefetch (OPERATOR op)
00149 {
00150   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00151   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_prefetch;
00152 }
00153 
00154 /*REFERENCED*/
00155 inline mUINT32
00156 OPERATOR_has_next_prev (OPERATOR op)
00157 {
00158   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00159   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_next_prev;
00160 }
00161 
00162 /*REFERENCED*/
00163 inline mUINT32
00164 OPERATOR_has_sym (OPERATOR op)
00165 {
00166   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00167   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_sym;
00168 }
00169 
00170 /*REFERENCED*/
00171 inline mUINT32
00172 OPERATOR_has_label (OPERATOR op)
00173 {
00174   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00175   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_label;
00176 }
00177 
00178 /*REFERENCED*/
00179 inline mUINT32
00180 OPERATOR_has_num_entries (OPERATOR op)
00181 {
00182   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00183   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_num_entries;
00184 }
00185 
00186 /*REFERENCED*/
00187 inline mUINT32
00188 OPERATOR_has_offset (OPERATOR op)
00189 {
00190   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00191   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_offset;
00192 }
00193 
00194 /*REFERENCED*/
00195 inline mUINT32
00196 OPERATOR_has_2offsets (OPERATOR op)
00197 {
00198   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00199   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_2offsets;
00200 }
00201 
00202 /*REFERENCED*/
00203 inline mUINT32
00204 OPERATOR_has_bits (OPERATOR op)
00205 {
00206   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00207   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_bits;
00208 }
00209 
00210 /*REFERENCED*/
00211 inline mUINT32
00212 OPERATOR_has_ndim (OPERATOR op)
00213 {
00214   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00215   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_ndim;
00216 }
00217 
00218 /*REFERENCED*/
00219 inline mUINT32
00220 OPERATOR_has_esize (OPERATOR op)
00221 {
00222   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00223   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_esize;
00224 }
00225 
00226 /*REFERENCED*/
00227 inline mUINT32
00228 OPERATOR_has_value (OPERATOR op)
00229 {
00230   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00231   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_value;
00232 }
00233 
00234 /*REFERENCED*/
00235 inline mUINT32
00236 OPERATOR_has_flags (OPERATOR op)
00237 {
00238   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00239   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_flags;
00240 }
00241 
00242 /*REFERENCED*/
00243 inline mUINT32
00244 OPERATOR_has_inumber (OPERATOR op)
00245 {
00246   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00247   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_inumber;
00248 }
00249 
00250 /*REFERENCED*/
00251 inline mUINT32
00252 OPERATOR_has_1ty (OPERATOR op)
00253 {
00254   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00255   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_1ty;
00256 }
00257 
00258 /*REFERENCED*/
00259 inline mUINT32
00260 OPERATOR_has_2ty (OPERATOR op)
00261 {
00262   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00263   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_2ty;
00264 }
00265 
00266 /*REFERENCED*/
00267 inline mUINT32
00268 OPERATOR_has_ereg_supp (OPERATOR op)
00269 {
00270   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00271   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_ereg_supp;
00272 }
00273 
00274 /*REFERENCED*/
00275 inline mUINT32
00276 OPERATOR_has_barrier (OPERATOR op)
00277 {
00278   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00279   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_barrier;
00280 }
00281 
00282 /*REFERENCED*/
00283 inline mUINT32
00284 OPERATOR_has_last_label (OPERATOR op)
00285 {
00286   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00287   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_last_label;
00288 }
00289 
00290 /*REFERENCED*/
00291 inline mUINT32
00292 OPERATOR_has_field_id (OPERATOR op)
00293 {
00294   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00295   return (mUINT32) OPERATOR_info [op]._flags & OPERATOR_PROPERTY_field_id;
00296 }
00297 
00298 /*REFERENCED*/
00299 inline mINT8
00300 OPERATOR_nkids (OPERATOR op)
00301 {
00302   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00303 #if 0 // SC
00304   return OPERATOR_info [op].nkids;
00305 #else
00306   printf(" Oper_info %3d NYI", op);
00307   return 0;
00308 #endif
00309 }
00310 
00311 /*REFERENCED*/
00312 inline OPERATOR_MAPCAT
00313 OPERATOR_mapcat (OPERATOR op)
00314 {
00315   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00316   return OPERATOR_info[op].mapcat;
00317 }
00318 
00319 /*REFERENCED*/
00320 inline BOOL
00321 OPERATOR_is_black_box (OPERATOR op)
00322 {
00323   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00324   return (op == OPR_IO);
00325 }
00326 
00327 /* Compatibility functions */
00328 #if 0 // SC
00329 extern OPCODE   OPCODE_is_valid_opcode_table[];
00330 #define OPCODE_MAKE_VALID(x) (OPCODE_is_valid_opcode_table[(x)])
00331 #endif
00332 
00333 #if 1
00334 static inline BOOL Is_Valid_Opcode(OPCODE c) { return 1; }
00335 static inline BOOL Is_Valid_Opcode_FUNC(OPCODE c) { return 1; }
00336 #else
00337 #define Is_Valid_Opcode(opcode) (OPCODE_is_valid_opcode_table[(opcode)]!=OPC_UNKNOWN)
00338 
00339 #ifdef __cplusplus
00340 extern "C" BOOL Is_Valid_Opcode_FUNC (OPCODE op);
00341 BOOL Is_Valid_Opcode_Parts(OPERATOR opr, TYPE_ID rtype, TYPE_ID desc);
00342 #else
00343 extern BOOL Is_Valid_Opcode_FUNC (OPCODE op);
00344 #endif /* __cplusplus */
00345 #endif
00346 
00347 /*REFERENCED*/
00348 inline OPERATOR
00349 OPCODE_operator (OPCODE op)
00350 {
00351   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00352   return (OPERATOR) (op & 0xFF);
00353 }
00354 
00355 /*REFERENCED*/
00356 inline TYPE_ID
00357 OPCODE_rtype (OPCODE op)
00358 {
00359   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00360   return (TYPE_ID) ((op >> 8) & 0x3F);
00361 }
00362 
00363 /*REFERENCED*/
00364 inline TYPE_ID
00365 OPCODE_desc (OPCODE op)
00366 {
00367   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00368   return (TYPE_ID) ((op >> 14) & 0x3F);
00369 }
00370 
00371 extern char* OPCODE_name (OPCODE op);
00372 
00373 /* Inlines for looking up attribute values */
00374 
00375 /*REFERENCED*/
00376 inline mUINT32
00377 OPCODE_is_scf (OPCODE op)
00378 {
00379   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00380   return (OPERATOR_is_scf (OPCODE_operator (op)));
00381 }
00382 
00383 /*REFERENCED*/
00384 inline mUINT32
00385 OPCODE_is_stmt (OPCODE op)
00386 {
00387   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00388   return (OPERATOR_is_stmt (OPCODE_operator (op)));
00389 }
00390 
00391 /*REFERENCED*/
00392 inline mUINT32
00393 OPCODE_is_expression (OPCODE op)
00394 {
00395   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00396   return (OPERATOR_is_expression (OPCODE_operator (op)));
00397 }
00398 
00399 /*REFERENCED*/
00400 inline mUINT32
00401 OPCODE_is_leaf (OPCODE op)
00402 {
00403   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00404   return (OPERATOR_is_leaf (OPCODE_operator (op)));
00405 }
00406 
00407 /*REFERENCED*/
00408 inline mUINT32
00409 OPCODE_is_store (OPCODE op)
00410 {
00411   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00412   return (OPERATOR_is_store (OPCODE_operator (op)));
00413 }
00414 
00415 /*REFERENCED*/
00416 inline mUINT32
00417 OPCODE_is_load (OPCODE op)
00418 {
00419   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00420   return (OPERATOR_is_load (OPCODE_operator (op)));
00421 }
00422 
00423 /*REFERENCED*/
00424 inline mUINT32
00425 OPCODE_is_call (OPCODE op)
00426 {
00427   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00428   return (OPERATOR_is_call (OPCODE_operator (op)));
00429 }
00430 
00431 /*REFERENCED*/
00432 inline mUINT32
00433 OPCODE_is_compare (OPCODE op)
00434 {
00435   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00436   return (OPERATOR_is_compare (OPCODE_operator (op)));
00437 }
00438 
00439 /*REFERENCED*/
00440 inline mUINT32
00441 OPCODE_is_non_scf (OPCODE op)
00442 {
00443   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00444   return (OPERATOR_is_non_scf (OPCODE_operator (op)));
00445 }
00446 
00447 /*REFERENCED*/
00448 inline mUINT32
00449 OPCODE_is_boolean (OPCODE op)
00450 {
00451   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00452   return (OPERATOR_is_boolean (OPCODE_operator (op)));
00453 }
00454 
00455 /*REFERENCED*/
00456 inline mUINT32
00457 OPCODE_is_endsbb (OPCODE op)
00458 {
00459   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00460   return (OPERATOR_is_endsbb (OPCODE_operator (op)));
00461 }
00462 
00463 /*REFERENCED*/
00464 inline mUINT32
00465 OPCODE_is_comp_unit_if (OPCODE op)
00466 {
00467   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00468   return (OPERATOR_is_comp_unit_if (OPCODE_operator (op)));
00469 }
00470 
00471 /*REFERENCED*/
00472 inline mUINT32
00473 OPCODE_is_not_executable (OPCODE op)
00474 {
00475   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00476   return (OPERATOR_is_not_executable (OPCODE_operator (op)));
00477 }
00478 
00479 /*REFERENCED*/
00480 inline mUINT32
00481 OPCODE_is_prefetch (OPCODE op)
00482 {
00483   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00484   return (OPERATOR_is_prefetch (OPCODE_operator (op)));
00485 }
00486 
00487 /*REFERENCED*/
00488 inline mUINT32
00489 OPCODE_has_next_prev (OPCODE op)
00490 {
00491   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00492   return (OPERATOR_has_next_prev (OPCODE_operator (op)));
00493 }
00494 
00495 /*REFERENCED*/
00496 inline mUINT32
00497 OPCODE_has_sym (OPCODE op)
00498 {
00499   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00500   return (OPERATOR_has_sym (OPCODE_operator (op)));
00501 }
00502 
00503 /*REFERENCED*/
00504 inline mUINT32
00505 OPCODE_has_label (OPCODE op)
00506 {
00507   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00508   return (OPERATOR_has_label (OPCODE_operator (op)));
00509 }
00510 
00511 /*REFERENCED*/
00512 inline mUINT32
00513 OPCODE_has_num_entries (OPCODE op)
00514 {
00515   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00516   return (OPERATOR_has_num_entries (OPCODE_operator (op)));
00517 }
00518 
00519 /*REFERENCED*/
00520 inline mUINT32
00521 OPCODE_has_offset (OPCODE op)
00522 {
00523   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00524   return (OPERATOR_has_offset (OPCODE_operator (op)));
00525 }
00526 
00527 /*REFERENCED*/
00528 inline mUINT32
00529 OPCODE_has_2offsets (OPCODE op)
00530 {
00531   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00532   return (OPERATOR_has_2offsets (OPCODE_operator (op)));
00533 }
00534 
00535 /*REFERENCED*/
00536 inline mUINT32
00537 OPCODE_has_bits (OPCODE op)
00538 {
00539   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00540   return (OPERATOR_has_bits (OPCODE_operator (op)));
00541 }
00542 
00543 /*REFERENCED*/
00544 inline mUINT32
00545 OPCODE_has_ndim (OPCODE op)
00546 {
00547   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00548   return (OPERATOR_has_ndim (OPCODE_operator (op)));
00549 }
00550 
00551 /*REFERENCED*/
00552 inline mUINT32
00553 OPCODE_has_esize (OPCODE op)
00554 {
00555   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00556   return (OPERATOR_has_esize (OPCODE_operator (op)));
00557 }
00558 
00559 /*REFERENCED*/
00560 inline mUINT32
00561 OPCODE_has_value (OPCODE op)
00562 {
00563   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00564   return (OPERATOR_has_value (OPCODE_operator (op)));
00565 }
00566 
00567 /*REFERENCED*/
00568 inline mUINT32
00569 OPCODE_has_flags (OPCODE op)
00570 {
00571   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00572   return (OPERATOR_has_flags (OPCODE_operator (op)));
00573 }
00574 
00575 /*REFERENCED*/
00576 inline mUINT32
00577 OPCODE_has_inumber (OPCODE op)
00578 {
00579   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00580   return (OPERATOR_has_inumber (OPCODE_operator (op)));
00581 }
00582 
00583 /*REFERENCED*/
00584 inline mUINT32
00585 OPCODE_has_1ty (OPCODE op)
00586 {
00587   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00588   return (OPERATOR_has_1ty (OPCODE_operator (op)));
00589 }
00590 
00591 /*REFERENCED*/
00592 inline mUINT32
00593 OPCODE_has_2ty (OPCODE op)
00594 {
00595   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00596   return (OPERATOR_has_2ty (OPCODE_operator (op)));
00597 }
00598 
00599 /*REFERENCED*/
00600 inline mUINT32
00601 OPCODE_has_ereg_supp (OPCODE op)
00602 {
00603   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00604   return (OPERATOR_has_ereg_supp (OPCODE_operator (op)));
00605 }
00606 
00607 /*REFERENCED*/
00608 inline mUINT32
00609 OPCODE_has_barrier (OPCODE op)
00610 {
00611   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00612   return (OPERATOR_has_barrier (OPCODE_operator (op)));
00613 }
00614 
00615 /*REFERENCED*/
00616 inline mUINT32
00617 OPCODE_has_last_label (OPCODE op)
00618 {
00619   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00620   return (OPERATOR_has_last_label (OPCODE_operator (op)));
00621 }
00622 
00623 /*REFERENCED*/
00624 inline mUINT32
00625 OPCODE_has_field_id (OPCODE op)
00626 {
00627   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00628   return (OPERATOR_has_field_id (OPCODE_operator (op)));
00629 }
00630 
00631 /*REFERENCED*/
00632 inline mINT8
00633 OPCODE_nkids(OPCODE op)
00634 {
00635   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00636   return (OPERATOR_nkids (OPCODE_operator (op)));
00637 }
00638 
00639 /*REFERENCED*/
00640 inline OPERATOR_MAPCAT
00641 OPCODE_mapcat (OPCODE op)
00642 {
00643   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00644   return (OPERATOR_mapcat (OPCODE_operator (op)));
00645 }
00646 
00647 /*REFERENCED*/
00648 inline BOOL
00649 OPCODE_is_black_box (OPCODE op)
00650 {
00651   Is_True(Is_Valid_Opcode(op), ("Bad opcode %d", op));
00652   return (OPERATOR_is_black_box (OPCODE_operator (op)));
00653 }
osprey/dipa/rta/open64/opcode_gen.h
