Open64 (mfef90, whirl2f, and IR tools): osprey1.0/common/com/opcode

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