Open64: osprey/common/com/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   return OPERATOR_info [op].nkids;
00304 }
00305 
00306 /*REFERENCED*/
00307 inline OPERATOR_MAPCAT
00308 OPERATOR_mapcat (OPERATOR op)
00309 {
00310   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00311   return OPERATOR_info[op].mapcat;
00312 }
00313 
00314 /*REFERENCED*/
00315 inline BOOL
00316 OPERATOR_is_black_box (OPERATOR op)
00317 {
00318   Is_True(op >= OPERATOR_FIRST && op <= OPERATOR_LAST, ("Bad operator %d", op));
00319   return (op == OPR_IO);
00320 }
00321 
00322 /* Compatibility functions */
00323 #if 0
00324 extern OPCODE   OPCODE_is_valid_opcode_table[];
00325 #define OPCODE_MAKE_VALID(x) (OPCODE_is_valid_opcode_table[(x)])
00326 #endif
00327 
00328 #if 1
00329 #define Is_Valid_Opcode Is_Valid_Opcode_FUNC
00330 #else
00331 #define Is_Valid_Opcode(opcode) (OPCODE_is_valid_opcode_table[(opcode)]!=OPC_UNKNOWN)
00332 #endif
00333 
00334 #ifdef __cplusplus
00335 extern "C" BOOL Is_Valid_Opcode_FUNC (OPCODE op);
00336 BOOL Is_Valid_Opcode_Parts(OPERATOR opr, TYPE_ID rtype, TYPE_ID desc);
00337 #else
00338 extern BOOL Is_Valid_Opcode_FUNC (OPCODE op);
00339 #endif /* __cplusplus */
00340 
00341 /*REFERENCED*/
00342 inline OPERATOR
00343 OPCODE_operator (OPCODE op)
00344 {
00345   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00346   return (OPERATOR) (op & 0xFF);
00347 }
00348 
00349 /*REFERENCED*/
00350 inline TYPE_ID
00351 OPCODE_rtype (OPCODE op)
00352 {
00353   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00354   return (TYPE_ID) ((op >> 8) & 0x3F);
00355 }
00356 
00357 /*REFERENCED*/
00358 inline TYPE_ID
00359 OPCODE_desc (OPCODE op)
00360 {
00361   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00362   return (TYPE_ID) ((op >> 14) & 0x3F);
00363 }
00364 
00365 extern char* OPCODE_name (OPCODE op);
00366 
00367 /* Inlines for looking up attribute values */
00368 
00369 /*REFERENCED*/
00370 inline mUINT32
00371 OPCODE_is_scf (OPCODE op)
00372 {
00373   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00374   return (OPERATOR_is_scf (OPCODE_operator (op)));
00375 }
00376 
00377 /*REFERENCED*/
00378 inline mUINT32
00379 OPCODE_is_stmt (OPCODE op)
00380 {
00381   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00382   return (OPERATOR_is_stmt (OPCODE_operator (op)));
00383 }
00384 
00385 /*REFERENCED*/
00386 inline mUINT32
00387 OPCODE_is_expression (OPCODE op)
00388 {
00389   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00390   return (OPERATOR_is_expression (OPCODE_operator (op)));
00391 }
00392 
00393 /*REFERENCED*/
00394 inline mUINT32
00395 OPCODE_is_leaf (OPCODE op)
00396 {
00397   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00398   return (OPERATOR_is_leaf (OPCODE_operator (op)));
00399 }
00400 
00401 /*REFERENCED*/
00402 inline mUINT32
00403 OPCODE_is_store (OPCODE op)
00404 {
00405   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00406   return (OPERATOR_is_store (OPCODE_operator (op)));
00407 }
00408 
00409 /*REFERENCED*/
00410 inline mUINT32
00411 OPCODE_is_load (OPCODE op)
00412 {
00413   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00414   return (OPERATOR_is_load (OPCODE_operator (op)));
00415 }
00416 
00417 /*REFERENCED*/
00418 inline mUINT32
00419 OPCODE_is_call (OPCODE op)
00420 {
00421   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00422   return (OPERATOR_is_call (OPCODE_operator (op)));
00423 }
00424 
00425 /*REFERENCED*/
00426 inline mUINT32
00427 OPCODE_is_compare (OPCODE op)
00428 {
00429   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00430   return (OPERATOR_is_compare (OPCODE_operator (op)));
00431 }
00432 
00433 /*REFERENCED*/
00434 inline mUINT32
00435 OPCODE_is_non_scf (OPCODE op)
00436 {
00437   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00438   return (OPERATOR_is_non_scf (OPCODE_operator (op)));
00439 }
00440 
00441 /*REFERENCED*/
00442 inline mUINT32
00443 OPCODE_is_boolean (OPCODE op)
00444 {
00445   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00446   return (OPERATOR_is_boolean (OPCODE_operator (op)));
00447 }
00448 
00449 /*REFERENCED*/
00450 inline mUINT32
00451 OPCODE_is_endsbb (OPCODE op)
00452 {
00453   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00454   return (OPERATOR_is_endsbb (OPCODE_operator (op)));
00455 }
00456 
00457 /*REFERENCED*/
00458 inline mUINT32
00459 OPCODE_is_comp_unit_if (OPCODE op)
00460 {
00461   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00462   return (OPERATOR_is_comp_unit_if (OPCODE_operator (op)));
00463 }
00464 
00465 /*REFERENCED*/
00466 inline mUINT32
00467 OPCODE_is_not_executable (OPCODE op)
00468 {
00469   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00470   return (OPERATOR_is_not_executable (OPCODE_operator (op)));
00471 }
00472 
00473 /*REFERENCED*/
00474 inline mUINT32
00475 OPCODE_is_prefetch (OPCODE op)
00476 {
00477   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00478   return (OPERATOR_is_prefetch (OPCODE_operator (op)));
00479 }
00480 
00481 /*REFERENCED*/
00482 inline mUINT32
00483 OPCODE_has_next_prev (OPCODE op)
00484 {
00485   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00486   return (OPERATOR_has_next_prev (OPCODE_operator (op)));
00487 }
00488 
00489 /*REFERENCED*/
00490 inline mUINT32
00491 OPCODE_has_sym (OPCODE op)
00492 {
00493   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00494   return (OPERATOR_has_sym (OPCODE_operator (op)));
00495 }
00496 
00497 /*REFERENCED*/
00498 inline mUINT32
00499 OPCODE_has_label (OPCODE op)
00500 {
00501   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00502   return (OPERATOR_has_label (OPCODE_operator (op)));
00503 }
00504 
00505 /*REFERENCED*/
00506 inline mUINT32
00507 OPCODE_has_num_entries (OPCODE op)
00508 {
00509   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00510   return (OPERATOR_has_num_entries (OPCODE_operator (op)));
00511 }
00512 
00513 /*REFERENCED*/
00514 inline mUINT32
00515 OPCODE_has_offset (OPCODE op)
00516 {
00517   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00518   return (OPERATOR_has_offset (OPCODE_operator (op)));
00519 }
00520 
00521 /*REFERENCED*/
00522 inline mUINT32
00523 OPCODE_has_2offsets (OPCODE op)
00524 {
00525   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00526   return (OPERATOR_has_2offsets (OPCODE_operator (op)));
00527 }
00528 
00529 /*REFERENCED*/
00530 inline mUINT32
00531 OPCODE_has_bits (OPCODE op)
00532 {
00533   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00534   return (OPERATOR_has_bits (OPCODE_operator (op)));
00535 }
00536 
00537 /*REFERENCED*/
00538 inline mUINT32
00539 OPCODE_has_ndim (OPCODE op)
00540 {
00541   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00542   return (OPERATOR_has_ndim (OPCODE_operator (op)));
00543 }
00544 
00545 /*REFERENCED*/
00546 inline mUINT32
00547 OPCODE_has_esize (OPCODE op)
00548 {
00549   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00550   return (OPERATOR_has_esize (OPCODE_operator (op)));
00551 }
00552 
00553 /*REFERENCED*/
00554 inline mUINT32
00555 OPCODE_has_value (OPCODE op)
00556 {
00557   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00558   return (OPERATOR_has_value (OPCODE_operator (op)));
00559 }
00560 
00561 /*REFERENCED*/
00562 inline mUINT32
00563 OPCODE_has_flags (OPCODE op)
00564 {
00565   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00566   return (OPERATOR_has_flags (OPCODE_operator (op)));
00567 }
00568 
00569 /*REFERENCED*/
00570 inline mUINT32
00571 OPCODE_has_inumber (OPCODE op)
00572 {
00573   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00574   return (OPERATOR_has_inumber (OPCODE_operator (op)));
00575 }
00576 
00577 /*REFERENCED*/
00578 inline mUINT32
00579 OPCODE_has_1ty (OPCODE op)
00580 {
00581   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00582   return (OPERATOR_has_1ty (OPCODE_operator (op)));
00583 }
00584 
00585 /*REFERENCED*/
00586 inline mUINT32
00587 OPCODE_has_2ty (OPCODE op)
00588 {
00589   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00590   return (OPERATOR_has_2ty (OPCODE_operator (op)));
00591 }
00592 
00593 /*REFERENCED*/
00594 inline mUINT32
00595 OPCODE_has_ereg_supp (OPCODE op)
00596 {
00597   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00598   return (OPERATOR_has_ereg_supp (OPCODE_operator (op)));
00599 }
00600 
00601 /*REFERENCED*/
00602 inline mUINT32
00603 OPCODE_has_barrier (OPCODE op)
00604 {
00605   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00606   return (OPERATOR_has_barrier (OPCODE_operator (op)));
00607 }
00608 
00609 /*REFERENCED*/
00610 inline mUINT32
00611 OPCODE_has_last_label (OPCODE op)
00612 {
00613   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00614   return (OPERATOR_has_last_label (OPCODE_operator (op)));
00615 }
00616 
00617 /*REFERENCED*/
00618 inline mUINT32
00619 OPCODE_has_field_id (OPCODE op)
00620 {
00621   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00622   return (OPERATOR_has_field_id (OPCODE_operator (op)));
00623 }
00624 
00625 /*REFERENCED*/
00626 inline mINT8
00627 OPCODE_nkids(OPCODE op)
00628 {
00629   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00630   return (OPERATOR_nkids (OPCODE_operator (op)));
00631 }
00632 
00633 /*REFERENCED*/
00634 inline OPERATOR_MAPCAT
00635 OPCODE_mapcat (OPCODE op)
00636 {
00637   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00638   return (OPERATOR_mapcat (OPCODE_operator (op)));
00639 }
00640 
00641 /*REFERENCED*/
00642 inline BOOL
00643 OPCODE_is_black_box (OPCODE op)
00644 {
00645   Is_True(Is_Valid_Opcode (op), ("Bad opcode %d", op));
00646   return (OPERATOR_is_black_box (OPCODE_operator (op)));
00647 }
osprey/common/com/opcode_gen.h
