Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/globals.cpp @ 20804:7848fc12602b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge with jdk8u40-b25
author Gilles Duboscq <gilles.m.duboscq@oracle.com>
date Tue, 07 Apr 2015 14:58:49 +0200
parents 52b4284cb496 46140919bf90
children be896a1983c0
comparison
equal deleted inserted replaced
20184:84105dcdb05b 20804:7848fc12602b
242 } 242 }
243 if (is_experimental()) { 243 if (is_experimental()) {
244 return UnlockExperimentalVMOptions; 244 return UnlockExperimentalVMOptions;
245 } 245 }
246 return is_unlocked_ext(); 246 return is_unlocked_ext();
247 }
248
249 void Flag::unlock_diagnostic() {
250 assert(is_diagnostic(), "sanity");
251 _flags = Flags(_flags & ~KIND_DIAGNOSTIC);
247 } 252 }
248 253
249 // Get custom message for this locked flag, or return NULL if 254 // Get custom message for this locked flag, or return NULL if
250 // none is available. 255 // none is available.
251 void Flag::get_locked_message(char* buf, int buflen) const { 256 void Flag::get_locked_message(char* buf, int buflen) const {
622 e.set_new_value(new_value); 627 e.set_new_value(new_value);
623 e.set_origin(origin); 628 e.set_origin(origin);
624 e.commit(); 629 e.commit();
625 } 630 }
626 631
627 bool CommandLineFlags::boolAt(char* name, size_t len, bool* value) { 632 bool CommandLineFlags::boolAt(const char* name, size_t len, bool* value) {
628 Flag* result = Flag::find_flag(name, len); 633 Flag* result = Flag::find_flag(name, len);
629 if (result == NULL) return false; 634 if (result == NULL) return false;
630 if (!result->is_bool()) return false; 635 if (!result->is_bool()) return false;
631 *value = result->get_bool(); 636 *value = result->get_bool();
632 return true; 637 return true;
633 } 638 }
634 639
635 bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin) { 640 bool CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
636 Flag* result = Flag::find_flag(name, len); 641 Flag* result = Flag::find_flag(name, len);
637 if (result == NULL) return false; 642 if (result == NULL) return false;
638 if (!result->is_bool()) return false; 643 if (!result->is_bool()) return false;
639 bool old_value = result->get_bool(); 644 bool old_value = result->get_bool();
640 trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin); 645 trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
650 trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin); 655 trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
651 faddr->set_bool(value); 656 faddr->set_bool(value);
652 faddr->set_origin(origin); 657 faddr->set_origin(origin);
653 } 658 }
654 659
655 bool CommandLineFlags::intxAt(char* name, size_t len, intx* value) { 660 bool CommandLineFlags::intxAt(const char* name, size_t len, intx* value) {
656 Flag* result = Flag::find_flag(name, len); 661 Flag* result = Flag::find_flag(name, len);
657 if (result == NULL) return false; 662 if (result == NULL) return false;
658 if (!result->is_intx()) return false; 663 if (!result->is_intx()) return false;
659 *value = result->get_intx(); 664 *value = result->get_intx();
660 return true; 665 return true;
661 } 666 }
662 667
663 bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin) { 668 bool CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
664 Flag* result = Flag::find_flag(name, len); 669 Flag* result = Flag::find_flag(name, len);
665 if (result == NULL) return false; 670 if (result == NULL) return false;
666 if (!result->is_intx()) return false; 671 if (!result->is_intx()) return false;
667 intx old_value = result->get_intx(); 672 intx old_value = result->get_intx();
668 trace_flag_changed<EventLongFlagChanged, s8>(name, old_value, *value, origin); 673 trace_flag_changed<EventLongFlagChanged, s8>(name, old_value, *value, origin);
678 trace_flag_changed<EventLongFlagChanged, s8>(faddr->_name, faddr->get_intx(), value, origin); 683 trace_flag_changed<EventLongFlagChanged, s8>(faddr->_name, faddr->get_intx(), value, origin);
679 faddr->set_intx(value); 684 faddr->set_intx(value);
680 faddr->set_origin(origin); 685 faddr->set_origin(origin);
681 } 686 }
682 687
683 bool CommandLineFlags::uintxAt(char* name, size_t len, uintx* value) { 688 bool CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value) {
684 Flag* result = Flag::find_flag(name, len); 689 Flag* result = Flag::find_flag(name, len);
685 if (result == NULL) return false; 690 if (result == NULL) return false;
686 if (!result->is_uintx()) return false; 691 if (!result->is_uintx()) return false;
687 *value = result->get_uintx(); 692 *value = result->get_uintx();
688 return true; 693 return true;
689 } 694 }
690 695
691 bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin) { 696 bool CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
692 Flag* result = Flag::find_flag(name, len); 697 Flag* result = Flag::find_flag(name, len);
693 if (result == NULL) return false; 698 if (result == NULL) return false;
694 if (!result->is_uintx()) return false; 699 if (!result->is_uintx()) return false;
695 uintx old_value = result->get_uintx(); 700 uintx old_value = result->get_uintx();
696 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); 701 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
706 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin); 711 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
707 faddr->set_uintx(value); 712 faddr->set_uintx(value);
708 faddr->set_origin(origin); 713 faddr->set_origin(origin);
709 } 714 }
710 715
711 bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) { 716 bool CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value) {
712 Flag* result = Flag::find_flag(name, len); 717 Flag* result = Flag::find_flag(name, len);
713 if (result == NULL) return false; 718 if (result == NULL) return false;
714 if (!result->is_uint64_t()) return false; 719 if (!result->is_uint64_t()) return false;
715 *value = result->get_uint64_t(); 720 *value = result->get_uint64_t();
716 return true; 721 return true;
717 } 722 }
718 723
719 bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin) { 724 bool CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
720 Flag* result = Flag::find_flag(name, len); 725 Flag* result = Flag::find_flag(name, len);
721 if (result == NULL) return false; 726 if (result == NULL) return false;
722 if (!result->is_uint64_t()) return false; 727 if (!result->is_uint64_t()) return false;
723 uint64_t old_value = result->get_uint64_t(); 728 uint64_t old_value = result->get_uint64_t();
724 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); 729 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
734 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin); 739 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
735 faddr->set_uint64_t(value); 740 faddr->set_uint64_t(value);
736 faddr->set_origin(origin); 741 faddr->set_origin(origin);
737 } 742 }
738 743
739 bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) { 744 bool CommandLineFlags::doubleAt(const char* name, size_t len, double* value) {
740 Flag* result = Flag::find_flag(name, len); 745 Flag* result = Flag::find_flag(name, len);
741 if (result == NULL) return false; 746 if (result == NULL) return false;
742 if (!result->is_double()) return false; 747 if (!result->is_double()) return false;
743 *value = result->get_double(); 748 *value = result->get_double();
744 return true; 749 return true;
745 } 750 }
746 751
747 bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin) { 752 bool CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
748 Flag* result = Flag::find_flag(name, len); 753 Flag* result = Flag::find_flag(name, len);
749 if (result == NULL) return false; 754 if (result == NULL) return false;
750 if (!result->is_double()) return false; 755 if (!result->is_double()) return false;
751 double old_value = result->get_double(); 756 double old_value = result->get_double();
752 trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin); 757 trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
762 trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin); 767 trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
763 faddr->set_double(value); 768 faddr->set_double(value);
764 faddr->set_origin(origin); 769 faddr->set_origin(origin);
765 } 770 }
766 771
767 bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) { 772 bool CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value) {
768 Flag* result = Flag::find_flag(name, len); 773 Flag* result = Flag::find_flag(name, len);
769 if (result == NULL) return false; 774 if (result == NULL) return false;
770 if (!result->is_ccstr()) return false; 775 if (!result->is_ccstr()) return false;
771 *value = result->get_ccstr(); 776 *value = result->get_ccstr();
772 return true; 777 return true;
773 } 778 }
774 779
775 // Contract: Flag will make private copy of the incoming value. 780 bool CommandLineFlags::ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin) {
776 // Outgoing value is always malloc-ed, and caller MUST call free.
777 bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) {
778 Flag* result = Flag::find_flag(name, len); 781 Flag* result = Flag::find_flag(name, len);
779 if (result == NULL) return false; 782 if (result == NULL) return false;
780 if (!result->is_ccstr()) return false; 783 if (!result->is_ccstr()) return false;
781 ccstr old_value = result->get_ccstr(); 784 ccstr old_value = result->get_ccstr();
782 trace_flag_changed<EventStringFlagChanged, const char*>(name, old_value, *value, origin); 785 trace_flag_changed<EventStringFlagChanged, const char*>(name, old_value, *value, origin);
795 *value = old_value; 798 *value = old_value;
796 result->set_origin(origin); 799 result->set_origin(origin);
797 return true; 800 return true;
798 } 801 }
799 802
800 // Contract: Flag will make private copy of the incoming value.
801 void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) { 803 void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
802 Flag* faddr = address_of_flag(flag); 804 Flag* faddr = address_of_flag(flag);
803 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type"); 805 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
804 ccstr old_value = faddr->get_ccstr(); 806 ccstr old_value = faddr->get_ccstr();
805 trace_flag_changed<EventStringFlagChanged, const char*>(faddr->_name, old_value, value, origin); 807 trace_flag_changed<EventStringFlagChanged, const char*>(faddr->_name, old_value, value, origin);