< prev index next >

src/share/vm/runtime/globals.cpp

Print this page 







 753   E e;
 754   e.set_name(name);
 755   e.set_old_value(old_value);
 756   e.set_new_value(new_value);
 757   e.set_origin(origin);
 758   e.commit();
 759 }
 760 
 761 static Flag::Error get_status_error(Flag::Error status_range, Flag::Error status_constraint) {
 762   if (status_range != Flag::SUCCESS) {
 763     return status_range;
 764   } else if (status_constraint != Flag::SUCCESS) {
 765     return status_constraint;
 766   } else {
 767     return Flag::SUCCESS;
 768   }
 769 }
 770 
 771 static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool* new_value, bool verbose = true) {
 772   Flag::Error status = Flag::SUCCESS;
 773   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
 774   if (constraint != NULL) {
 775     status = constraint->apply_bool(new_value, verbose);
 776   }
 777   return status;
 778 }
 779 
 780 Flag::Error CommandLineFlags::boolAt(const char* name, size_t len, bool* value, bool allow_locked, bool return_flag) {
 781   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 782   if (result == NULL) return Flag::INVALID_FLAG;
 783   if (!result->is_bool()) return Flag::WRONG_FORMAT;
 784   *value = result->get_bool();
 785   return Flag::SUCCESS;
 786 }
 787 
 788 Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
 789   Flag* result = Flag::find_flag(name, len);
 790   if (result == NULL) return Flag::INVALID_FLAG;
 791   if (!result->is_bool()) return Flag::WRONG_FORMAT;
 792   Flag::Error check = apply_constraint_and_check_range_bool(name, value, !CommandLineFlags::finishedInitializing());
 793   if (check != Flag::SUCCESS) return check;
 794   bool old_value = result->get_bool();
 795   trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
 796   result->set_bool(*value);
 797   *value = old_value;
 798   result->set_origin(origin);
 799   return Flag::SUCCESS;
 800 }
 801 
 802 Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
 803   Flag* faddr = address_of_flag(flag);
 804   guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
 805   Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, &value);
 806   if (check != Flag::SUCCESS) return check;
 807   trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
 808   faddr->set_bool(value);
 809   faddr->set_origin(origin);
 810   return Flag::SUCCESS;
 811 }
 812 
 813 static Flag::Error apply_constraint_and_check_range_int(const char* name, int* new_value, bool verbose = true) {
 814   Flag::Error range_status = Flag::SUCCESS;
 815   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 816   if (range != NULL) {
 817     range_status = range->check_int(*new_value, verbose);
 818   }
 819   Flag::Error constraint_status = Flag::SUCCESS;
 820   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
 821   if (constraint != NULL) {
 822     constraint_status = constraint->apply_int(new_value, verbose);
 823   }
 824   return get_status_error(range_status, constraint_status);
 825 }
 826 
 827 Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
 828   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 829   if (result == NULL) return Flag::INVALID_FLAG;
 830   if (!result->is_int()) return Flag::WRONG_FORMAT;
 831   *value = result->get_int();
 832   return Flag::SUCCESS;
 833 }
 834 
 835 Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
 836   Flag* result = Flag::find_flag(name, len);
 837   if (result == NULL) return Flag::INVALID_FLAG;
 838   if (!result->is_int()) return Flag::WRONG_FORMAT;
 839   Flag::Error check = apply_constraint_and_check_range_int(name, value, !CommandLineFlags::finishedInitializing());
 840   if (check != Flag::SUCCESS) return check;
 841   int old_value = result->get_int();
 842   trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
 843   result->set_int(*value);
 844   *value = old_value;
 845   result->set_origin(origin);
 846   return Flag::SUCCESS;
 847 }
 848 
 849 Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
 850   Flag* faddr = address_of_flag(flag);
 851   guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
 852   trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
 853   faddr->set_int(value);
 854   faddr->set_origin(origin);
 855   return Flag::SUCCESS;
 856 }
 857 
 858 static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint* new_value, bool verbose = true) {
 859   Flag::Error range_status = Flag::SUCCESS;
 860   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 861   if (range != NULL) {
 862     range_status = range->check_uint(*new_value, verbose);
 863   }
 864   Flag::Error constraint_status = Flag::SUCCESS;
 865   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
 866   if (constraint != NULL) {
 867     constraint_status = constraint->apply_uint(new_value, verbose);
 868   }
 869   return get_status_error(range_status, constraint_status);
 870 }
 871 
 872 Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
 873   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 874   if (result == NULL) return Flag::INVALID_FLAG;
 875   if (!result->is_uint()) return Flag::WRONG_FORMAT;
 876   *value = result->get_uint();
 877   return Flag::SUCCESS;
 878 }
 879 
 880 Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
 881   Flag* result = Flag::find_flag(name, len);
 882   if (result == NULL) return Flag::INVALID_FLAG;
 883   if (!result->is_uint()) return Flag::WRONG_FORMAT;
 884   Flag::Error check = apply_constraint_and_check_range_uint(name, value, !CommandLineFlags::finishedInitializing());
 885   if (check != Flag::SUCCESS) return check;
 886   uint old_value = result->get_uint();
 887   trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
 888   result->set_uint(*value);
 889   *value = old_value;
 890   result->set_origin(origin);
 891   return Flag::SUCCESS;
 892 }
 893 
 894 Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
 895   Flag* faddr = address_of_flag(flag);
 896   guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
 897   trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
 898   faddr->set_uint(value);
 899   faddr->set_origin(origin);
 900   return Flag::SUCCESS;
 901 }
 902 
 903 Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
 904   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 905   if (result == NULL) return Flag::INVALID_FLAG;
 906   if (!result->is_intx()) return Flag::WRONG_FORMAT;
 907   *value = result->get_intx();
 908   return Flag::SUCCESS;
 909 }
 910 
 911 static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx* new_value, bool verbose = true) {
 912   Flag::Error range_status = Flag::SUCCESS;
 913   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 914   if (range != NULL) {
 915     range_status = range->check_intx(*new_value, verbose);
 916   }
 917   Flag::Error constraint_status = Flag::SUCCESS;
 918   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
 919   if (constraint != NULL) {
 920     constraint_status = constraint->apply_intx(new_value, verbose);
 921   }
 922   return get_status_error(range_status, constraint_status);
 923 }
 924 
 925 Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
 926   Flag* result = Flag::find_flag(name, len);
 927   if (result == NULL) return Flag::INVALID_FLAG;
 928   if (!result->is_intx()) return Flag::WRONG_FORMAT;
 929   Flag::Error check = apply_constraint_and_check_range_intx(name, value, !CommandLineFlags::finishedInitializing());
 930   if (check != Flag::SUCCESS) return check;
 931   intx old_value = result->get_intx();
 932   trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
 933   result->set_intx(*value);
 934   *value = old_value;
 935   result->set_origin(origin);
 936   return Flag::SUCCESS;
 937 }
 938 
 939 Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
 940   Flag* faddr = address_of_flag(flag);
 941   guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
 942   Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, &value);
 943   if (check != Flag::SUCCESS) return check;
 944   trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
 945   faddr->set_intx(value);
 946   faddr->set_origin(origin);
 947   return Flag::SUCCESS;
 948 }
 949 
 950 Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
 951   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 952   if (result == NULL) return Flag::INVALID_FLAG;
 953   if (!result->is_uintx()) return Flag::WRONG_FORMAT;
 954   *value = result->get_uintx();
 955   return Flag::SUCCESS;
 956 }
 957 
 958 static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx* new_value, bool verbose = true) {
 959   Flag::Error range_status = Flag::SUCCESS;
 960   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 961   if (range != NULL) {
 962     range_status = range->check_uintx(*new_value, verbose);
 963   }
 964   Flag::Error constraint_status = Flag::SUCCESS;
 965   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
 966   if (constraint != NULL) {
 967     constraint_status = constraint->apply_uintx(new_value, verbose);
 968   }
 969   return get_status_error(range_status, constraint_status);
 970 }
 971 
 972 Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
 973   Flag* result = Flag::find_flag(name, len);
 974   if (result == NULL) return Flag::INVALID_FLAG;
 975   if (!result->is_uintx()) return Flag::WRONG_FORMAT;
 976   Flag::Error check = apply_constraint_and_check_range_uintx(name, value, !CommandLineFlags::finishedInitializing());
 977   if (check != Flag::SUCCESS) return check;
 978   uintx old_value = result->get_uintx();
 979   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
 980   result->set_uintx(*value);
 981   *value = old_value;
 982   result->set_origin(origin);
 983   return Flag::SUCCESS;
 984 }
 985 
 986 Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
 987   Flag* faddr = address_of_flag(flag);
 988   guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
 989   Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, &value);
 990   if (check != Flag::SUCCESS) return check;
 991   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
 992   faddr->set_uintx(value);
 993   faddr->set_origin(origin);
 994   return Flag::SUCCESS;
 995 }
 996 
 997 Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
 998   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 999   if (result == NULL) return Flag::INVALID_FLAG;
1000   if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1001   *value = result->get_uint64_t();
1002   return Flag::SUCCESS;
1003 }
1004 
1005 static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t* new_value, bool verbose = true) {
1006   Flag::Error range_status = Flag::SUCCESS;
1007   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1008   if (range != NULL) {
1009     range_status = range->check_uint64_t(*new_value, verbose);
1010   }
1011   Flag::Error constraint_status = Flag::SUCCESS;
1012   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
1013   if (constraint != NULL) {
1014     constraint_status = constraint->apply_uint64_t(new_value, verbose);
1015   }
1016   return get_status_error(range_status, constraint_status);
1017 }
1018 
1019 Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
1020   Flag* result = Flag::find_flag(name, len);
1021   if (result == NULL) return Flag::INVALID_FLAG;
1022   if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1023   Flag::Error check = apply_constraint_and_check_range_uint64_t(name, value, !CommandLineFlags::finishedInitializing());
1024   if (check != Flag::SUCCESS) return check;
1025   uint64_t old_value = result->get_uint64_t();
1026   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1027   result->set_uint64_t(*value);
1028   *value = old_value;
1029   result->set_origin(origin);
1030   return Flag::SUCCESS;
1031 }
1032 
1033 Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
1034   Flag* faddr = address_of_flag(flag);
1035   guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
1036   Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, &value);
1037   if (check != Flag::SUCCESS) return check;
1038   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
1039   faddr->set_uint64_t(value);
1040   faddr->set_origin(origin);
1041   return Flag::SUCCESS;
1042 }
1043 
1044 Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) {
1045   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1046   if (result == NULL) return Flag::INVALID_FLAG;
1047   if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1048   *value = result->get_size_t();
1049   return Flag::SUCCESS;
1050 }
1051 
1052 static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t* new_value, bool verbose = true) {
1053   Flag::Error range_status = Flag::SUCCESS;
1054   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1055   if (range != NULL) {
1056     range_status = range->check_size_t(*new_value, verbose);
1057   }
1058   Flag::Error constraint_status = Flag::SUCCESS;
1059   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
1060   if (constraint != NULL) {
1061     constraint_status = constraint->apply_size_t(new_value, verbose);
1062   }
1063   return get_status_error(range_status, constraint_status);
1064 }
1065 
1066 Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
1067   Flag* result = Flag::find_flag(name, len);
1068   if (result == NULL) return Flag::INVALID_FLAG;
1069   if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1070   Flag::Error check = apply_constraint_and_check_range_size_t(name, value, !CommandLineFlags::finishedInitializing());
1071   if (check != Flag::SUCCESS) return check;
1072   size_t old_value = result->get_size_t();
1073   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1074   result->set_size_t(*value);
1075   *value = old_value;
1076   result->set_origin(origin);
1077   return Flag::SUCCESS;
1078 }
1079 
1080 Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
1081   Flag* faddr = address_of_flag(flag);
1082   guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
1083   Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, &value);
1084   if (check != Flag::SUCCESS) return check;
1085   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
1086   faddr->set_size_t(value);
1087   faddr->set_origin(origin);
1088   return Flag::SUCCESS;
1089 }
1090 
1091 Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
1092   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1093   if (result == NULL) return Flag::INVALID_FLAG;
1094   if (!result->is_double()) return Flag::WRONG_FORMAT;
1095   *value = result->get_double();
1096   return Flag::SUCCESS;
1097 }
1098 
1099 static Flag::Error apply_constraint_and_check_range_double(const char* name, double* new_value, bool verbose = true) {
1100   Flag::Error range_status = Flag::SUCCESS;
1101   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1102   if (range != NULL) {
1103     range_status = range->check_double(*new_value, verbose);
1104   }
1105   Flag::Error constraint_status = Flag::SUCCESS;
1106   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
1107   if (constraint != NULL) {
1108     constraint_status = constraint->apply_double(new_value, verbose);
1109   }
1110   return get_status_error(range_status, constraint_status);
1111 }
1112 
1113 Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
1114   Flag* result = Flag::find_flag(name, len);
1115   if (result == NULL) return Flag::INVALID_FLAG;
1116   if (!result->is_double()) return Flag::WRONG_FORMAT;
1117   Flag::Error check = apply_constraint_and_check_range_double(name, value, !CommandLineFlags::finishedInitializing());
1118   if (check != Flag::SUCCESS) return check;
1119   double old_value = result->get_double();
1120   trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
1121   result->set_double(*value);
1122   *value = old_value;
1123   result->set_origin(origin);
1124   return Flag::SUCCESS;
1125 }
1126 
1127 Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
1128   Flag* faddr = address_of_flag(flag);
1129   guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
1130   Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, &value, !CommandLineFlags::finishedInitializing());
1131   if (check != Flag::SUCCESS) return check;
1132   trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
1133   faddr->set_double(value);
1134   faddr->set_origin(origin);
1135   return Flag::SUCCESS;
1136 }
1137 
1138 Flag::Error CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) {
1139   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1140   if (result == NULL) return Flag::INVALID_FLAG;
1141   if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1142   *value = result->get_ccstr();
1143   return Flag::SUCCESS;
1144 }
1145 
1146 Flag::Error CommandLineFlags::ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin) {
1147   Flag* result = Flag::find_flag(name, len);
1148   if (result == NULL) return Flag::INVALID_FLAG;
1149   if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1150   ccstr old_value = result->get_ccstr();


1193   const size_t length = Flag::numFlags - 1;
1194 
1195   // Sort
1196   Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
1197   for (size_t i = 0; i < length; i++) {
1198     array[i] = &flagTable[i];
1199   }
1200   qsort(array, length, sizeof(Flag*), compare_flags);
1201 
1202   // Print
1203   for (size_t i = 0; i < length; i++) {
1204     if (array[i]->get_origin() /* naked field! */) {
1205       array[i]->print_as_flag(out);
1206       out->print(" ");
1207     }
1208   }
1209   out->cr();
1210   FREE_C_HEAP_ARRAY(Flag*, array);
1211 }
1212 
1213 bool CommandLineFlags::_finished_initializing = false;

































1214 
1215 bool CommandLineFlags::check_all_ranges_and_constraints() {
1216 
1217 //#define PRINT_RANGES_AND_CONSTRAINTS_SIZES
1218 #ifdef PRINT_RANGES_AND_CONSTRAINTS_SIZES
1219   {
1220     size_t size_ranges = sizeof(CommandLineFlagRangeList);
1221     for (int i=0; i<CommandLineFlagRangeList::length(); i++) {
1222       size_ranges += sizeof(CommandLineFlagRange);
1223       CommandLineFlagRange* range = CommandLineFlagRangeList::at(i);
1224       const char* name = range->name();
1225       Flag* flag = Flag::find_flag(name, strlen(name), true, true);
1226       if (flag->is_intx()) {
1227         size_ranges += 2*sizeof(intx);
1228         size_ranges += sizeof(CommandLineFlagRange*);
1229       } else if (flag->is_uintx()) {
1230         size_ranges += 2*sizeof(uintx);
1231         size_ranges += sizeof(CommandLineFlagRange*);
1232       } else if (flag->is_uint64_t()) {
1233         size_ranges += 2*sizeof(uint64_t);
1234         size_ranges += sizeof(CommandLineFlagRange*);
1235       } else if (flag->is_size_t()) {


1258         size_constraints += sizeof(CommandLineFlagConstraint*);
1259       } else if (flag->is_uintx()) {
1260         size_constraints += sizeof(CommandLineFlagConstraintFunc_uintx);
1261         size_constraints += sizeof(CommandLineFlagConstraint*);
1262       } else if (flag->is_uint64_t()) {
1263         size_constraints += sizeof(CommandLineFlagConstraintFunc_uint64_t);
1264         size_constraints += sizeof(CommandLineFlagConstraint*);
1265       } else if (flag->is_size_t()) {
1266         size_constraints += sizeof(CommandLineFlagConstraintFunc_size_t);
1267         size_constraints += sizeof(CommandLineFlagConstraint*);
1268       } else if (flag->is_double()) {
1269         size_constraints += sizeof(CommandLineFlagConstraintFunc_double);
1270         size_constraints += sizeof(CommandLineFlagConstraint*);
1271       }
1272     }
1273     fprintf(stderr, "Size of %d constraints: " SIZE_FORMAT " bytes\n",
1274             CommandLineFlagConstraintList::length(), size_constraints);
1275   }
1276 #endif // PRINT_RANGES_AND_CONSTRAINTS_SIZES
1277 
1278   _finished_initializing = true;
1279 

1280   bool status = true;
1281   for (int i=0; i<CommandLineFlagRangeList::length(); i++) {
1282     CommandLineFlagRange* range = CommandLineFlagRangeList::at(i);
1283     const char* name = range->name();
1284     Flag* flag = Flag::find_flag(name, strlen(name), true, true);
1285     if (flag != NULL) {
1286       if (flag->is_intx()) {
1287         intx value = flag->get_intx();
1288         if (range->check_intx(value, true) != Flag::SUCCESS) status = false;
1289       } else if (flag->is_uintx()) {
1290         uintx value = flag->get_uintx();
1291         if (range->check_uintx(value, true) != Flag::SUCCESS) status = false;
1292       } else if (flag->is_uint64_t()) {
1293         uint64_t value = flag->get_uint64_t();
1294         if (range->check_uint64_t(value, true) != Flag::SUCCESS) status = false;
1295       } else if (flag->is_size_t()) {
1296         size_t value = flag->get_size_t();
1297         if (range->check_size_t(value, true) != Flag::SUCCESS) status = false;
1298       } else if (flag->is_double()) {
1299         double value = flag->get_double();
1300         if (range->check_double(value, true) != Flag::SUCCESS) status = false;
1301       }
1302     }
1303   }
1304   for (int i=0; i<CommandLineFlagConstraintList::length(); i++) {
1305     CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::at(i);
1306     const char*name = constraint->name();
1307     Flag* flag = Flag::find_flag(name, strlen(name), true, true);
1308     if (flag != NULL) {
1309       if (flag->is_bool()) {
1310         bool value = flag->get_bool();
1311         if (constraint->apply_bool(&value, true) != Flag::SUCCESS) status = false;
1312       } else if (flag->is_intx()) {
1313         intx value = flag->get_intx();
1314         if (constraint->apply_intx(&value, true) != Flag::SUCCESS) status = false;
1315       } else if (flag->is_uintx()) {
1316         uintx value = flag->get_uintx();
1317         if (constraint->apply_uintx(&value, true) != Flag::SUCCESS) status = false;
1318       } else if (flag->is_uint64_t()) {
1319         uint64_t value = flag->get_uint64_t();
1320         if (constraint->apply_uint64_t(&value, true) != Flag::SUCCESS) status = false;
1321       } else if (flag->is_size_t()) {
1322         size_t value = flag->get_size_t();
1323         if (constraint->apply_size_t(&value, true) != Flag::SUCCESS) status = false;
1324       } else if (flag->is_double()) {
1325         double value = flag->get_double();
1326         if (constraint->apply_double(&value, true) != Flag::SUCCESS) status = false;
1327       }
1328     }
1329   }
1330 
1331   Arguments::post_final_range_and_constraint_check(status);
1332 
1333   return status;







1334 }
1335 
1336 #ifndef PRODUCT
1337 
1338 void CommandLineFlags::verify() {
1339   assert(Arguments::check_vm_args_consistency(), "Some flag settings conflict");
1340 }
1341 
1342 #endif // PRODUCT
1343 
1344 #define ONLY_PRINT_PRODUCT_FLAGS
1345 
1346 void CommandLineFlags::printFlags(outputStream* out, bool withComments, bool printRanges) {
1347   // Print the flags sorted by name
1348   // note: this method is called before the thread structure is in place
1349   //       which means resource allocation cannot be used.
1350 
1351   // The last entry is the null entry.
1352   const size_t length = Flag::numFlags - 1;
1353 






 753   E e;
 754   e.set_name(name);
 755   e.set_old_value(old_value);
 756   e.set_new_value(new_value);
 757   e.set_origin(origin);
 758   e.commit();
 759 }
 760 
 761 static Flag::Error get_status_error(Flag::Error status_range, Flag::Error status_constraint) {
 762   if (status_range != Flag::SUCCESS) {
 763     return status_range;
 764   } else if (status_constraint != Flag::SUCCESS) {
 765     return status_constraint;
 766   } else {
 767     return Flag::SUCCESS;
 768   }
 769 }
 770 
 771 static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool* new_value, bool verbose = true) {
 772   Flag::Error status = Flag::SUCCESS;
 773   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
 774   if (constraint != NULL) {
 775     status = constraint->apply_bool(new_value, verbose);
 776   }
 777   return status;
 778 }
 779 
 780 Flag::Error CommandLineFlags::boolAt(const char* name, size_t len, bool* value, bool allow_locked, bool return_flag) {
 781   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 782   if (result == NULL) return Flag::INVALID_FLAG;
 783   if (!result->is_bool()) return Flag::WRONG_FORMAT;
 784   *value = result->get_bool();
 785   return Flag::SUCCESS;
 786 }
 787 
 788 Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
 789   Flag* result = Flag::find_flag(name, len);
 790   if (result == NULL) return Flag::INVALID_FLAG;
 791   if (!result->is_bool()) return Flag::WRONG_FORMAT;
 792   Flag::Error check = apply_constraint_and_check_range_bool(name, value, !CommandLineFlagConstraintList::validated_after_parse());
 793   if (check != Flag::SUCCESS) return check;
 794   bool old_value = result->get_bool();
 795   trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
 796   result->set_bool(*value);
 797   *value = old_value;
 798   result->set_origin(origin);
 799   return Flag::SUCCESS;
 800 }
 801 
 802 Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
 803   Flag* faddr = address_of_flag(flag);
 804   guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
 805   Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, &value);
 806   if (check != Flag::SUCCESS) return check;
 807   trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
 808   faddr->set_bool(value);
 809   faddr->set_origin(origin);
 810   return Flag::SUCCESS;
 811 }
 812 
 813 static Flag::Error apply_constraint_and_check_range_int(const char* name, int* new_value, bool verbose = true) {
 814   Flag::Error range_status = Flag::SUCCESS;
 815   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 816   if (range != NULL) {
 817     range_status = range->check_int(*new_value, verbose);
 818   }
 819   Flag::Error constraint_status = Flag::SUCCESS;
 820   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
 821   if (constraint != NULL) {
 822     constraint_status = constraint->apply_int(new_value, verbose);
 823   }
 824   return get_status_error(range_status, constraint_status);
 825 }
 826 
 827 Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
 828   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 829   if (result == NULL) return Flag::INVALID_FLAG;
 830   if (!result->is_int()) return Flag::WRONG_FORMAT;
 831   *value = result->get_int();
 832   return Flag::SUCCESS;
 833 }
 834 
 835 Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
 836   Flag* result = Flag::find_flag(name, len);
 837   if (result == NULL) return Flag::INVALID_FLAG;
 838   if (!result->is_int()) return Flag::WRONG_FORMAT;
 839   Flag::Error check = apply_constraint_and_check_range_int(name, value, !CommandLineFlagConstraintList::validated_after_parse());
 840   if (check != Flag::SUCCESS) return check;
 841   int old_value = result->get_int();
 842   trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
 843   result->set_int(*value);
 844   *value = old_value;
 845   result->set_origin(origin);
 846   return Flag::SUCCESS;
 847 }
 848 
 849 Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
 850   Flag* faddr = address_of_flag(flag);
 851   guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
 852   trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
 853   faddr->set_int(value);
 854   faddr->set_origin(origin);
 855   return Flag::SUCCESS;
 856 }
 857 
 858 static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint* new_value, bool verbose = true) {
 859   Flag::Error range_status = Flag::SUCCESS;
 860   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 861   if (range != NULL) {
 862     range_status = range->check_uint(*new_value, verbose);
 863   }
 864   Flag::Error constraint_status = Flag::SUCCESS;
 865   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
 866   if (constraint != NULL) {
 867     constraint_status = constraint->apply_uint(new_value, verbose);
 868   }
 869   return get_status_error(range_status, constraint_status);
 870 }
 871 
 872 Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
 873   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 874   if (result == NULL) return Flag::INVALID_FLAG;
 875   if (!result->is_uint()) return Flag::WRONG_FORMAT;
 876   *value = result->get_uint();
 877   return Flag::SUCCESS;
 878 }
 879 
 880 Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
 881   Flag* result = Flag::find_flag(name, len);
 882   if (result == NULL) return Flag::INVALID_FLAG;
 883   if (!result->is_uint()) return Flag::WRONG_FORMAT;
 884   Flag::Error check = apply_constraint_and_check_range_uint(name, value, !CommandLineFlagConstraintList::validated_after_parse());
 885   if (check != Flag::SUCCESS) return check;
 886   uint old_value = result->get_uint();
 887   trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
 888   result->set_uint(*value);
 889   *value = old_value;
 890   result->set_origin(origin);
 891   return Flag::SUCCESS;
 892 }
 893 
 894 Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
 895   Flag* faddr = address_of_flag(flag);
 896   guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
 897   trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
 898   faddr->set_uint(value);
 899   faddr->set_origin(origin);
 900   return Flag::SUCCESS;
 901 }
 902 
 903 Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
 904   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 905   if (result == NULL) return Flag::INVALID_FLAG;
 906   if (!result->is_intx()) return Flag::WRONG_FORMAT;
 907   *value = result->get_intx();
 908   return Flag::SUCCESS;
 909 }
 910 
 911 static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx* new_value, bool verbose = true) {
 912   Flag::Error range_status = Flag::SUCCESS;
 913   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 914   if (range != NULL) {
 915     range_status = range->check_intx(*new_value, verbose);
 916   }
 917   Flag::Error constraint_status = Flag::SUCCESS;
 918   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
 919   if (constraint != NULL) {
 920     constraint_status = constraint->apply_intx(new_value, verbose);
 921   }
 922   return get_status_error(range_status, constraint_status);
 923 }
 924 
 925 Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
 926   Flag* result = Flag::find_flag(name, len);
 927   if (result == NULL) return Flag::INVALID_FLAG;
 928   if (!result->is_intx()) return Flag::WRONG_FORMAT;
 929   Flag::Error check = apply_constraint_and_check_range_intx(name, value, !CommandLineFlagConstraintList::validated_after_parse());
 930   if (check != Flag::SUCCESS) return check;
 931   intx old_value = result->get_intx();
 932   trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
 933   result->set_intx(*value);
 934   *value = old_value;
 935   result->set_origin(origin);
 936   return Flag::SUCCESS;
 937 }
 938 
 939 Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
 940   Flag* faddr = address_of_flag(flag);
 941   guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
 942   Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, &value);
 943   if (check != Flag::SUCCESS) return check;
 944   trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
 945   faddr->set_intx(value);
 946   faddr->set_origin(origin);
 947   return Flag::SUCCESS;
 948 }
 949 
 950 Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
 951   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 952   if (result == NULL) return Flag::INVALID_FLAG;
 953   if (!result->is_uintx()) return Flag::WRONG_FORMAT;
 954   *value = result->get_uintx();
 955   return Flag::SUCCESS;
 956 }
 957 
 958 static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx* new_value, bool verbose = true) {
 959   Flag::Error range_status = Flag::SUCCESS;
 960   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 961   if (range != NULL) {
 962     range_status = range->check_uintx(*new_value, verbose);
 963   }
 964   Flag::Error constraint_status = Flag::SUCCESS;
 965   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
 966   if (constraint != NULL) {
 967     constraint_status = constraint->apply_uintx(new_value, verbose);
 968   }
 969   return get_status_error(range_status, constraint_status);
 970 }
 971 
 972 Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
 973   Flag* result = Flag::find_flag(name, len);
 974   if (result == NULL) return Flag::INVALID_FLAG;
 975   if (!result->is_uintx()) return Flag::WRONG_FORMAT;
 976   Flag::Error check = apply_constraint_and_check_range_uintx(name, value, !CommandLineFlagConstraintList::validated_after_parse());
 977   if (check != Flag::SUCCESS) return check;
 978   uintx old_value = result->get_uintx();
 979   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
 980   result->set_uintx(*value);
 981   *value = old_value;
 982   result->set_origin(origin);
 983   return Flag::SUCCESS;
 984 }
 985 
 986 Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
 987   Flag* faddr = address_of_flag(flag);
 988   guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
 989   Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, &value);
 990   if (check != Flag::SUCCESS) return check;
 991   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
 992   faddr->set_uintx(value);
 993   faddr->set_origin(origin);
 994   return Flag::SUCCESS;
 995 }
 996 
 997 Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
 998   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 999   if (result == NULL) return Flag::INVALID_FLAG;
1000   if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1001   *value = result->get_uint64_t();
1002   return Flag::SUCCESS;
1003 }
1004 
1005 static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t* new_value, bool verbose = true) {
1006   Flag::Error range_status = Flag::SUCCESS;
1007   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1008   if (range != NULL) {
1009     range_status = range->check_uint64_t(*new_value, verbose);
1010   }
1011   Flag::Error constraint_status = Flag::SUCCESS;
1012   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1013   if (constraint != NULL) {
1014     constraint_status = constraint->apply_uint64_t(new_value, verbose);
1015   }
1016   return get_status_error(range_status, constraint_status);
1017 }
1018 
1019 Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
1020   Flag* result = Flag::find_flag(name, len);
1021   if (result == NULL) return Flag::INVALID_FLAG;
1022   if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1023   Flag::Error check = apply_constraint_and_check_range_uint64_t(name, value, !CommandLineFlagConstraintList::validated_after_parse());
1024   if (check != Flag::SUCCESS) return check;
1025   uint64_t old_value = result->get_uint64_t();
1026   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1027   result->set_uint64_t(*value);
1028   *value = old_value;
1029   result->set_origin(origin);
1030   return Flag::SUCCESS;
1031 }
1032 
1033 Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
1034   Flag* faddr = address_of_flag(flag);
1035   guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
1036   Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, &value);
1037   if (check != Flag::SUCCESS) return check;
1038   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
1039   faddr->set_uint64_t(value);
1040   faddr->set_origin(origin);
1041   return Flag::SUCCESS;
1042 }
1043 
1044 Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) {
1045   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1046   if (result == NULL) return Flag::INVALID_FLAG;
1047   if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1048   *value = result->get_size_t();
1049   return Flag::SUCCESS;
1050 }
1051 
1052 static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t* new_value, bool verbose = true) {
1053   Flag::Error range_status = Flag::SUCCESS;
1054   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1055   if (range != NULL) {
1056     range_status = range->check_size_t(*new_value, verbose);
1057   }
1058   Flag::Error constraint_status = Flag::SUCCESS;
1059   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1060   if (constraint != NULL) {
1061     constraint_status = constraint->apply_size_t(new_value, verbose);
1062   }
1063   return get_status_error(range_status, constraint_status);
1064 }
1065 
1066 Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
1067   Flag* result = Flag::find_flag(name, len);
1068   if (result == NULL) return Flag::INVALID_FLAG;
1069   if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1070   Flag::Error check = apply_constraint_and_check_range_size_t(name, value, !CommandLineFlagConstraintList::validated_after_parse());
1071   if (check != Flag::SUCCESS) return check;
1072   size_t old_value = result->get_size_t();
1073   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1074   result->set_size_t(*value);
1075   *value = old_value;
1076   result->set_origin(origin);
1077   return Flag::SUCCESS;
1078 }
1079 
1080 Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
1081   Flag* faddr = address_of_flag(flag);
1082   guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
1083   Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, &value);
1084   if (check != Flag::SUCCESS) return check;
1085   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
1086   faddr->set_size_t(value);
1087   faddr->set_origin(origin);
1088   return Flag::SUCCESS;
1089 }
1090 
1091 Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
1092   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1093   if (result == NULL) return Flag::INVALID_FLAG;
1094   if (!result->is_double()) return Flag::WRONG_FORMAT;
1095   *value = result->get_double();
1096   return Flag::SUCCESS;
1097 }
1098 
1099 static Flag::Error apply_constraint_and_check_range_double(const char* name, double* new_value, bool verbose = true) {
1100   Flag::Error range_status = Flag::SUCCESS;
1101   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1102   if (range != NULL) {
1103     range_status = range->check_double(*new_value, verbose);
1104   }
1105   Flag::Error constraint_status = Flag::SUCCESS;
1106   CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1107   if (constraint != NULL) {
1108     constraint_status = constraint->apply_double(new_value, verbose);
1109   }
1110   return get_status_error(range_status, constraint_status);
1111 }
1112 
1113 Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
1114   Flag* result = Flag::find_flag(name, len);
1115   if (result == NULL) return Flag::INVALID_FLAG;
1116   if (!result->is_double()) return Flag::WRONG_FORMAT;
1117   Flag::Error check = apply_constraint_and_check_range_double(name, value, !CommandLineFlagConstraintList::validated_after_parse());
1118   if (check != Flag::SUCCESS) return check;
1119   double old_value = result->get_double();
1120   trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
1121   result->set_double(*value);
1122   *value = old_value;
1123   result->set_origin(origin);
1124   return Flag::SUCCESS;
1125 }
1126 
1127 Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
1128   Flag* faddr = address_of_flag(flag);
1129   guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
1130   Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, &value);
1131   if (check != Flag::SUCCESS) return check;
1132   trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
1133   faddr->set_double(value);
1134   faddr->set_origin(origin);
1135   return Flag::SUCCESS;
1136 }
1137 
1138 Flag::Error CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) {
1139   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1140   if (result == NULL) return Flag::INVALID_FLAG;
1141   if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1142   *value = result->get_ccstr();
1143   return Flag::SUCCESS;
1144 }
1145 
1146 Flag::Error CommandLineFlags::ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin) {
1147   Flag* result = Flag::find_flag(name, len);
1148   if (result == NULL) return Flag::INVALID_FLAG;
1149   if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1150   ccstr old_value = result->get_ccstr();


1193   const size_t length = Flag::numFlags - 1;
1194 
1195   // Sort
1196   Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
1197   for (size_t i = 0; i < length; i++) {
1198     array[i] = &flagTable[i];
1199   }
1200   qsort(array, length, sizeof(Flag*), compare_flags);
1201 
1202   // Print
1203   for (size_t i = 0; i < length; i++) {
1204     if (array[i]->get_origin() /* naked field! */) {
1205       array[i]->print_as_flag(out);
1206       out->print(" ");
1207     }
1208   }
1209   out->cr();
1210   FREE_C_HEAP_ARRAY(Flag*, array);
1211 }
1212 
1213 // Check constraints for specific constraint type.
1214 static bool check_constraints(CommandLineFlagConstraint::ConstraintType constraint_type) {
1215   bool status = true;
1216 
1217   for (int i=0; i<CommandLineFlagConstraintList::length(); i++) {
1218     CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::at(i);
1219     if (constraint_type != constraint->type()) continue;
1220     const char*name = constraint->name();
1221     Flag* flag = Flag::find_flag(name, strlen(name), true, true);
1222     if (flag != NULL) {
1223       if (flag->is_bool()) {
1224         bool value = flag->get_bool();
1225         if (constraint->apply_bool(&value, true) != Flag::SUCCESS) status = false;
1226       } else if (flag->is_intx()) {
1227         intx value = flag->get_intx();
1228         if (constraint->apply_intx(&value, true) != Flag::SUCCESS) status = false;
1229       } else if (flag->is_uintx()) {
1230         uintx value = flag->get_uintx();
1231         if (constraint->apply_uintx(&value, true) != Flag::SUCCESS) status = false;
1232       } else if (flag->is_uint64_t()) {
1233         uint64_t value = flag->get_uint64_t();
1234         if (constraint->apply_uint64_t(&value, true) != Flag::SUCCESS) status = false;
1235       } else if (flag->is_size_t()) {
1236         size_t value = flag->get_size_t();
1237         if (constraint->apply_size_t(&value, true) != Flag::SUCCESS) status = false;
1238       } else if (flag->is_double()) {
1239         double value = flag->get_double();
1240         if (constraint->apply_double(&value, true) != Flag::SUCCESS) status = false;
1241       }
1242     }
1243   }
1244 
1245   return status;
1246 }
1247 
1248 bool CommandLineFlags::check_ranges_and_constraints_of_after_parse() {
1249 
1250 //#define PRINT_RANGES_AND_CONSTRAINTS_SIZES
1251 #ifdef PRINT_RANGES_AND_CONSTRAINTS_SIZES
1252   {
1253     size_t size_ranges = sizeof(CommandLineFlagRangeList);
1254     for (int i=0; i<CommandLineFlagRangeList::length(); i++) {
1255       size_ranges += sizeof(CommandLineFlagRange);
1256       CommandLineFlagRange* range = CommandLineFlagRangeList::at(i);
1257       const char* name = range->name();
1258       Flag* flag = Flag::find_flag(name, strlen(name), true, true);
1259       if (flag->is_intx()) {
1260         size_ranges += 2*sizeof(intx);
1261         size_ranges += sizeof(CommandLineFlagRange*);
1262       } else if (flag->is_uintx()) {
1263         size_ranges += 2*sizeof(uintx);
1264         size_ranges += sizeof(CommandLineFlagRange*);
1265       } else if (flag->is_uint64_t()) {
1266         size_ranges += 2*sizeof(uint64_t);
1267         size_ranges += sizeof(CommandLineFlagRange*);
1268       } else if (flag->is_size_t()) {


1291         size_constraints += sizeof(CommandLineFlagConstraint*);
1292       } else if (flag->is_uintx()) {
1293         size_constraints += sizeof(CommandLineFlagConstraintFunc_uintx);
1294         size_constraints += sizeof(CommandLineFlagConstraint*);
1295       } else if (flag->is_uint64_t()) {
1296         size_constraints += sizeof(CommandLineFlagConstraintFunc_uint64_t);
1297         size_constraints += sizeof(CommandLineFlagConstraint*);
1298       } else if (flag->is_size_t()) {
1299         size_constraints += sizeof(CommandLineFlagConstraintFunc_size_t);
1300         size_constraints += sizeof(CommandLineFlagConstraint*);
1301       } else if (flag->is_double()) {
1302         size_constraints += sizeof(CommandLineFlagConstraintFunc_double);
1303         size_constraints += sizeof(CommandLineFlagConstraint*);
1304       }
1305     }
1306     fprintf(stderr, "Size of %d constraints: " SIZE_FORMAT " bytes\n",
1307             CommandLineFlagConstraintList::length(), size_constraints);
1308   }
1309 #endif // PRINT_RANGES_AND_CONSTRAINTS_SIZES
1310 
1311   CommandLineFlagConstraintList::set_validating_type(CommandLineFlagConstraint::AfterParse);
1312 
1313   // Check ranges.
1314   bool status = true;
1315   for (int i=0; i<CommandLineFlagRangeList::length(); i++) {
1316     CommandLineFlagRange* range = CommandLineFlagRangeList::at(i);
1317     const char* name = range->name();
1318     Flag* flag = Flag::find_flag(name, strlen(name), true, true);
1319     if (flag != NULL) {
1320       if (flag->is_intx()) {
1321         intx value = flag->get_intx();
1322         if (range->check_intx(value, true) != Flag::SUCCESS) status = false;
1323       } else if (flag->is_uintx()) {
1324         uintx value = flag->get_uintx();
1325         if (range->check_uintx(value, true) != Flag::SUCCESS) status = false;
1326       } else if (flag->is_uint64_t()) {
1327         uint64_t value = flag->get_uint64_t();
1328         if (range->check_uint64_t(value, true) != Flag::SUCCESS) status = false;
1329       } else if (flag->is_size_t()) {
1330         size_t value = flag->get_size_t();
1331         if (range->check_size_t(value, true) != Flag::SUCCESS) status = false;
1332       } else if (flag->is_double()) {
1333         double value = flag->get_double();
1334         if (range->check_double(value, true) != Flag::SUCCESS) status = false;
1335       }
1336     }
1337   }
1338 
1339   // Check constraints of 'AfterParse'.
1340   status = check_constraints(CommandLineFlagConstraint::AfterParse);























1341 
1342   Arguments::post_final_range_and_constraint_check(status);
1343 
1344   return status;
1345 }
1346 
1347 
1348 bool CommandLineFlags::check_constraints_of_after_memory_init() {
1349   CommandLineFlagConstraintList::set_validating_type(CommandLineFlagConstraint::AfterMemoryInit);
1350 
1351   return check_constraints(CommandLineFlagConstraint::AfterMemoryInit);
1352 }
1353 
1354 #ifndef PRODUCT
1355 
1356 void CommandLineFlags::verify() {
1357   assert(Arguments::check_vm_args_consistency(), "Some flag settings conflict");
1358 }
1359 
1360 #endif // PRODUCT
1361 
1362 #define ONLY_PRINT_PRODUCT_FLAGS
1363 
1364 void CommandLineFlags::printFlags(outputStream* out, bool withComments, bool printRanges) {
1365   // Print the flags sorted by name
1366   // note: this method is called before the thread structure is in place
1367   //       which means resource allocation cannot be used.
1368 
1369   // The last entry is the null entry.
1370   const size_t length = Flag::numFlags - 1;
1371 







< prev index next >