340             case Byte:
 341                 return forByte((byte) 0);
 342             case Char:
 343                 return forChar((char) 0);
 344             case Short:
 345                 return forShort((short) 0);
 346             case Int:
 347                 return INT_0;
 348             case Double:
 349                 return DOUBLE_0;
 350             case Float:
 351                 return FLOAT_0;
 352             case Long:
 353                 return LONG_0;
 354             case Object:
 355                 return NULL_POINTER;
 356             default:
 357                 throw new IllegalArgumentException(kind.toString());
 358         }
 359     }
 360 
 361     /**
 362      * Returns the zero value for a given numeric kind.
 363      */
 364     static JavaConstant zero(JavaKind kind) {
 365         switch (kind) {
 366             case Boolean:
 367                 return FALSE;
 368             case Byte:
 369                 return forByte((byte) 0);
 370             case Char:
 371                 return forChar((char) 0);
 372             case Double:
 373                 return DOUBLE_0;
 374             case Float:
 375                 return FLOAT_0;
 376             case Int:
 377                 return INT_0;
 378             case Long:
 379                 return LONG_0;
 380             case Short:
 381                 return forShort((short) 0);
 382             default:
 383                 throw new IllegalArgumentException(kind.toString());
 384         }
 385     }
 386 
 387     /**
 388      * Returns the one value for a given numeric kind.
 389      */
 390     static JavaConstant one(JavaKind kind) {
 391         switch (kind) {
 392             case Boolean:
 393                 return TRUE;
 394             case Byte:
 395                 return forByte((byte) 1);
 396             case Char:
 397                 return forChar((char) 1);
 398             case Double:
 399                 return DOUBLE_1;
 400             case Float:
 401                 return FLOAT_1;
 402             case Int:
 403                 return INT_1;
 404             case Long:
 405                 return LONG_1;
 406             case Short:
 407                 return forShort((short) 1);
 408             default:
 409                 throw new IllegalArgumentException(kind.toString());
 410         }
 411     }
 412 
 413     /**
 414      * Adds two numeric constants.
 415      */
 416     static JavaConstant add(JavaConstant x, JavaConstant y) {
 417         assert x.getJavaKind() == y.getJavaKind();
 418         switch (x.getJavaKind()) {
 419             case Byte:
 420                 return forByte((byte) (x.asInt() + y.asInt()));
 421             case Char:
 422                 return forChar((char) (x.asInt() + y.asInt()));
 423             case Double:
 424                 return forDouble(x.asDouble() + y.asDouble());
 425             case Float:
 426                 return forFloat(x.asFloat() + y.asFloat());
 427             case Int:
 428                 return forInt(x.asInt() + y.asInt());
 429             case Long:
 430                 return forLong(x.asLong() + y.asLong());
 431             case Short:
 432                 return forShort((short) (x.asInt() + y.asInt()));
 433             default:
 434                 throw new IllegalArgumentException(x.getJavaKind().toString());
 435         }
 436     }
 437 
 438     /**
 439      * Multiplies two numeric constants.
 440      */
 441     static PrimitiveConstant mul(JavaConstant x, JavaConstant y) {
 442         assert x.getJavaKind() == y.getJavaKind();
 443         switch (x.getJavaKind()) {
 444             case Byte:
 445                 return forByte((byte) (x.asInt() * y.asInt()));
 446             case Char:
 447                 return forChar((char) (x.asInt() * y.asInt()));
 448             case Double:
 449                 return forDouble(x.asDouble() * y.asDouble());
 450             case Float:
 451                 return forFloat(x.asFloat() * y.asFloat());
 452             case Int:
 453                 return forInt(x.asInt() * y.asInt());
 454             case Long:
 455                 return forLong(x.asLong() * y.asLong());
 456             case Short:
 457                 return forShort((short) (x.asInt() * y.asInt()));
 458             default:
 459                 throw new IllegalArgumentException(x.getJavaKind().toString());
 460         }
 461     }
 462 }

 340             case Byte:
 341                 return forByte((byte) 0);
 342             case Char:
 343                 return forChar((char) 0);
 344             case Short:
 345                 return forShort((short) 0);
 346             case Int:
 347                 return INT_0;
 348             case Double:
 349                 return DOUBLE_0;
 350             case Float:
 351                 return FLOAT_0;
 352             case Long:
 353                 return LONG_0;
 354             case Object:
 355                 return NULL_POINTER;
 356             default:
 357                 throw new IllegalArgumentException(kind.toString());
 358         }
 359     }






































































































 360 }