Datasets:

AISE-TUDelft

/

Capybara

like 3

Follow

AISE research lab at TU Delft 44

[ "org_bluez_device1_set_name:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_name", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"name\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_rssi:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_rssi", "(", "OrgBluezDevice1", "*", "object", ",", "gint16", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"rssi\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_gatt_services:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_gatt_services", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "const", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"gatt-services\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_paired:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_paired", "(", "OrgBluezDevice1", "*", "object", ",", "gboolean", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"paired\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_address_type:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_address_type", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"address-type\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_trusted:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_trusted", "(", "OrgBluezDevice1", "*", "object", ",", "gboolean", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"trusted\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_blocked:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_blocked", "(", "OrgBluezDevice1", "*", "object", ",", "gboolean", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"blocked\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_services_resolved:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_services_resolved", "(", "OrgBluezDevice1", "*", "object", ",", "gboolean", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"services-resolved\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_legacy_pairing:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_legacy_pairing", "(", "OrgBluezDevice1", "*", "object", ",", "gboolean", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"legacy-pairing\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_address:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_address", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"address\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_connected:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_connected", "(", "OrgBluezDevice1", "*", "object", ",", "gboolean", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"connected\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_class:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_class", "(", "OrgBluezDevice1", "*", "object", ",", "guint", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"class\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_uuids:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_uuids", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "const", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"uuids\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_tx_power:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_tx_power", "(", "OrgBluezDevice1", "*", "object", ",", "gint16", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"tx-power\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_adapter:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_adapter", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"adapter\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_manufacturer_data:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_manufacturer_data", "(", "OrgBluezDevice1", "*", "object", ",", "GVariant", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"manufacturer-data\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_modalias:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_modalias", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"modalias\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_appearance:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_appearance", "(", "OrgBluezDevice1", "*", "object", ",", "guint16", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"appearance\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_icon:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_icon", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"icon\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "org_bluez_device1_set_alias:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_alias", "(", "OrgBluezDevice1", "*", "object", ",", "const", "gchar", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"alias\"", ",", "value", ",", "NULL", ")", ";", "}'" ]

[ "Putting", "an", "#include", "here", "for", "EbIntraPrediction_SSSE3" ]

[ "'EB_EXTERN", "void", "IntraModeDCChroma16bit_SSSE3_INTRIN", "(", "const", "EB_U32", "size", ",", "//input", "parameter,", "denotes", "the", "size", "of", "the", "current", "PU", "const", "EB_U16", "*", "refSamples", ",", "//input", "parameter,", "pointer", "to", "the", "reference", "samples", "EB_U16", "*", "predictionPtr", ",", "//output", "parameter,", "pointer", "to", "the", "prediction", "const", "EB_U32", "predictionBufferStride", ",", "//input", "parameter,", "denotes", "the", "stride", "for", "the", "prediction", "ptr", "const", "EB_BOOL", "skip", ")", "//skip", "half", "rows", "{", "EB_U32", "topOffset", "=", "(", "size", "<<", "1", ")", "+", "1", ";", "EB_U32", "pStride", "=", "skip", "?", "(", "predictionBufferStride", "<<", "1", ")", ":", "predictionBufferStride", ";", "if", "(", "size", "==", "4", ")", "{", "__m128i", "sum", "=", "_mm_setr_epi16", "(", "4", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadl_epi64", "(", "(", "__m128i", "*", ")", "refSamples", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadl_epi64", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "topOffset", ")", ")", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_srli_epi16", "(", "sum", ",", "3", ")", ";", "sum", "=", "_mm_unpacklo_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_unpacklo_epi32", "(", "sum", ",", "sum", ")", ";", "_mm_storel_epi64", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "predictionPtr", "+=", "pStride", ";", "_mm_storel_epi64", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "if", "(", "!", "skip", ")", "{", "predictionPtr", "+=", "pStride", ";", "_mm_storel_epi64", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "predictionPtr", "+=", "pStride", ";", "_mm_storel_epi64", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "size", "==", "8", ")", "{", "__m128i", "sum", "=", "_mm_setr_epi16", "(", "8", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "refSamples", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "topOffset", ")", ")", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_srli_epi16", "(", "sum", ",", "4", ")", ";", "sum", "=", "_mm_unpacklo_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_unpacklo_epi32", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_unpacklo_epi64", "(", "sum", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "if", "(", "!", "skip", ")", "{", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "size", "==", "16", ")", "{", "__m128i", "sum", "=", "_mm_setr_epi16", "(", "16", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "refSamples", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "8", ")", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "topOffset", ")", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "topOffset", "+", "8", ")", ")", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_srli_epi16", "(", "sum", ",", "5", ")", ";", "sum", "=", "_mm_unpacklo_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_unpacklo_epi32", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_unpacklo_epi64", "(", "sum", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "if", "(", "!", "skip", ")", "{", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "}", "}", "else", "{", "<comment_type=\"line\"", "format=\"doxygen\">", "///*", "if", "(size", "==", "32)", "{*/", "__m128i", "sum", "=", "_mm_setr_epi16", "(", "32", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "refSamples", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "8", ")", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "16", ")", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "24", ")", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "topOffset", ")", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "topOffset", "+", "8", ")", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "topOffset", "+", "16", ")", ")", ")", ";", "sum", "=", "_mm_add_epi16", "(", "sum", ",", "_mm_loadu_si128", "(", "(", "__m128i", "*", ")", "(", "refSamples", "+", "topOffset", "+", "24", ")", ")", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_hadd_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_srli_epi16", "(", "sum", ",", "6", ")", ";", "sum", "=", "_mm_unpacklo_epi16", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_unpacklo_epi32", "(", "sum", ",", "sum", ")", ";", "sum", "=", "_mm_unpacklo_epi64", "(", "sum", ",", "sum", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "(", "EB_U32", ")", "(", "skip", "?", "8", ":", "16", ")", ";", "i", "++", ")", "{", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "predictionPtr", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "16", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "24", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "8", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "16", ")", ",", "sum", ")", ";", "_mm_storeu_si128", "(", "(", "__m128i", "*", ")", "(", "predictionPtr", "+", "pStride", "+", "24", ")", ",", "sum", ")", ";", "predictionPtr", "+=", "2", "*", "pStride", ";", "}", "}", "}'" ]

[ "random", "number", "r:", "0", "<", "r", "<", "range" ]

[ "'static", "int", "bnrand_range", "(", "BNRAND_FLAG", "flag", ",", "BIGNUM", "*", "r", ",", "const", "BIGNUM", "*", "range", ")", "{", "int", "n", ";", "int", "count", "=", "100", ";", "if", "(", "range", "->", "neg", "||", "BN_is_zero", "(", "range", ")", ")", "{", "BNerr", "(", "BN_F_BNRAND_RANGE", ",", "BN_R_INVALID_RANGE", ")", ";", "return", "0", ";", "}", "n", "=", "BN_num_bits", "(", "range", ")", ";", "/*", "n", ">", "0", "*/", "/*", "BN_is_bit_set(range,", "n", "-", "1)", "always", "holds", "*/", "if", "(", "n", "==", "1", ")", "BN_zero", "(", "r", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "BN_is_bit_set", "(", "range", ",", "n", "-", "2", ")", "&&", "!", "BN_is_bit_set", "(", "range", ",", "n", "-", "3", ")", ")", "{", "/*", "*", "range", "=", "100..._2,", "so", "3*range", "(=", "11..._2)", "is", "exactly", "one", "bit", "longer", "*", "than", "range", "*/", "do", "{", "if", "(", "!", "bnrand", "(", "flag", ",", "r", ",", "n", "+", "1", ",", "BN_RAND_TOP_ANY", ",", "BN_RAND_BOTTOM_ANY", ")", ")", "return", "0", ";", "/*", "*", "If", "r", "<", "3*range,", "use", "r", ":=", "r", "MOD", "range", "(which", "is", "either", "r,", "r", "-", "*", "range,", "or", "r", "-", "2*range).", "Otherwise,", "iterate", "once", "more.", "Since", "*", "3*range", "=", "11..._2,", "each", "iteration", "succeeds", "with", "probability", ">=", "*", ".75.", "*/", "if", "(", "BN_cmp", "(", "r", ",", "range", ")", ">=", "0", ")", "{", "if", "(", "!", "BN_sub", "(", "r", ",", "r", ",", "range", ")", ")", "return", "0", ";", "if", "(", "BN_cmp", "(", "r", ",", "range", ")", ">=", "0", ")", "if", "(", "!", "BN_sub", "(", "r", ",", "r", ",", "range", ")", ")", "return", "0", ";", "}", "if", "(", "!", "--", "count", ")", "{", "BNerr", "(", "BN_F_BNRAND_RANGE", ",", "BN_R_TOO_MANY_ITERATIONS", ")", ";", "return", "0", ";", "}", "}", "while", "(", "BN_cmp", "(", "r", ",", "range", ")", ">=", "0", ")", ";", "}", "else", "{", "do", "{", "/*", "range", "=", "11..._2", "or", "range", "=", "101..._2", "*/", "if", "(", "!", "bnrand", "(", "flag", ",", "r", ",", "n", ",", "BN_RAND_TOP_ANY", ",", "BN_RAND_BOTTOM_ANY", ")", ")", "return", "0", ";", "if", "(", "!", "--", "count", ")", "{", "BNerr", "(", "BN_F_BNRAND_RANGE", ",", "BN_R_TOO_MANY_ITERATIONS", ")", ";", "return", "0", ";", "}", "}", "while", "(", "BN_cmp", "(", "r", ",", "range", ")", ">=", "0", ")", ";", "}", "bn_check_top", "(", "r", ")", ";", "return", "1", ";", "}'" ]

[ "Like", "gen_expand,", "but", "generates", "insns", "resulting", "from", "splitting", "SPLIT" ]

[ "'static", "void", "gen_split", "(", "md_rtx_info", "*", "info", ")", "{", "struct", "pattern_stats", "stats", ";", "int", "i", ";", "rtx", "split", "=", "info", "->", "def", ";", "const", "char", "*", "const", "name", "=", "(", "(", "GET_CODE", "(", "split", ")", "==", "DEFINE_PEEPHOLE2", ")", "?", "\"peephole2\"", ":", "\"split\"", ")", ";", "const", "char", "*", "unused", ";", "char", "*", "used", ";", "if", "(", "XVEC", "(", "split", ",", "0", ")", "==", "0", ")", "fatal_at", "(", "info", "->", "loc", ",", "\"%s", "lacks", "a", "pattern\"", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "split", ")", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "XVEC", "(", "split", ",", "2", ")", "==", "0", ")", "fatal_at", "(", "info", "->", "loc", ",", "\"%s", "lacks", "a", "replacement", "pattern\"", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "split", ")", ")", ")", ";", "/*", "Find", "out", "how", "many", "operands", "this", "function", "has.", "*/", "get_pattern_stats", "(", "&", "stats", ",", "XVEC", "(", "split", ",", "2", ")", ")", ";", "unused", "=", "(", "stats", ".", "num_operand_vars", "==", "0", "?", "\"", "ATTRIBUTE_UNUSED\"", ":", "\"\"", ")", ";", "used", "=", "XCNEWVEC", "(", "char", ",", "stats", ".", "num_operand_vars", ")", ";", "/*", "Output", "the", "prototype,", "function", "name", "and", "argument", "declarations.", "*/", "if", "(", "GET_CODE", "(", "split", ")", "==", "DEFINE_PEEPHOLE2", ")", "{", "printf", "(", "\"extern", "rtx_insn", "*gen_%s_%d", "(rtx_insn", "*,", "rtx", "*);\\\"", ",", "name", ",", "info", "->", "index", ")", ";", "printf", "(", "\"rtx_insn", "*\\gen_%s_%d", "(rtx_insn", "*curr_insn", "ATTRIBUTE_UNUSED,\"", "\"", "rtx", "*operands%s)\\\"", ",", "name", ",", "info", "->", "index", ",", "unused", ")", ";", "}", "else", "{", "printf", "(", "\"extern", "rtx_insn", "*gen_split_%d", "(rtx_insn", "*,", "rtx", "*);\\\"", ",", "info", "->", "index", ")", ";", "printf", "(", "\"rtx_insn", "*\\gen_split_%d", "\"", "\"(rtx_insn", "*curr_insn", "ATTRIBUTE_UNUSED,", "rtx", "*operands%s)\\\"", ",", "info", "->", "index", ",", "unused", ")", ";", "}", "printf", "(", "\"{\\\"", ")", ";", "/*", "Declare", "all", "local", "variables.", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "stats", ".", "num_operand_vars", ";", "i", "++", ")", "printf", "(", "\"", "rtx", "operand%d;\\\"", ",", "i", ")", ";", "printf", "(", "\"", "rtx_insn", "*_val", "=", "NULL;\\\"", ")", ";", "if", "(", "GET_CODE", "(", "split", ")", "==", "DEFINE_PEEPHOLE2", ")", "output_peephole2_scratches", "(", "split", ")", ";", "printf", "(", "\"", "if", "(dump_file)\\\"", ")", ";", "printf", "(", "\"", "fprintf", "(dump_file,", "\\\\\"Splitting", "with", "gen_%s_%d\\\\\\\\\\\");\\\"", ",", "name", ",", "info", "->", "index", ")", ";", "printf", "(", "\"", "start_sequence", "();\\\"", ")", ";", "/*", "The", "fourth", "operand", "of", "DEFINE_SPLIT", "is", "some", "code", "to", "be", "executed", "before", "the", "actual", "construction.", "*/", "if", "(", "XSTR", "(", "split", ",", "3", ")", ")", "emit_c_code", "(", "XSTR", "(", "split", ",", "3", ")", ",", "true", ",", "name", ")", ";", "/*", "Output", "code", "to", "copy", "the", "arguments", "back", "out", "of", "`operands\\'", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "stats", ".", "num_operand_vars", ";", "i", "++", ")", "{", "printf", "(", "\"", "operand%d", "=", "operands[%d];\\\"", ",", "i", ",", "i", ")", ";", "printf", "(", "\"", "(void)", "operand%d;\\\"", ",", "i", ")", ";", "}", "gen_emit_seq", "(", "XVEC", "(", "split", ",", "2", ")", ",", "used", ")", ";", "/*", "Call", "`get_insns\\'", "to", "make", "a", "list", "of", "all", "the", "insns", "emitted", "within", "this", "gen_...", "function.", "*/", "printf", "(", "\"", "_val", "=", "get_insns", "();\\\"", ")", ";", "printf", "(", "\"", "end_sequence", "();\\\"", ")", ";", "printf", "(", "\"", "return", "_val;\\}\\\\\"", ")", ";", "free", "(", "used", ")", ";", "}'" ]

[ "Derive", "secrets", "for", "ECDH", "DH" ]

[ "\"int", "ssl_derive", "(", "SSL", "*", "s", ",", "EVP_PKEY", "*", "privkey", ",", "EVP_PKEY", "*", "pubkey", ",", "int", "gensecret", ")", "{", "int", "rv", "=", "0", ";", "unsigned", "char", "*", "pms", "=", "NULL", ";", "size_t", "pmslen", "=", "0", ";", "EVP_PKEY_CTX", "*", "pctx", ";", "if", "(", "privkey", "==", "NULL", "||", "pubkey", "==", "NULL", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_DERIVE", ",", "ERR_R_INTERNAL_ERROR", ")", ";", "return", "0", ";", "}", "pctx", "=", "EVP_PKEY_CTX_new", "(", "privkey", ",", "NULL", ")", ";", "if", "(", "EVP_PKEY_derive_init", "(", "pctx", ")", "<=", "0", "||", "EVP_PKEY_derive_set_peer", "(", "pctx", ",", "pubkey", ")", "<=", "0", "||", "EVP_PKEY_derive", "(", "pctx", ",", "NULL", ",", "&", "pmslen", ")", "<=", "0", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_DERIVE", ",", "ERR_R_INTERNAL_ERROR", ")", ";", "goto", "err", ";", "}", "pms", "=", "OPENSSL_malloc", "(", "pmslen", ")", ";", "if", "(", "pms", "==", "NULL", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_DERIVE", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "goto", "err", ";", "}", "if", "(", "EVP_PKEY_derive", "(", "pctx", ",", "pms", ",", "&", "pmslen", ")", "<=", "0", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_DERIVE", ",", "ERR_R_INTERNAL_ERROR", ")", ";", "goto", "err", ";", "}", "if", "(", "gensecret", ")", "{", "/*", "SSLfatal()", "called", "as", "appropriate", "in", "the", "below", "functions", "*/", "if", "(", "SSL_IS_TLS13", "(", "s", ")", ")", "{", "/*", "*", "If", "we", "are", "resuming", "then", "we", "already", "generated", "the", "early", "secret", "*", "when", "we", "created", "the", "ClientHello,", "so", "don't", "recreate", "it.", "*/", "if", "(", "!", "s", "->", "hit", ")", "rv", "=", "tls13_generate_secret", "(", "s", ",", "ssl_handshake_md", "(", "s", ")", ",", "NULL", ",", "NULL", ",", "0", ",", "(", "unsigned", "char", "*", ")", "&", "s", "->", "early_secret", ")", ";", "else", "rv", "=", "1", ";", "rv", "=", "rv", "&&", "tls13_generate_handshake_secret", "(", "s", ",", "pms", ",", "pmslen", ")", ";", "}", "else", "{", "rv", "=", "ssl_generate_master_secret", "(", "s", ",", "pms", ",", "pmslen", ",", "0", ")", ";", "}", "}", "else", "{", "/*", "Save", "premaster", "secret", "*/", "s", "->", "s3", "->", "tmp", ".", "pms", "=", "pms", ";", "s", "->", "s3", "->", "tmp", ".", "pmslen", "=", "pmslen", ";", "pms", "=", "NULL", ";", "rv", "=", "1", ";", "}", "err", ":", "OPENSSL_clear_free", "(", "pms", ",", "pmslen", ")", ";", "EVP_PKEY_CTX_free", "(", "pctx", ")", ";", "return", "rv", ";", "}\"" ]

[ "Generate", "a", "private", "key", "from", "a", "group", "ID" ]

[ "'EVP_PKEY", "*", "ssl_generate_pkey_group", "(", "SSL", "*", "s", ",", "uint16_t", "id", ")", "{", "EVP_PKEY_CTX", "*", "pctx", "=", "NULL", ";", "EVP_PKEY", "*", "pkey", "=", "NULL", ";", "const", "TLS_GROUP_INFO", "*", "ginf", "=", "tls1_group_id_lookup", "(", "id", ")", ";", "uint16_t", "gtype", ";", "if", "(", "ginf", "==", "NULL", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_GENERATE_PKEY_GROUP", ",", "ERR_R_INTERNAL_ERROR", ")", ";", "goto", "err", ";", "}", "gtype", "=", "ginf", "->", "flags", "&", "TLS_CURVE_TYPE", ";", "if", "(", "gtype", "==", "TLS_CURVE_CUSTOM", ")", "pctx", "=", "EVP_PKEY_CTX_new_id", "(", "ginf", "->", "nid", ",", "NULL", ")", ";", "else", "pctx", "=", "EVP_PKEY_CTX_new_id", "(", "EVP_PKEY_EC", ",", "NULL", ")", ";", "if", "(", "pctx", "==", "NULL", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_GENERATE_PKEY_GROUP", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "goto", "err", ";", "}", "if", "(", "EVP_PKEY_keygen_init", "(", "pctx", ")", "<=", "0", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_GENERATE_PKEY_GROUP", ",", "ERR_R_EVP_LIB", ")", ";", "goto", "err", ";", "}", "if", "(", "gtype", "!=", "TLS_CURVE_CUSTOM", "&&", "EVP_PKEY_CTX_set_ec_paramgen_curve_nid", "(", "pctx", ",", "ginf", "->", "nid", ")", "<=", "0", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_GENERATE_PKEY_GROUP", ",", "ERR_R_EVP_LIB", ")", ";", "goto", "err", ";", "}", "if", "(", "EVP_PKEY_keygen", "(", "pctx", ",", "&", "pkey", ")", "<=", "0", ")", "{", "SSLfatal", "(", "s", ",", "SSL_AD_INTERNAL_ERROR", ",", "SSL_F_SSL_GENERATE_PKEY_GROUP", ",", "ERR_R_EVP_LIB", ")", ";", "EVP_PKEY_free", "(", "pkey", ")", ";", "pkey", "=", "NULL", ";", "}", "err", ":", "EVP_PKEY_CTX_free", "(", "pctx", ")", ";", "return", "pkey", ";", "}'" ]

[ "Generate", "a", "private", "key", "from", "parameters" ]

[ "'EVP_PKEY", "*", "ssl_generate_pkey", "(", "EVP_PKEY", "*", "pm", ")", "{", "EVP_PKEY_CTX", "*", "pctx", "=", "NULL", ";", "EVP_PKEY", "*", "pkey", "=", "NULL", ";", "if", "(", "pm", "==", "NULL", ")", "return", "NULL", ";", "pctx", "=", "EVP_PKEY_CTX_new", "(", "pm", ",", "NULL", ")", ";", "if", "(", "pctx", "==", "NULL", ")", "goto", "err", ";", "if", "(", "EVP_PKEY_keygen_init", "(", "pctx", ")", "<=", "0", ")", "goto", "err", ";", "if", "(", "EVP_PKEY_keygen", "(", "pctx", ",", "&", "pkey", ")", "<=", "0", ")", "{", "EVP_PKEY_free", "(", "pkey", ")", ";", "pkey", "=", "NULL", ";", "}", "err", ":", "EVP_PKEY_CTX_free", "(", "pctx", ")", ";", "return", "pkey", ";", "}'" ]

[ "Destroys", "the", "host", "and", "all", "resources", "associated", "with", "it" ]

[ "'void", "enet_host_destroy", "(", "ENetHost", "*", "host", ")", "{", "ENetPeer", "*", "currentPeer", ";", "if", "(", "host", "==", "NULL", ")", "return", ";", "enet_socket_destroy", "(", "host", "->", "socket", ")", ";", "for", "(", "currentPeer", "=", "host", "->", "peers", ";", "currentPeer", "<", "&", "host", "->", "peers", "[", "host", "->", "peerCount", "]", ";", "++", "currentPeer", ")", "{", "enet_peer_reset", "(", "currentPeer", ")", ";", "}", "if", "(", "host", "->", "compressor", ".", "context", "!=", "NULL", "&&", "host", "->", "compressor", ".", "destroy", ")", "(", "*", "host", "->", "compressor", ".", "destroy", ")", "(", "host", "->", "compressor", ".", "context", ")", ";", "enet_free", "(", "host", "->", "peers", ")", ";", "enet_free", "(", "host", ")", ";", "}'" ]

[ "Adjusts", "the", "bandwidth", "limits", "of", "a", "host" ]

[ "'void", "enet_host_bandwidth_limit", "(", "ENetHost", "*", "host", ",", "enet_uint32", "incomingBandwidth", ",", "enet_uint32", "outgoingBandwidth", ")", "{", "host", "->", "incomingBandwidth", "=", "incomingBandwidth", ";", "host", "->", "outgoingBandwidth", "=", "outgoingBandwidth", ";", "host", "->", "recalculateBandwidthLimits", "=", "1", ";", "}'" ]

[ "Queues", "a", "packet", "to", "be", "sent", "to", "all", "peers", "associated", "with", "the", "host" ]

[ "'void", "enet_host_broadcast", "(", "ENetHost", "*", "host", ",", "enet_uint8", "channelID", ",", "ENetPacket", "*", "packet", ")", "{", "ENetPeer", "*", "currentPeer", ";", "for", "(", "currentPeer", "=", "host", "->", "peers", ";", "currentPeer", "<", "&", "host", "->", "peers", "[", "host", "->", "peerCount", "]", ";", "++", "currentPeer", ")", "{", "if", "(", "currentPeer", "->", "state", "!=", "ENET_PEER_STATE_CONNECTED", ")", "continue;", "enet_peer_send", "(", "currentPeer", ",", "channelID", ",", "packet", ")", ";", "}", "if", "(", "packet", "->", "referenceCount", "==", "0", ")", "enet_packet_destroy", "(", "packet", ")", ";", "}'" ]

[ "@defgroup", "host", "ENet", "host", "functions", "@{", "Creates", "a", "host", "for", "communicating", "to", "peers" ]

[ "'ENetHost", "*", "enet_host_create", "(", "const", "ENetAddress", "*", "address", ",", "size_t", "peerCount", ",", "size_t", "channelLimit", ",", "enet_uint32", "incomingBandwidth", ",", "enet_uint32", "outgoingBandwidth", ")", "{", "ENetHost", "*", "host", ";", "ENetPeer", "*", "currentPeer", ";", "if", "(", "peerCount", ">", "ENET_PROTOCOL_MAXIMUM_PEER_ID", ")", "return", "NULL", ";", "host", "=", "(", "ENetHost", "*", ")", "enet_malloc", "(", "sizeof", "(", "ENetHost", ")", ")", ";", "if", "(", "host", "==", "NULL", ")", "return", "NULL", ";", "memset", "(", "host", ",", "0", ",", "sizeof", "(", "ENetHost", ")", ")", ";", "host", "->", "peers", "=", "(", "ENetPeer", "*", ")", "enet_malloc", "(", "peerCount", "*", "sizeof", "(", "ENetPeer", ")", ")", ";", "if", "(", "host", "->", "peers", "==", "NULL", ")", "{", "enet_free", "(", "host", ")", ";", "return", "NULL", ";", "}", "memset", "(", "host", "->", "peers", ",", "0", ",", "peerCount", "*", "sizeof", "(", "ENetPeer", ")", ")", ";", "host", "->", "socket", "=", "enet_socket_create", "(", "ENET_SOCKET_TYPE_DATAGRAM", ")", ";", "if", "(", "host", "->", "socket", "==", "ENET_SOCKET_NULL", "||", "(", "address", "!=", "NULL", "&&", "enet_socket_bind", "(", "host", "->", "socket", ",", "address", ")", "<", "0", ")", ")", "{", "if", "(", "host", "->", "socket", "!=", "ENET_SOCKET_NULL", ")", "enet_socket_destroy", "(", "host", "->", "socket", ")", ";", "enet_free", "(", "host", "->", "peers", ")", ";", "enet_free", "(", "host", ")", ";", "return", "NULL", ";", "}", "enet_socket_set_option", "(", "host", "->", "socket", ",", "ENET_SOCKOPT_NONBLOCK", ",", "1", ")", ";", "enet_socket_set_option", "(", "host", "->", "socket", ",", "ENET_SOCKOPT_BROADCAST", ",", "1", ")", ";", "enet_socket_set_option", "(", "host", "->", "socket", ",", "ENET_SOCKOPT_RCVBUF", ",", "ENET_HOST_RECEIVE_BUFFER_SIZE", ")", ";", "enet_socket_set_option", "(", "host", "->", "socket", ",", "ENET_SOCKOPT_SNDBUF", ",", "ENET_HOST_SEND_BUFFER_SIZE", ")", ";", "if", "(", "address", "!=", "NULL", ")", "host", "->", "address", "=", "*", "address", ";", "if", "(", "!", "channelLimit", "||", "channelLimit", ">", "ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT", ")", "channelLimit", "=", "ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT", ";", "<if", "type=\"elseif\">", "else", "if", "(", "channelLimit", "<", "ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT", ")", "channelLimit", "=", "ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT", ";", "host", "->", "randomSeed", "=", "(", "enet_uint32", ")", "(", "size_t", ")", "host", ";", "#", "ifdef", "WIN32", "host", "->", "randomSeed", "+=", "(", "enet_uint32", ")", "timeGetTime", "()", ";", "#", "else", "host", "->", "randomSeed", "+=", "(", "enet_uint32", ")", "time", "(", "NULL", ")", ";", "#", "endif", "host", "->", "randomSeed", "=", "(", "host", "->", "randomSeed", "<<", "16", ")", "|", "(", "host", "->", "randomSeed", ">>", "16", ")", ";", "host", "->", "channelLimit", "=", "channelLimit", ";", "host", "->", "incomingBandwidth", "=", "incomingBandwidth", ";", "host", "->", "outgoingBandwidth", "=", "outgoingBandwidth", ";", "host", "->", "bandwidthThrottleEpoch", "=", "0", ";", "host", "->", "recalculateBandwidthLimits", "=", "0", ";", "host", "->", "mtu", "=", "ENET_HOST_DEFAULT_MTU", ";", "host", "->", "peerCount", "=", "peerCount", ";", "host", "->", "commandCount", "=", "0", ";", "host", "->", "bufferCount", "=", "0", ";", "host", "->", "checksum", "=", "NULL", ";", "host", "->", "receivedAddress", ".", "host", "=", "ENET_HOST_ANY", ";", "host", "->", "receivedAddress", ".", "port", "=", "0", ";", "host", "->", "receivedData", "=", "NULL", ";", "host", "->", "receivedDataLength", "=", "0", ";", "host", "->", "totalSentData", "=", "0", ";", "host", "->", "totalSentPackets", "=", "0", ";", "host", "->", "totalReceivedData", "=", "0", ";", "host", "->", "totalReceivedPackets", "=", "0", ";", "host", "->", "compressor", ".", "context", "=", "NULL", ";", "host", "->", "compressor", ".", "compress", "=", "NULL", ";", "host", "->", "compressor", ".", "decompress", "=", "NULL", ";", "host", "->", "compressor", ".", "destroy", "=", "NULL", ";", "host", "->", "intercept", "=", "NULL", ";", "enet_list_clear", "(", "&", "host", "->", "dispatchQueue", ")", ";", "for", "(", "currentPeer", "=", "host", "->", "peers", ";", "currentPeer", "<", "&", "host", "->", "peers", "[", "host", "->", "peerCount", "]", ";", "++", "currentPeer", ")", "{", "currentPeer", "->", "host", "=", "host", ";", "currentPeer", "->", "incomingPeerID", "=", "currentPeer", "-", "host", "->", "peers", ";", "currentPeer", "->", "outgoingSessionID", "=", "currentPeer", "->", "incomingSessionID", "=", "0xFF", ";", "currentPeer", "->", "data", "=", "NULL", ";", "enet_list_clear", "(", "&", "currentPeer", "->", "acknowledgements", ")", ";", "enet_list_clear", "(", "&", "currentPeer", "->", "sentReliableCommands", ")", ";", "enet_list_clear", "(", "&", "currentPeer", "->", "sentUnreliableCommands", ")", ";", "enet_list_clear", "(", "&", "currentPeer", "->", "outgoingReliableCommands", ")", ";", "enet_list_clear", "(", "&", "currentPeer", "->", "outgoingUnreliableCommands", ")", ";", "enet_list_clear", "(", "&", "currentPeer", "->", "dispatchedCommands", ")", ";", "enet_peer_reset", "(", "currentPeer", ")", ";", "}", "return", "host", ";", "}'" ]

[ "Sets", "the", "packet", "compressor", "the", "host", "should", "use", "to", "compress", "and", "decompress", "packets" ]

[ "'void", "enet_host_compress", "(", "ENetHost", "*", "host", ",", "const", "ENetCompressor", "*", "compressor", ")", "{", "if", "(", "host", "->", "compressor", ".", "context", "!=", "NULL", "&&", "host", "->", "compressor", ".", "destroy", ")", "(", "*", "host", "->", "compressor", ".", "destroy", ")", "(", "host", "->", "compressor", ".", "context", ")", ";", "if", "(", "compressor", ")", "host", "->", "compressor", "=", "*", "compressor", ";", "else", "host", "->", "compressor", ".", "context", "=", "NULL", ";", "}'" ]

[ "Limits", "the", "maximum", "allowed", "channels", "of", "future", "incoming", "connections" ]

[ "'void", "enet_host_channel_limit", "(", "ENetHost", "*", "host", ",", "size_t", "channelLimit", ")", "{", "if", "(", "!", "channelLimit", "||", "channelLimit", ">", "ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT", ")", "channelLimit", "=", "ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT", ";", "<if", "type=\"elseif\">", "else", "if", "(", "channelLimit", "<", "ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT", ")", "channelLimit", "=", "ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT", ";", "host", "->", "channelLimit", "=", "channelLimit", ";", "}'" ]

[ "Initiates", "a", "connection", "to", "a", "foreign", "host" ]

[ "'ENetPeer", "*", "enet_host_connect", "(", "ENetHost", "*", "host", ",", "const", "ENetAddress", "*", "address", ",", "size_t", "channelCount", ",", "enet_uint32", "data", ")", "{", "ENetPeer", "*", "currentPeer", ";", "ENetChannel", "*", "channel", ";", "ENetProtocol", "command", ";", "if", "(", "channelCount", "<", "ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT", ")", "channelCount", "=", "ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT", ";", "<if", "type=\"elseif\">", "else", "if", "(", "channelCount", ">", "ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT", ")", "channelCount", "=", "ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT", ";", "for", "(", "currentPeer", "=", "host", "->", "peers", ";", "currentPeer", "<", "&", "host", "->", "peers", "[", "host", "->", "peerCount", "]", ";", "++", "currentPeer", ")", "{", "if", "(", "currentPeer", "->", "state", "==", "ENET_PEER_STATE_DISCONNECTED", ")", "break;", "}", "if", "(", "currentPeer", ">=", "&", "host", "->", "peers", "[", "host", "->", "peerCount", "]", ")", "return", "NULL", ";", "currentPeer", "->", "channels", "=", "(", "ENetChannel", "*", ")", "enet_malloc", "(", "channelCount", "*", "sizeof", "(", "ENetChannel", ")", ")", ";", "if", "(", "currentPeer", "->", "channels", "==", "NULL", ")", "return", "NULL", ";", "currentPeer", "->", "channelCount", "=", "channelCount", ";", "currentPeer", "->", "state", "=", "ENET_PEER_STATE_CONNECTING", ";", "currentPeer", "->", "address", "=", "*", "address", ";", "currentPeer", "->", "connectID", "=", "++", "host", "->", "randomSeed", ";", "if", "(", "host", "->", "outgoingBandwidth", "==", "0", ")", "currentPeer", "->", "windowSize", "=", "ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE", ";", "else", "currentPeer", "->", "windowSize", "=", "(", "host", "->", "outgoingBandwidth", "/", "ENET_PEER_WINDOW_SIZE_SCALE", ")", "*", "ENET_PROTOCOL_MINIMUM_WINDOW_SIZE", ";", "if", "(", "currentPeer", "->", "windowSize", "<", "ENET_PROTOCOL_MINIMUM_WINDOW_SIZE", ")", "currentPeer", "->", "windowSize", "=", "ENET_PROTOCOL_MINIMUM_WINDOW_SIZE", ";", "<if", "type=\"elseif\">", "else", "if", "(", "currentPeer", "->", "windowSize", ">", "ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE", ")", "currentPeer", "->", "windowSize", "=", "ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE", ";", "for", "(", "channel", "=", "currentPeer", "->", "channels", ";", "channel", "<", "&", "currentPeer", "->", "channels", "[", "channelCount", "]", ";", "++", "channel", ")", "{", "channel", "->", "outgoingReliableSequenceNumber", "=", "0", ";", "channel", "->", "outgoingUnreliableSequenceNumber", "=", "0", ";", "channel", "->", "incomingReliableSequenceNumber", "=", "0", ";", "channel", "->", "incomingUnreliableSequenceNumber", "=", "0", ";", "enet_list_clear", "(", "&", "channel", "->", "incomingReliableCommands", ")", ";", "enet_list_clear", "(", "&", "channel", "->", "incomingUnreliableCommands", ")", ";", "channel", "->", "usedReliableWindows", "=", "0", ";", "memset", "(", "channel", "->", "reliableWindows", ",", "0", ",", "sizeof", "(", "channel", "->", "reliableWindows", ")", ")", ";", "}", "command", ".", "header", ".", "command", "=", "ENET_PROTOCOL_COMMAND_CONNECT", "|", "ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE", ";", "command", ".", "header", ".", "channelID", "=", "0xFF", ";", "command", ".", "connect", ".", "outgoingPeerID", "=", "ENET_HOST_TO_NET_16", "(", "currentPeer", "->", "incomingPeerID", ")", ";", "command", ".", "connect", ".", "incomingSessionID", "=", "currentPeer", "->", "incomingSessionID", ";", "command", ".", "connect", ".", "outgoingSessionID", "=", "currentPeer", "->", "outgoingSessionID", ";", "command", ".", "connect", ".", "mtu", "=", "ENET_HOST_TO_NET_32", "(", "currentPeer", "->", "mtu", ")", ";", "command", ".", "connect", ".", "windowSize", "=", "ENET_HOST_TO_NET_32", "(", "currentPeer", "->", "windowSize", ")", ";", "command", ".", "connect", ".", "channelCount", "=", "ENET_HOST_TO_NET_32", "(", "channelCount", ")", ";", "command", ".", "connect", ".", "incomingBandwidth", "=", "ENET_HOST_TO_NET_32", "(", "host", "->", "incomingBandwidth", ")", ";", "command", ".", "connect", ".", "outgoingBandwidth", "=", "ENET_HOST_TO_NET_32", "(", "host", "->", "outgoingBandwidth", ")", ";", "command", ".", "connect", ".", "packetThrottleInterval", "=", "ENET_HOST_TO_NET_32", "(", "currentPeer", "->", "packetThrottleInterval", ")", ";", "command", ".", "connect", ".", "packetThrottleAcceleration", "=", "ENET_HOST_TO_NET_32", "(", "currentPeer", "->", "packetThrottleAcceleration", ")", ";", "command", ".", "connect", ".", "packetThrottleDeceleration", "=", "ENET_HOST_TO_NET_32", "(", "currentPeer", "->", "packetThrottleDeceleration", ")", ";", "command", ".", "connect", ".", "connectID", "=", "currentPeer", "->", "connectID", ";", "command", ".", "connect", ".", "data", "=", "ENET_HOST_TO_NET_32", "(", "data", ")", ";", "enet_peer_queue_outgoing_command", "(", "currentPeer", ",", "&", "command", ",", "NULL", ",", "0", ",", "0", ")", ";", "return", "currentPeer", ";", "}'" ]

[ "Returns", "cost", "of", "operation", "CODE,", "according", "to", "WEIGHTS" ]

[ "'static", "int", "estimate_operator_cost", "(", "enum", "tree_code", "code", ",", "eni_weights", "*", "weights", ",", "tree", "op1", "ATTRIBUTE_UNUSED", ",", "tree", "op2", ")", "{", "switch", "(", "code", ")", "{", "/*", "These", "are", "\"free\"", "conversions,", "or", "their", "presumed", "cost", "is", "folded", "into", "other", "operations.", "*/", "case", "RANGE_EXPR", ":", "CASE_CONVERT", ":", "case", "COMPLEX_EXPR", ":", "case", "PAREN_EXPR", ":", "case", "VIEW_CONVERT_EXPR", ":", "return", "0", ";", "/*", "Assign", "cost", "of", "1", "to", "usual", "operations.", "???", "We", "may", "consider", "mapping", "RTL", "costs", "to", "this.", "*/", "case", "COND_EXPR", ":", "case", "VEC_COND_EXPR", ":", "case", "VEC_PERM_EXPR", ":", "case", "PLUS_EXPR", ":", "case", "POINTER_PLUS_EXPR", ":", "case", "POINTER_DIFF_EXPR", ":", "case", "MINUS_EXPR", ":", "case", "MULT_EXPR", ":", "case", "MULT_HIGHPART_EXPR", ":", "case", "FMA_EXPR", ":", "case", "ADDR_SPACE_CONVERT_EXPR", ":", "case", "FIXED_CONVERT_EXPR", ":", "case", "FIX_TRUNC_EXPR", ":", "case", "NEGATE_EXPR", ":", "case", "FLOAT_EXPR", ":", "case", "MIN_EXPR", ":", "case", "MAX_EXPR", ":", "case", "ABS_EXPR", ":", "case", "LSHIFT_EXPR", ":", "case", "RSHIFT_EXPR", ":", "case", "LROTATE_EXPR", ":", "case", "RROTATE_EXPR", ":", "case", "BIT_IOR_EXPR", ":", "case", "BIT_XOR_EXPR", ":", "case", "BIT_AND_EXPR", ":", "case", "BIT_NOT_EXPR", ":", "case", "TRUTH_ANDIF_EXPR", ":", "case", "TRUTH_ORIF_EXPR", ":", "case", "TRUTH_AND_EXPR", ":", "case", "TRUTH_OR_EXPR", ":", "case", "TRUTH_XOR_EXPR", ":", "case", "TRUTH_NOT_EXPR", ":", "case", "LT_EXPR", ":", "case", "LE_EXPR", ":", "case", "GT_EXPR", ":", "case", "GE_EXPR", ":", "case", "EQ_EXPR", ":", "case", "NE_EXPR", ":", "case", "ORDERED_EXPR", ":", "case", "UNORDERED_EXPR", ":", "case", "UNLT_EXPR", ":", "case", "UNLE_EXPR", ":", "case", "UNGT_EXPR", ":", "case", "UNGE_EXPR", ":", "case", "UNEQ_EXPR", ":", "case", "LTGT_EXPR", ":", "case", "CONJ_EXPR", ":", "case", "PREDECREMENT_EXPR", ":", "case", "PREINCREMENT_EXPR", ":", "case", "POSTDECREMENT_EXPR", ":", "case", "POSTINCREMENT_EXPR", ":", "case", "REALIGN_LOAD_EXPR", ":", "case", "WIDEN_SUM_EXPR", ":", "case", "WIDEN_MULT_EXPR", ":", "case", "DOT_PROD_EXPR", ":", "case", "SAD_EXPR", ":", "case", "WIDEN_MULT_PLUS_EXPR", ":", "case", "WIDEN_MULT_MINUS_EXPR", ":", "case", "WIDEN_LSHIFT_EXPR", ":", "case", "VEC_WIDEN_MULT_HI_EXPR", ":", "case", "VEC_WIDEN_MULT_LO_EXPR", ":", "case", "VEC_WIDEN_MULT_EVEN_EXPR", ":", "case", "VEC_WIDEN_MULT_ODD_EXPR", ":", "case", "VEC_UNPACK_HI_EXPR", ":", "case", "VEC_UNPACK_LO_EXPR", ":", "case", "VEC_UNPACK_FLOAT_HI_EXPR", ":", "case", "VEC_UNPACK_FLOAT_LO_EXPR", ":", "case", "VEC_PACK_TRUNC_EXPR", ":", "case", "VEC_PACK_SAT_EXPR", ":", "case", "VEC_PACK_FIX_TRUNC_EXPR", ":", "case", "VEC_WIDEN_LSHIFT_HI_EXPR", ":", "case", "VEC_WIDEN_LSHIFT_LO_EXPR", ":", "case", "VEC_DUPLICATE_EXPR", ":", "case", "VEC_SERIES_EXPR", ":", "return", "1", ";", "/*", "Few", "special", "cases", "of", "expensive", "operations.", "This", "is", "useful", "to", "avoid", "inlining", "on", "functions", "having", "too", "many", "of", "these.", "*/", "case", "TRUNC_DIV_EXPR", ":", "case", "CEIL_DIV_EXPR", ":", "case", "FLOOR_DIV_EXPR", ":", "case", "ROUND_DIV_EXPR", ":", "case", "EXACT_DIV_EXPR", ":", "case", "TRUNC_MOD_EXPR", ":", "case", "CEIL_MOD_EXPR", ":", "case", "FLOOR_MOD_EXPR", ":", "case", "ROUND_MOD_EXPR", ":", "case", "RDIV_EXPR", ":", "if", "(", "TREE_CODE", "(", "op2", ")", "!=", "INTEGER_CST", ")", "return", "weights", "->", "div_mod_cost", ";", "return", "1", ";", "/*", "Bit-field", "insertion", "needs", "several", "shift", "and", "mask", "operations.", "*/", "case", "BIT_INSERT_EXPR", ":", "return", "3", ";", "default:", "/*", "We", "expect", "a", "copy", "assignment", "with", "no", "operator.", "*/", "gcc_assert", "(", "get_gimple_rhs_class", "(", "code", ")", "==", "GIMPLE_SINGLE_RHS", ")", ";", "return", "0", ";", "}", "}'" ]

[ "Construct", "new", "SSA", "name", "for", "old", "NAME" ]

[ "'static", "tree", "remap_ssa_name", "(", "tree", "name", ",", "copy_body_data", "*", "id", ")", "{", "tree", "new_tree", ",", "<type", "ref=\"prev\"/>", "var", ";", "tree", "*", "n", ";", "gcc_assert", "(", "TREE_CODE", "(", "name", ")", "==", "SSA_NAME", ")", ";", "n", "=", "id", "->", "decl_map", "->", "get", "(", "name", ")", ";", "if", "(", "n", ")", "return", "unshare_expr", "(", "*", "n", ")", ";", "if", "(", "processing_debug_stmt", ")", "{", "if", "(", "SSA_NAME_IS_DEFAULT_DEF", "(", "name", ")", "&&", "TREE_CODE", "(", "SSA_NAME_VAR", "(", "name", ")", ")", "==", "PARM_DECL", "&&", "id", "->", "entry_bb", "==", "NULL", "&&", "single_succ_p", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ")", "{", "tree", "vexpr", "=", "make_node", "(", "DEBUG_EXPR_DECL", ")", ";", "gimple", "*", "def_temp", ";", "gimple_stmt_iterator", "gsi", ";", "tree", "val", "=", "SSA_NAME_VAR", "(", "name", ")", ";", "n", "=", "id", "->", "decl_map", "->", "get", "(", "val", ")", ";", "if", "(", "n", "!=", "NULL", ")", "val", "=", "*", "n", ";", "if", "(", "TREE_CODE", "(", "val", ")", "!=", "PARM_DECL", ")", "{", "processing_debug_stmt", "=", "-", "1", ";", "return", "name", ";", "}", "def_temp", "=", "gimple_build_debug_source_bind", "(", "vexpr", ",", "val", ",", "NULL", ")", ";", "DECL_ARTIFICIAL", "(", "vexpr", ")", "=", "1", ";", "TREE_TYPE", "(", "vexpr", ")", "=", "TREE_TYPE", "(", "name", ")", ";", "SET_DECL_MODE", "(", "vexpr", ",", "DECL_MODE", "(", "SSA_NAME_VAR", "(", "name", ")", ")", ")", ";", "gsi", "=", "gsi_after_labels", "(", "single_succ", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ")", ";", "gsi_insert_before", "(", "&", "gsi", ",", "def_temp", ",", "GSI_SAME_STMT", ")", ";", "return", "vexpr", ";", "}", "processing_debug_stmt", "=", "-", "1", ";", "return", "name", ";", "}", "/*", "Remap", "anonymous", "SSA", "names", "or", "SSA", "names", "of", "anonymous", "decls.", "*/", "var", "=", "SSA_NAME_VAR", "(", "name", ")", ";", "if", "(", "!", "var", "||", "(", "!", "SSA_NAME_IS_DEFAULT_DEF", "(", "name", ")", "&&", "VAR_P", "(", "var", ")", "&&", "!", "VAR_DECL_IS_VIRTUAL_OPERAND", "(", "var", ")", "&&", "DECL_ARTIFICIAL", "(", "var", ")", "&&", "DECL_IGNORED_P", "(", "var", ")", "&&", "!", "DECL_NAME", "(", "var", ")", ")", ")", "{", "struct", "ptr_info_def", "*", "pi", ";", "new_tree", "=", "make_ssa_name", "(", "remap_type", "(", "TREE_TYPE", "(", "name", ")", ",", "id", ")", ")", ";", "if", "(", "!", "var", "&&", "SSA_NAME_IDENTIFIER", "(", "name", ")", ")", "SET_SSA_NAME_VAR_OR_IDENTIFIER", "(", "new_tree", ",", "SSA_NAME_IDENTIFIER", "(", "name", ")", ")", ";", "insert_decl_map", "(", "id", ",", "name", ",", "new_tree", ")", ";", "SSA_NAME_OCCURS_IN_ABNORMAL_PHI", "(", "new_tree", ")", "=", "SSA_NAME_OCCURS_IN_ABNORMAL_PHI", "(", "name", ")", ";", "/*", "At", "least", "IPA", "points-to", "info", "can", "be", "directly", "transferred.", "*/", "if", "(", "id", "->", "src_cfun", "->", "gimple_df", "&&", "id", "->", "src_cfun", "->", "gimple_df", "->", "ipa_pta", "&&", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "name", ")", ")", "&&", "(", "pi", "=", "SSA_NAME_PTR_INFO", "(", "name", ")", ")", "&&", "!", "pi", "->", "pt", ".", "anything", ")", "{", "struct", "ptr_info_def", "*", "new_pi", "=", "get_ptr_info", "(", "new_tree", ")", ";", "new_pi", "->", "pt", "=", "pi", "->", "pt", ";", "}", "return", "new_tree", ";", "}", "/*", "Do", "not", "set", "DEF_STMT", "yet", "as", "statement", "is", "not", "copied", "yet.", "We", "do", "that", "in", "copy_bb.", "*/", "new_tree", "=", "remap_decl", "(", "var", ",", "id", ")", ";", "/*", "We", "might\\'ve", "substituted", "constant", "or", "another", "SSA_NAME", "for", "the", "variable.", "Replace", "the", "SSA", "name", "representing", "RESULT_DECL", "by", "variable", "during", "inlining:", "this", "saves", "us", "from", "need", "to", "introduce", "PHI", "node", "in", "a", "case", "return", "value", "is", "just", "partly", "initialized.", "*/", "if", "(", "(", "VAR_P", "(", "new_tree", ")", "||", "TREE_CODE", "(", "new_tree", ")", "==", "PARM_DECL", ")", "&&", "(", "!", "SSA_NAME_VAR", "(", "name", ")", "||", "TREE_CODE", "(", "SSA_NAME_VAR", "(", "name", ")", ")", "!=", "RESULT_DECL", "||", "!", "id", "->", "transform_return_to_modify", ")", ")", "{", "struct", "ptr_info_def", "*", "pi", ";", "new_tree", "=", "make_ssa_name", "(", "new_tree", ")", ";", "insert_decl_map", "(", "id", ",", "name", ",", "new_tree", ")", ";", "SSA_NAME_OCCURS_IN_ABNORMAL_PHI", "(", "new_tree", ")", "=", "SSA_NAME_OCCURS_IN_ABNORMAL_PHI", "(", "name", ")", ";", "/*", "At", "least", "IPA", "points-to", "info", "can", "be", "directly", "transferred.", "*/", "if", "(", "id", "->", "src_cfun", "->", "gimple_df", "&&", "id", "->", "src_cfun", "->", "gimple_df", "->", "ipa_pta", "&&", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "name", ")", ")", "&&", "(", "pi", "=", "SSA_NAME_PTR_INFO", "(", "name", ")", ")", "&&", "!", "pi", "->", "pt", ".", "anything", ")", "{", "struct", "ptr_info_def", "*", "new_pi", "=", "get_ptr_info", "(", "new_tree", ")", ";", "new_pi", "->", "pt", "=", "pi", "->", "pt", ";", "}", "if", "(", "SSA_NAME_IS_DEFAULT_DEF", "(", "name", ")", ")", "{", "/*", "By", "inlining", "function", "having", "uninitialized", "variable,", "we", "might", "extend", "the", "lifetime", "(variable", "might", "get", "reused).", "This", "cause", "ICE", "in", "the", "case", "we", "end", "up", "extending", "lifetime", "of", "SSA", "name", "across", "abnormal", "edge,", "but", "also", "increase", "register", "pressure.", "We", "simply", "initialize", "all", "uninitialized", "vars", "by", "0", "except", "for", "case", "we", "are", "inlining", "to", "very", "first", "BB.", "We", "can", "avoid", "this", "for", "all", "BBs", "that", "are", "not", "inside", "strongly", "connected", "regions", "of", "the", "CFG,", "but", "this", "is", "expensive", "to", "test.", "*/", "if", "(", "id", "->", "entry_bb", "&&", "SSA_NAME_OCCURS_IN_ABNORMAL_PHI", "(", "name", ")", "&&", "(", "!", "SSA_NAME_VAR", "(", "name", ")", "||", "TREE_CODE", "(", "SSA_NAME_VAR", "(", "name", ")", ")", "!=", "PARM_DECL", ")", "&&", "(", "id", "->", "entry_bb", "!=", "EDGE_SUCC", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ",", "0", ")", "->", "dest", "||", "EDGE_COUNT", "(", "id", "->", "entry_bb", "->", "preds", ")", "!=", "1", ")", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_last_bb", "(", "id", "->", "entry_bb", ")", ";", "gimple", "*", "init_stmt", ";", "tree", "zero", "=", "build_zero_cst", "(", "TREE_TYPE", "(", "new_tree", ")", ")", ";", "init_stmt", "=", "gimple_build_assign", "(", "new_tree", ",", "zero", ")", ";", "gsi_insert_after", "(", "&", "gsi", ",", "init_stmt", ",", "GSI_NEW_STMT", ")", ";", "SSA_NAME_IS_DEFAULT_DEF", "(", "new_tree", ")", "=", "0", ";", "}", "else", "{", "SSA_NAME_DEF_STMT", "(", "new_tree", ")", "=", "gimple_build_nop", "()", ";", "set_ssa_default_def", "(", "cfun", ",", "SSA_NAME_VAR", "(", "new_tree", ")", ",", "new_tree", ")", ";", "}", "}", "}", "else", "insert_decl_map", "(", "id", ",", "name", ",", "new_tree", ")", ";", "return", "new_tree", ";", "}'" ]

[ "Initializes", "weights", "used", "by", "estimate_num_insns" ]

[ "'void", "init_inline_once", "(", "void", ")", "{", "eni_size_weights", ".", "call_cost", "=", "1", ";", "eni_size_weights", ".", "indirect_call_cost", "=", "3", ";", "eni_size_weights", ".", "target_builtin_call_cost", "=", "1", ";", "eni_size_weights", ".", "div_mod_cost", "=", "1", ";", "eni_size_weights", ".", "omp_cost", "=", "40", ";", "eni_size_weights", ".", "tm_cost", "=", "10", ";", "eni_size_weights", ".", "time_based", "=", "false", ";", "eni_size_weights", ".", "return_cost", "=", "1", ";", "/*", "Estimating", "time", "for", "call", "is", "difficult,", "since", "we", "have", "no", "idea", "what", "the", "called", "function", "does.", "In", "the", "current", "uses", "of", "eni_time_weights,", "underestimating", "the", "cost", "does", "less", "harm", "than", "overestimating", "it,", "so", "we", "choose", "a", "rather", "small", "value", "here.", "*/", "eni_time_weights", ".", "call_cost", "=", "10", ";", "eni_time_weights", ".", "indirect_call_cost", "=", "15", ";", "eni_time_weights", ".", "target_builtin_call_cost", "=", "1", ";", "eni_time_weights", ".", "div_mod_cost", "=", "10", ";", "eni_time_weights", ".", "omp_cost", "=", "40", ";", "eni_time_weights", ".", "tm_cost", "=", "40", ";", "eni_time_weights", ".", "time_based", "=", "true", ";", "eni_time_weights", ".", "return_cost", "=", "2", ";", "}'" ]

[ "Create", "a", "copy", "of", "SEQ", "and", "remap", "all", "decls", "in", "it" ]

[ "'static", "gimple_seq", "duplicate_remap_omp_clause_seq", "(", "gimple_seq", "seq", ",", "struct", "walk_stmt_info", "*", "wi", ")", "{", "if", "(", "!", "seq", ")", "return", "NULL", ";", "/*", "If", "there", "are", "any", "labels", "in", "OMP", "sequences,", "they", "can", "be", "only", "referred", "to", "in", "the", "sequence", "itself", "and", "therefore", "we", "can", "do", "both", "here.", "*/", "walk_gimple_seq", "(", "seq", ",", "mark_local_labels_stmt", ",", "NULL", ",", "wi", ")", ";", "gimple_seq", "copy", "=", "gimple_seq_copy", "(", "seq", ")", ";", "walk_gimple_seq", "(", "copy", ",", "replace_locals_stmt", ",", "replace_locals_op", ",", "wi", ")", ";", "return", "copy", ";", "}'" ]

[ "Copy", "the", "whole", "block", "tree", "and", "root", "it", "in", "id>block" ]

[ "'static", "tree", "remap_blocks", "(", "tree", "block", ",", "copy_body_data", "*", "id", ")", "{", "tree", "t", ";", "tree", "new_tree", "=", "block", ";", "if", "(", "!", "block", ")", "return", "NULL", ";", "remap_block", "(", "&", "new_tree", ",", "id", ")", ";", "gcc_assert", "(", "new_tree", "!=", "block", ")", ";", "for", "(", "t", "=", "BLOCK_SUBBLOCKS", "(", "block", ")", ";", "t", ";", "t", "=", "BLOCK_CHAIN", "(", "t", ")", ")", "prepend_lexical_block", "(", "new_tree", ",", "remap_blocks", "(", "t", ",", "id", ")", ")", ";", "/*", "Blocks", "are", "in", "arbitrary", "order,", "but", "make", "things", "slightly", "prettier", "and", "do", "not", "swap", "order", "when", "producing", "a", "copy.", "*/", "BLOCK_SUBBLOCKS", "(", "new_tree", ")", "=", "blocks_nreverse", "(", "BLOCK_SUBBLOCKS", "(", "new_tree", ")", ")", ";", "return", "new_tree", ";", "}'" ]

[ "Install", "new", "lexical", "TREE_BLOCK", "underneath", "'current_block'" ]

[ "'static", "void", "prepend_lexical_block", "(", "tree", "current_block", ",", "tree", "new_block", ")", "{", "BLOCK_CHAIN", "(", "new_block", ")", "=", "BLOCK_SUBBLOCKS", "(", "current_block", ")", ";", "BLOCK_SUBBLOCKS", "(", "current_block", ")", "=", "new_block", ";", "BLOCK_SUPERCONTEXT", "(", "new_block", ")", "=", "current_block", ";", "}'" ]

[ "Remap", "DECL", "during", "the", "copying", "of", "the", "BLOCK", "tree", "for", "the", "function" ]

[ "\"tree", "remap_decl", "(", "tree", "decl", ",", "copy_body_data", "*", "id", ")", "{", "tree", "*", "n", ";", "/*", "We", "only", "remap", "local", "variables", "in", "the", "current", "function.", "*/", "/*", "See", "if", "we", "have", "remapped", "this", "declaration.", "*/", "n", "=", "id", "->", "decl_map", "->", "get", "(", "decl", ")", ";", "if", "(", "!", "n", "&&", "processing_debug_stmt", ")", "{", "processing_debug_stmt", "=", "-", "1", ";", "return", "decl", ";", "}", "/*", "When", "remapping", "a", "type", "within", "copy_gimple_seq_and_replace_locals,", "all", "necessary", "DECLs", "have", "already", "been", "remapped", "and", "we", "do", "not", "want", "to", "duplicate", "a", "decl", "coming", "from", "outside", "of", "the", "sequence", "we", "are", "copying.", "*/", "if", "(", "!", "n", "&&", "id", "->", "prevent_decl_creation_for_types", "&&", "id", "->", "remapping_type_depth", ">", "0", "&&", "(", "VAR_P", "(", "decl", ")", "||", "TREE_CODE", "(", "decl", ")", "==", "PARM_DECL", ")", ")", "return", "decl", ";", "/*", "If", "we", "didn't", "already", "have", "an", "equivalent", "for", "this", "declaration,", "create", "one", "now.", "*/", "if", "(", "!", "n", ")", "{", "/*", "Make", "a", "copy", "of", "the", "variable", "or", "label.", "*/", "tree", "t", "=", "id", "->", "copy_decl", "(", "decl", ",", "id", ")", ";", "/*", "Remember", "it,", "so", "that", "if", "we", "encounter", "this", "local", "entity", "again", "we", "can", "reuse", "this", "copy.", "Do", "this", "early", "because", "remap_type", "may", "need", "this", "decl", "for", "TYPE_STUB_DECL.", "*/", "insert_decl_map", "(", "id", ",", "decl", ",", "t", ")", ";", "if", "(", "!", "DECL_P", "(", "t", ")", ")", "return", "t", ";", "/*", "Remap", "types,", "if", "necessary.", "*/", "TREE_TYPE", "(", "t", ")", "=", "remap_type", "(", "TREE_TYPE", "(", "t", ")", ",", "id", ")", ";", "if", "(", "TREE_CODE", "(", "t", ")", "==", "TYPE_DECL", ")", "{", "DECL_ORIGINAL_TYPE", "(", "t", ")", "=", "remap_type", "(", "DECL_ORIGINAL_TYPE", "(", "t", ")", ",", "id", ")", ";", "/*", "Preserve", "the", "invariant", "that", "DECL_ORIGINAL_TYPE", "!=", "TREE_TYPE,", "which", "is", "enforced", "in", "gen_typedef_die", "when", "DECL_ABSTRACT_ORIGIN", "is", "not", "set", "on", "the", "TYPE_DECL,", "for", "example", "in", "LTO", "mode.", "*/", "if", "(", "DECL_ORIGINAL_TYPE", "(", "t", ")", "==", "TREE_TYPE", "(", "t", ")", ")", "{", "tree", "x", "=", "build_variant_type_copy", "(", "TREE_TYPE", "(", "t", ")", ")", ";", "TYPE_STUB_DECL", "(", "x", ")", "=", "TYPE_STUB_DECL", "(", "TREE_TYPE", "(", "t", ")", ")", ";", "TYPE_NAME", "(", "x", ")", "=", "TYPE_NAME", "(", "TREE_TYPE", "(", "t", ")", ")", ";", "DECL_ORIGINAL_TYPE", "(", "t", ")", "=", "x", ";", "}", "}", "/*", "Remap", "sizes", "as", "necessary.", "*/", "walk_tree", "(", "&", "DECL_SIZE", "(", "t", ")", ",", "copy_tree_body_r", ",", "id", ",", "NULL", ")", ";", "walk_tree", "(", "&", "DECL_SIZE_UNIT", "(", "t", ")", ",", "copy_tree_body_r", ",", "id", ",", "NULL", ")", ";", "/*", "If", "fields,", "do", "likewise", "for", "offset", "and", "qualifier.", "*/", "if", "(", "TREE_CODE", "(", "t", ")", "==", "FIELD_DECL", ")", "{", "walk_tree", "(", "&", "DECL_FIELD_OFFSET", "(", "t", ")", ",", "copy_tree_body_r", ",", "id", ",", "NULL", ")", ";", "if", "(", "TREE_CODE", "(", "DECL_CONTEXT", "(", "t", ")", ")", "==", "QUAL_UNION_TYPE", ")", "walk_tree", "(", "&", "DECL_QUALIFIER", "(", "t", ")", ",", "copy_tree_body_r", ",", "id", ",", "NULL", ")", ";", "}", "return", "t", ";", "}", "if", "(", "id", "->", "do_not_unshare", ")", "return", "*", "n", ";", "else", "return", "unshare_expr", "(", "*", "n", ")", ";", "}\"" ]

[ "Similar,", "but", "operate", "on", "INTEGER_CSTs" ]

[ "'static", "tree", "remap_eh_region_tree_nr", "(", "tree", "old_t_nr", ",", "copy_body_data", "*", "id", ")", "{", "int", "old_nr", ",", "<type", "ref=\"prev\"/>", "new_nr", ";", "old_nr", "=", "tree_to_shwi", "(", "old_t_nr", ")", ";", "new_nr", "=", "remap_eh_region_nr", "(", "old_nr", ",", "id", ")", ";", "return", "build_int_cst", "(", "integer_type_node", ",", "new_nr", ")", ";", "}'" ]

[ "Duplicate", "a", "type,", "fields", "and", "all" ]

[ "'tree", "build_duplicate_type", "(", "tree", "type", ")", "{", "struct", "copy_body_data", "id", ";", "memset", "(", "&", "id", ",", "0", ",", "sizeof", "(", "id", ")", ")", ";", "id", ".", "src_fn", "=", "current_function_decl", ";", "id", ".", "dst_fn", "=", "current_function_decl", ";", "id", ".", "src_cfun", "=", "cfun", ";", "id", ".", "decl_map", "=", "new", "hash_map", "<argument_list", "type=\"generic\">", "<", "tree", ",", "tree", ">", ";", "id", ".", "debug_map", "=", "NULL", ";", "id", ".", "copy_decl", "=", "copy_decl_no_change", ";", "type", "=", "remap_type_1", "(", "type", ",", "&", "id", ")", ";", "delete", "id", ".", "decl_map", ";", "if", "(", "id", ".", "debug_map", ")", "delete", "id", ".", "debug_map", ";", "TYPE_CANONICAL", "(", "type", ")", "=", "type", ";", "return", "type", ";", "}'" ]

[ "If", "STMT", "is", "a", "GIMPLE_CALL,", "replace", "it", "with", "its", "inline", "expansion" ]

[ "'static", "bool", "expand_call_inline", "(", "basic_block", "bb", ",", "gimple", "*", "stmt", ",", "copy_body_data", "*", "id", ")", "{", "tree", "use_retvar", ";", "tree", "fn", ";", "hash_map", "<argument_list", "type=\"generic\">", "<", "tree", ",", "tree", ">", "*", "dst", ";", "hash_map", "<argument_list", "type=\"generic\">", "<", "tree", ",", "tree", ">", "*", "st", "=", "NULL", ";", "tree", "return_slot", ";", "tree", "modify_dest", ";", "tree", "return_bounds", "=", "NULL", ";", "struct", "cgraph_edge", "*", "cg_edge", ";", "cgraph_inline_failed_t", "reason", ";", "basic_block", "return_block", ";", "edge", "e", ";", "gimple_stmt_iterator", "gsi", ",", "<type", "ref=\"prev\"/>", "stmt_gsi", ";", "bool", "successfully_inlined", "=", "false", ";", "bool", "purge_dead_abnormal_edges", ";", "gcall", "*", "call_stmt", ";", "unsigned", "int", "i", ";", "unsigned", "int", "prop_mask", ",", "<type", "ref=\"prev\"/>", "src_properties", ";", "struct", "function", "*", "dst_cfun", ";", "tree", "simduid", ";", "use_operand_p", "use", ";", "gimple", "*", "simtenter_stmt", "=", "NULL", ";", "vec", "<argument_list", "type=\"generic\">", "<", "tree", ">", "*", "simtvars_save", ";", "/*", "The", "gimplifier", "uses", "input_location", "in", "too", "many", "places,", "such", "as", "internal_get_tmp_var", "().", "*/", "location_t", "saved_location", "=", "input_location", ";", "input_location", "=", "gimple_location", "(", "stmt", ")", ";", "/*", "From", "here", "on,", "we\\'re", "only", "interested", "in", "CALL_EXPRs.", "*/", "call_stmt", "=", "dyn_cast", "<argument_list", "type=\"generic\">", "<", "gcall", "*", ">", "(", "stmt", ")", ";", "if", "(", "!", "call_stmt", ")", "goto", "egress", ";", "cg_edge", "=", "id", "->", "dst_node", "->", "get_edge", "(", "stmt", ")", ";", "gcc_checking_assert", "(", "cg_edge", ")", ";", "/*", "First,", "see", "if", "we", "can", "figure", "out", "what", "function", "is", "being", "called.", "If", "we", "cannot,", "then", "there", "is", "no", "hope", "of", "inlining", "the", "function.", "*/", "if", "(", "cg_edge", "->", "indirect_unknown_callee", ")", "goto", "egress", ";", "fn", "=", "cg_edge", "->", "callee", "->", "decl", ";", "gcc_checking_assert", "(", "fn", ")", ";", "/*", "If", "FN", "is", "a", "declaration", "of", "a", "function", "in", "a", "nested", "scope", "that", "was", "globally", "declared", "inline,", "we", "don\\'t", "set", "its", "DECL_INITIAL.", "However,", "we", "can\\'t", "blindly", "follow", "DECL_ABSTRACT_ORIGIN", "because", "the", "C++", "front-end", "uses", "it", "for", "cdtors", "to", "refer", "to", "their", "internal", "declarations,", "that", "are", "not", "real", "functions.", "Fortunately", "those", "don\\'t", "have", "trees", "to", "be", "saved,", "so", "we", "can", "tell", "by", "checking", "their", "gimple_body.", "*/", "if", "(", "!", "DECL_INITIAL", "(", "fn", ")", "&&", "DECL_ABSTRACT_ORIGIN", "(", "fn", ")", "&&", "gimple_has_body_p", "(", "DECL_ABSTRACT_ORIGIN", "(", "fn", ")", ")", ")", "fn", "=", "DECL_ABSTRACT_ORIGIN", "(", "fn", ")", ";", "/*", "Don\\'t", "try", "to", "inline", "functions", "that", "are", "not", "well-suited", "to", "inlining.", "*/", "if", "(", "cg_edge", "->", "inline_failed", ")", "{", "reason", "=", "cg_edge", "->", "inline_failed", ";", "/*", "If", "this", "call", "was", "originally", "indirect,", "we", "do", "not", "want", "to", "emit", "any", "inlining", "related", "warnings", "or", "sorry", "messages", "because", "there", "are", "no", "guarantees", "regarding", "those.", "*/", "if", "(", "cg_edge", "->", "indirect_inlining_edge", ")", "goto", "egress", ";", "if", "(", "lookup_attribute", "(", "\"always_inline\"", ",", "DECL_ATTRIBUTES", "(", "fn", ")", ")", "/*", "For", "extern", "inline", "functions", "that", "get", "redefined", "we", "always", "silently", "ignored", "always_inline", "flag.", "Better", "behavior", "would", "be", "to", "be", "able", "to", "keep", "both", "bodies", "and", "use", "extern", "inline", "body", "for", "inlining,", "but", "we", "can\\'t", "do", "that", "because", "frontends", "overwrite", "the", "body.", "*/", "&&", "!", "cg_edge", "->", "callee", "->", "local", ".", "redefined_extern_inline", "/*", "During", "early", "inline", "pass,", "report", "only", "when", "optimization", "is", "not", "turned", "on.", "*/", "&&", "(", "symtab", "->", "global_info_ready", "||", "!", "optimize", "||", "cgraph_inline_failed_type", "(", "reason", ")", "==", "CIF_FINAL_ERROR", ")", "/*", "PR", "20090218-1_0.c.", "Body", "can", "be", "provided", "by", "another", "module.", "*/", "&&", "(", "reason", "!=", "CIF_BODY_NOT_AVAILABLE", "||", "!", "flag_generate_lto", ")", ")", "{", "error", "(", "\"inlining", "failed", "in", "call", "to", "always_inline", "%q+F:", "%s\"", ",", "fn", ",", "cgraph_inline_failed_string", "(", "reason", ")", ")", ";", "if", "(", "gimple_location", "(", "stmt", ")", "!=", "UNKNOWN_LOCATION", ")", "inform", "(", "gimple_location", "(", "stmt", ")", ",", "\"called", "from", "here\"", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "DECL_SOURCE_LOCATION", "(", "cfun", "->", "decl", ")", "!=", "UNKNOWN_LOCATION", ")", "inform", "(", "DECL_SOURCE_LOCATION", "(", "cfun", "->", "decl", ")", ",", "\"called", "from", "this", "function\"", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "warn_inline", "&&", "DECL_DECLARED_INLINE_P", "(", "fn", ")", "&&", "!", "DECL_NO_INLINE_WARNING_P", "(", "fn", ")", "&&", "!", "DECL_IN_SYSTEM_HEADER", "(", "fn", ")", "&&", "reason", "!=", "CIF_UNSPECIFIED", "&&", "!", "lookup_attribute", "(", "\"noinline\"", ",", "DECL_ATTRIBUTES", "(", "fn", ")", ")", "/*", "Do", "not", "warn", "about", "not", "inlined", "recursive", "calls.", "*/", "&&", "!", "cg_edge", "->", "recursive_p", "()", "/*", "Avoid", "warnings", "during", "early", "inline", "pass.", "*/", "&&", "symtab", "->", "global_info_ready", ")", "{", "if", "(", "warning", "(", "OPT_Winline", ",", "\"inlining", "failed", "in", "call", "to", "%q+F:", "%s\"", ",", "fn", ",", "_", "(", "cgraph_inline_failed_string", "(", "reason", ")", ")", ")", ")", "{", "if", "(", "gimple_location", "(", "stmt", ")", "!=", "UNKNOWN_LOCATION", ")", "inform", "(", "gimple_location", "(", "stmt", ")", ",", "\"called", "from", "here\"", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "DECL_SOURCE_LOCATION", "(", "cfun", "->", "decl", ")", "!=", "UNKNOWN_LOCATION", ")", "inform", "(", "DECL_SOURCE_LOCATION", "(", "cfun", "->", "decl", ")", ",", "\"called", "from", "this", "function\"", ")", ";", "}", "}", "goto", "egress", ";", "}", "id", "->", "src_node", "=", "cg_edge", "->", "callee", ";", "/*", "If", "callee", "is", "thunk,", "all", "we", "need", "is", "to", "adjust", "the", "THIS", "pointer", "and", "redirect", "to", "function", "being", "thunked.", "*/", "if", "(", "id", "->", "src_node", "->", "thunk", ".", "thunk_p", ")", "{", "cgraph_edge", "*", "edge", ";", "tree", "virtual_offset", "=", "NULL", ";", "profile_count", "count", "=", "cg_edge", "->", "count", ";", "tree", "op", ";", "gimple_stmt_iterator", "iter", "=", "gsi_for_stmt", "(", "stmt", ")", ";", "cg_edge", "->", "remove", "()", ";", "edge", "=", "id", "->", "src_node", "->", "callees", "->", "clone", "(", "id", "->", "dst_node", ",", "call_stmt", ",", "gimple_uid", "(", "stmt", ")", ",", "profile_count", "::", "one", "()", ",", "profile_count", "::", "one", "()", ",", "true", ")", ";", "edge", "->", "count", "=", "count", ";", "if", "(", "id", "->", "src_node", "->", "thunk", ".", "virtual_offset_p", ")", "virtual_offset", "=", "size_int", "(", "id", "->", "src_node", "->", "thunk", ".", "virtual_value", ")", ";", "op", "=", "create_tmp_reg_fn", "(", "cfun", ",", "TREE_TYPE", "(", "gimple_call_arg", "(", "stmt", ",", "0", ")", ")", ",", "NULL", ")", ";", "gsi_insert_before", "(", "&", "iter", ",", "gimple_build_assign", "(", "op", ",", "gimple_call_arg", "(", "stmt", ",", "0", ")", ")", ",", "GSI_NEW_STMT", ")", ";", "gcc_assert", "(", "id", "->", "src_node", "->", "thunk", ".", "this_adjusting", ")", ";", "op", "=", "thunk_adjust", "(", "&", "iter", ",", "op", ",", "1", ",", "id", "->", "src_node", "->", "thunk", ".", "fixed_offset", ",", "virtual_offset", ")", ";", "gimple_call_set_arg", "(", "stmt", ",", "0", ",", "op", ")", ";", "gimple_call_set_fndecl", "(", "stmt", ",", "edge", "->", "callee", "->", "decl", ")", ";", "update_stmt", "(", "stmt", ")", ";", "id", "->", "src_node", "->", "remove", "()", ";", "expand_call_inline", "(", "bb", ",", "stmt", ",", "id", ")", ";", "maybe_remove_unused_call_args", "(", "cfun", ",", "stmt", ")", ";", "return", "true", ";", "}", "fn", "=", "cg_edge", "->", "callee", "->", "decl", ";", "cg_edge", "->", "callee", "->", "get_untransformed_body", "()", ";", "if", "(", "flag_checking", "&&", "cg_edge", "->", "callee", "->", "decl", "!=", "id", "->", "dst_node", "->", "decl", ")", "cg_edge", "->", "callee", "->", "verify", "()", ";", "/*", "We", "will", "be", "inlining", "this", "callee.", "*/", "id", "->", "eh_lp_nr", "=", "lookup_stmt_eh_lp", "(", "stmt", ")", ";", "id", "->", "assign_stmts", ".", "create", "(", "0", ")", ";", "/*", "Update", "the", "callers", "EH", "personality.", "*/", "if", "(", "DECL_FUNCTION_PERSONALITY", "(", "cg_edge", "->", "callee", "->", "decl", ")", ")", "DECL_FUNCTION_PERSONALITY", "(", "cg_edge", "->", "caller", "->", "decl", ")", "=", "DECL_FUNCTION_PERSONALITY", "(", "cg_edge", "->", "callee", "->", "decl", ")", ";", "/*", "Split", "the", "block", "before", "the", "GIMPLE_CALL.", "*/", "stmt_gsi", "=", "gsi_for_stmt", "(", "stmt", ")", ";", "gsi_prev", "(", "&", "stmt_gsi", ")", ";", "e", "=", "split_block", "(", "bb", ",", "gsi_end_p", "(", "stmt_gsi", ")", "?", "NULL", ":", "gsi_stmt", "(", "stmt_gsi", ")", ")", ";", "bb", "=", "e", "->", "src", ";", "return_block", "=", "e", "->", "dest", ";", "remove_edge", "(", "e", ")", ";", "/*", "If", "the", "GIMPLE_CALL", "was", "in", "the", "last", "statement", "of", "BB,", "it", "may", "have", "been", "the", "source", "of", "abnormal", "edges.", "In", "this", "case,", "schedule", "the", "removal", "of", "dead", "abnormal", "edges.", "*/", "gsi", "=", "gsi_start_bb", "(", "return_block", ")", ";", "gsi_next", "(", "&", "gsi", ")", ";", "purge_dead_abnormal_edges", "=", "gsi_end_p", "(", "gsi", ")", ";", "stmt_gsi", "=", "gsi_start_bb", "(", "return_block", ")", ";", "/*", "Build", "a", "block", "containing", "code", "to", "initialize", "the", "arguments,", "the", "actual", "inline", "expansion", "of", "the", "body,", "and", "a", "label", "for", "the", "return", "statements", "within", "the", "function", "to", "jump", "to.", "The", "type", "of", "the", "statement", "expression", "is", "the", "return", "type", "of", "the", "function", "call.", "???", "If", "the", "call", "does", "not", "have", "an", "associated", "block", "then", "we", "will", "remap", "all", "callee", "blocks", "to", "NULL,", "effectively", "dropping", "most", "of", "its", "debug", "information.", "This", "should", "only", "happen", "for", "calls", "to", "artificial", "decls", "inserted", "by", "the", "compiler", "itself.", "We", "need", "to", "either", "link", "the", "inlined", "blocks", "into", "the", "caller", "block", "tree", "or", "not", "refer", "to", "them", "in", "any", "way", "to", "not", "break", "GC", "for", "locations.", "*/", "if", "(", "gimple_block", "(", "stmt", ")", ")", "{", "id", "->", "block", "=", "make_node", "(", "BLOCK", ")", ";", "BLOCK_ABSTRACT_ORIGIN", "(", "id", "->", "block", ")", "=", "fn", ";", "BLOCK_SOURCE_LOCATION", "(", "id", "->", "block", ")", "=", "LOCATION_LOCUS", "(", "gimple_location", "(", "stmt", ")", ")", ";", "prepend_lexical_block", "(", "gimple_block", "(", "stmt", ")", ",", "id", "->", "block", ")", ";", "}", "/*", "Local", "declarations", "will", "be", "replaced", "by", "their", "equivalents", "in", "this", "map.", "*/", "st", "=", "id", "->", "decl_map", ";", "id", "->", "decl_map", "=", "new", "hash_map", "<argument_list", "type=\"generic\">", "<", "tree", ",", "tree", ">", ";", "dst", "=", "id", "->", "debug_map", ";", "id", "->", "debug_map", "=", "NULL", ";", "/*", "Record", "the", "function", "we", "are", "about", "to", "inline.", "*/", "id", "->", "src_fn", "=", "fn", ";", "id", "->", "src_cfun", "=", "DECL_STRUCT_FUNCTION", "(", "fn", ")", ";", "id", "->", "call_stmt", "=", "call_stmt", ";", "/*", "When", "inlining", "into", "an", "OpenMP", "SIMD-on-SIMT", "loop,", "arrange", "for", "new", "automatic", "variables", "to", "be", "added", "to", "IFN_GOMP_SIMT_ENTER", "argument", "list.", "*/", "dst_cfun", "=", "DECL_STRUCT_FUNCTION", "(", "id", "->", "dst_fn", ")", ";", "simtvars_save", "=", "id", "->", "dst_simt_vars", ";", "if", "(", "!", "(", "dst_cfun", "->", "curr_properties", "&", "PROP_gimple_lomp_dev", ")", "&&", "(", "simduid", "=", "bb", "->", "loop_father", "->", "simduid", ")", "!=", "NULL_TREE", "&&", "(", "simduid", "=", "ssa_default_def", "(", "dst_cfun", ",", "simduid", ")", ")", "!=", "NULL_TREE", "&&", "single_imm_use", "(", "simduid", ",", "&", "use", ",", "&", "simtenter_stmt", ")", "&&", "is_gimple_call", "(", "simtenter_stmt", ")", "&&", "gimple_call_internal_p", "(", "simtenter_stmt", ",", "IFN_GOMP_SIMT_ENTER", ")", ")", "vec_alloc", "(", "id", "->", "dst_simt_vars", ",", "0", ")", ";", "else", "id", "->", "dst_simt_vars", "=", "NULL", ";", "if", "(", "profile_status_for_fn", "(", "id", "->", "src_cfun", ")", "==", "PROFILE_ABSENT", ")", "profile_status_for_fn", "(", "dst_cfun", ")", "=", "PROFILE_ABSENT", ";", "/*", "If", "the", "src", "function", "contains", "an", "IFN_VA_ARG,", "then", "so", "will", "the", "dst", "function", "after", "inlining.", "Likewise", "for", "IFN_GOMP_USE_SIMT.", "*/", "prop_mask", "=", "PROP_gimple_lva", "|", "PROP_gimple_lomp_dev", ";", "src_properties", "=", "id", "->", "src_cfun", "->", "curr_properties", "&", "prop_mask", ";", "if", "(", "src_properties", "!=", "prop_mask", ")", "dst_cfun", "->", "curr_properties", "&=", "src_properties", "|", "~", "prop_mask", ";", "gcc_assert", "(", "!", "id", "->", "src_cfun", "->", "after_inlining", ")", ";", "id", "->", "entry_bb", "=", "bb", ";", "if", "(", "lookup_attribute", "(", "\"cold\"", ",", "DECL_ATTRIBUTES", "(", "fn", ")", ")", ")", "{", "gimple_stmt_iterator", "si", "=", "gsi_last_bb", "(", "bb", ")", ";", "gsi_insert_after", "(", "&", "si", ",", "gimple_build_predict", "(", "PRED_COLD_FUNCTION", ",", "NOT_TAKEN", ")", ",", "GSI_NEW_STMT", ")", ";", "}", "initialize_inlined_parameters", "(", "id", ",", "stmt", ",", "fn", ",", "bb", ")", ";", "if", "(", "debug_nonbind_markers_p", "&&", "debug_inline_points", "&&", "id", "->", "block", "&&", "inlined_function_outer_scope_p", "(", "id", "->", "block", ")", ")", "{", "gimple_stmt_iterator", "si", "=", "gsi_last_bb", "(", "bb", ")", ";", "gsi_insert_after", "(", "&", "si", ",", "gimple_build_debug_inline_entry", "(", "id", "->", "block", ",", "input_location", ")", ",", "GSI_NEW_STMT", ")", ";", "}", "if", "(", "DECL_INITIAL", "(", "fn", ")", ")", "{", "if", "(", "gimple_block", "(", "stmt", ")", ")", "{", "tree", "*", "var", ";", "prepend_lexical_block", "(", "id", "->", "block", ",", "remap_blocks", "(", "DECL_INITIAL", "(", "fn", ")", ",", "id", ")", ")", ";", "gcc_checking_assert", "(", "BLOCK_SUBBLOCKS", "(", "id", "->", "block", ")", "&&", "(", "BLOCK_CHAIN", "(", "BLOCK_SUBBLOCKS", "(", "id", "->", "block", ")", ")", "==", "NULL_TREE", ")", ")", ";", "/*", "Move", "vars", "for", "PARM_DECLs", "from", "DECL_INITIAL", "block", "to", "id->block,", "otherwise", "for", "DWARF", "DW_TAG_formal_parameter", "will", "not", "be", "children", "of", "DW_TAG_inlined_subroutine,", "but", "of", "a", "DW_TAG_lexical_block", "under", "it.", "The", "parameters", "can", "be", "then", "evaluated", "in", "the", "debugger,", "but", "don\\'t", "show", "in", "backtraces.", "*/", "for", "(", "var", "=", "&", "BLOCK_VARS", "(", "BLOCK_SUBBLOCKS", "(", "id", "->", "block", ")", ")", ";", "*", "var", ";", ")", "if", "(", "TREE_CODE", "(", "DECL_ORIGIN", "(", "*", "var", ")", ")", "==", "PARM_DECL", ")", "{", "tree", "v", "=", "*", "var", ";", "*", "var", "=", "TREE_CHAIN", "(", "v", ")", ";", "TREE_CHAIN", "(", "v", ")", "=", "BLOCK_VARS", "(", "id", "->", "block", ")", ";", "BLOCK_VARS", "(", "id", "->", "block", ")", "=", "v", ";", "}", "else", "var", "=", "&", "TREE_CHAIN", "(", "*", "var", ")", ";", "}", "else", "remap_blocks_to_null", "(", "DECL_INITIAL", "(", "fn", ")", ",", "id", ")", ";", "}", "/*", "Return", "statements", "in", "the", "function", "body", "will", "be", "replaced", "by", "jumps", "to", "the", "RET_LABEL.", "*/", "gcc_assert", "(", "DECL_INITIAL", "(", "fn", ")", ")", ";", "gcc_assert", "(", "TREE_CODE", "(", "DECL_INITIAL", "(", "fn", ")", ")", "==", "BLOCK", ")", ";", "/*", "Find", "the", "LHS", "to", "which", "the", "result", "of", "this", "call", "is", "assigned.", "*/", "return_slot", "=", "NULL", ";", "if", "(", "gimple_call_lhs", "(", "stmt", ")", ")", "{", "modify_dest", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "/*", "Remember", "where", "to", "copy", "returned", "bounds.", "*/", "if", "(", "gimple_call_with_bounds_p", "(", "stmt", ")", "&&", "TREE_CODE", "(", "modify_dest", ")", "==", "SSA_NAME", ")", "{", "gcall", "*", "retbnd", "=", "chkp_retbnd_call_by_val", "(", "modify_dest", ")", ";", "if", "(", "retbnd", ")", "{", "return_bounds", "=", "gimple_call_lhs", "(", "retbnd", ")", ";", "/*", "If", "returned", "bounds", "are", "not", "used", "then", "just", "remove", "unused", "call.", "*/", "if", "(", "!", "return_bounds", ")", "{", "gimple_stmt_iterator", "iter", "=", "gsi_for_stmt", "(", "retbnd", ")", ";", "gsi_remove", "(", "&", "iter", ",", "true", ")", ";", "}", "}", "}", "/*", "The", "function", "which", "we", "are", "inlining", "might", "not", "return", "a", "value,", "in", "which", "case", "we", "should", "issue", "a", "warning", "that", "the", "function", "does", "not", "return", "a", "value.", "In", "that", "case", "the", "optimizers", "will", "see", "that", "the", "variable", "to", "which", "the", "value", "is", "assigned", "was", "not", "initialized.", "We", "do", "not", "want", "to", "issue", "a", "warning", "about", "that", "uninitialized", "variable.", "*/", "if", "(", "DECL_P", "(", "modify_dest", ")", ")", "TREE_NO_WARNING", "(", "modify_dest", ")", "=", "1", ";", "if", "(", "gimple_call_return_slot_opt_p", "(", "call_stmt", ")", ")", "{", "return_slot", "=", "modify_dest", ";", "modify_dest", "=", "NULL", ";", "}", "}", "else", "modify_dest", "=", "NULL", ";", "/*", "If", "we", "are", "inlining", "a", "call", "to", "the", "C++", "operator", "new,", "we", "don\\'t", "want", "to", "use", "type", "based", "alias", "analysis", "on", "the", "return", "value.", "Otherwise", "we", "may", "get", "confused", "if", "the", "compiler", "sees", "that", "the", "inlined", "new", "function", "returns", "a", "pointer", "which", "was", "just", "deleted.", "See", "bug", "33407.", "*/", "if", "(", "DECL_IS_OPERATOR_NEW", "(", "fn", ")", ")", "{", "return_slot", "=", "NULL", ";", "modify_dest", "=", "NULL", ";", "}", "/*", "Declare", "the", "return", "variable", "for", "the", "function.", "*/", "use_retvar", "=", "declare_return_variable", "(", "id", ",", "return_slot", ",", "modify_dest", ",", "return_bounds", ",", "bb", ")", ";", "/*", "Add", "local", "vars", "in", "this", "inlined", "callee", "to", "caller.", "*/", "add_local_variables", "(", "id", "->", "src_cfun", ",", "cfun", ",", "id", ")", ";", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "{", "fprintf", "(", "dump_file", ",", "\"Inlining", "%s", "to", "%s", "with", "frequency", "%4.2f\\\"", ",", "id", "->", "src_node", "->", "dump_name", "()", ",", "id", "->", "dst_node", "->", "dump_name", "()", ",", "cg_edge", "->", "sreal_frequency", "()", ".", "to_double", "()", ")", ";", "id", "->", "src_node", "->", "dump", "(", "dump_file", ")", ";", "id", "->", "dst_node", "->", "dump", "(", "dump_file", ")", ";", "}", "/*", "This", "is", "it.", "Duplicate", "the", "callee", "body.", "Assume", "callee", "is", "pre-gimplified.", "Note", "that", "we", "must", "not", "alter", "the", "caller", "function", "in", "any", "way", "before", "this", "point,", "as", "this", "CALL_EXPR", "may", "be", "a", "self-referential", "call;", "if", "we\\'re", "calling", "ourselves,", "we", "need", "to", "duplicate", "our", "body", "before", "altering", "anything.", "*/", "copy_body", "(", "id", ",", "bb", ",", "return_block", ",", "NULL", ")", ";", "reset_debug_bindings", "(", "id", ",", "stmt_gsi", ")", ";", "if", "(", "flag_stack_reuse", "!=", "SR_NONE", ")", "for", "(", "tree", "p", "=", "DECL_ARGUMENTS", "(", "id", "->", "src_fn", ")", ";", "p", ";", "p", "=", "DECL_CHAIN", "(", "p", ")", ")", "if", "(", "!", "TREE_THIS_VOLATILE", "(", "p", ")", ")", "{", "tree", "*", "varp", "=", "id", "->", "decl_map", "->", "get", "(", "p", ")", ";", "if", "(", "varp", "&&", "VAR_P", "(", "*", "varp", ")", "&&", "!", "is_gimple_reg", "(", "*", "varp", ")", ")", "{", "tree", "clobber", "=", "build_constructor", "(", "TREE_TYPE", "(", "*", "varp", ")", ",", "NULL", ")", ";", "gimple", "*", "clobber_stmt", ";", "TREE_THIS_VOLATILE", "(", "clobber", ")", "=", "1", ";", "clobber_stmt", "=", "gimple_build_assign", "(", "*", "varp", ",", "clobber", ")", ";", "gimple_set_location", "(", "clobber_stmt", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_insert_before", "(", "&", "stmt_gsi", ",", "clobber_stmt", ",", "GSI_SAME_STMT", ")", ";", "}", "}", "/*", "Reset", "the", "escaped", "solution.", "*/", "if", "(", "cfun", "->", "gimple_df", ")", "pt_solution_reset", "(", "&", "cfun", "->", "gimple_df", "->", "escaped", ")", ";", "/*", "Add", "new", "automatic", "variables", "to", "IFN_GOMP_SIMT_ENTER", "arguments.", "*/", "if", "(", "id", "->", "dst_simt_vars", "&&", "id", "->", "dst_simt_vars", "->", "length", "()", ">", "0", ")", "{", "size_t", "nargs", "=", "gimple_call_num_args", "(", "simtenter_stmt", ")", ";", "vec", "<argument_list", "type=\"generic\">", "<", "tree", ">", "*", "vars", "=", "id", "->", "dst_simt_vars", ";", "auto_vec", "<argument_list", "type=\"generic\">", "<", "tree", ">", "newargs", "(", "nargs", "+", "vars", "->", "length", "()", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "nargs", ";", "i", "++", ")", "newargs", ".", "quick_push", "(", "gimple_call_arg", "(", "simtenter_stmt", ",", "i", ")", ")", ";", "for", "(", "tree", "*", "pvar", "=", "vars", "->", "begin", "()", ";", "pvar", "!=", "vars", "->", "end", "()", ";", "pvar", "++", ")", "{", "tree", "ptrtype", "=", "build_pointer_type", "(", "TREE_TYPE", "(", "*", "pvar", ")", ")", ";", "newargs", ".", "quick_push", "(", "build1", "(", "ADDR_EXPR", ",", "ptrtype", ",", "*", "pvar", ")", ")", ";", "}", "gcall", "*", "g", "=", "gimple_build_call_internal_vec", "(", "IFN_GOMP_SIMT_ENTER", ",", "newargs", ")", ";", "gimple_call_set_lhs", "(", "g", ",", "gimple_call_lhs", "(", "simtenter_stmt", ")", ")", ";", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "simtenter_stmt", ")", ";", "gsi_replace", "(", "&", "gsi", ",", "g", ",", "false", ")", ";", "}", "vec_free", "(", "id", "->", "dst_simt_vars", ")", ";", "id", "->", "dst_simt_vars", "=", "simtvars_save", ";", "/*", "Clean", "up.", "*/", "if", "(", "id", "->", "debug_map", ")", "{", "delete", "id", "->", "debug_map", ";", "id", "->", "debug_map", "=", "dst", ";", "}", "delete", "id", "->", "decl_map", ";", "id", "->", "decl_map", "=", "st", ";", "/*", "Unlink", "the", "calls", "virtual", "operands", "before", "replacing", "it.", "*/", "unlink_stmt_vdef", "(", "stmt", ")", ";", "if", "(", "gimple_vdef", "(", "stmt", ")", "&&", "TREE_CODE", "(", "gimple_vdef", "(", "stmt", ")", ")", "==", "SSA_NAME", ")", "release_ssa_name", "(", "gimple_vdef", "(", "stmt", ")", ")", ";", "/*", "If", "the", "inlined", "function", "returns", "a", "result", "that", "we", "care", "about,", "substitute", "the", "GIMPLE_CALL", "with", "an", "assignment", "of", "the", "return", "variable", "to", "the", "LHS", "of", "the", "call.", "That", "is,", "if", "STMT", "was", "\\'a", "=", "foo", "(...)\\',", "substitute", "the", "call", "with", "\\'a", "=", "USE_RETVAR\\'.", "*/", "if", "(", "use_retvar", "&&", "gimple_call_lhs", "(", "stmt", ")", ")", "{", "gimple", "*", "old_stmt", "=", "stmt", ";", "stmt", "=", "gimple_build_assign", "(", "gimple_call_lhs", "(", "stmt", ")", ",", "use_retvar", ")", ";", "gsi_replace", "(", "&", "stmt_gsi", ",", "stmt", ",", "false", ")", ";", "maybe_clean_or_replace_eh_stmt", "(", "old_stmt", ",", "stmt", ")", ";", "/*", "Append", "a", "clobber", "for", "id->retvar", "if", "easily", "possible.", "*/", "if", "(", "flag_stack_reuse", "!=", "SR_NONE", "&&", "id", "->", "retvar", "&&", "VAR_P", "(", "id", "->", "retvar", ")", "&&", "id", "->", "retvar", "!=", "return_slot", "&&", "id", "->", "retvar", "!=", "modify_dest", "&&", "!", "TREE_THIS_VOLATILE", "(", "id", "->", "retvar", ")", "&&", "!", "is_gimple_reg", "(", "id", "->", "retvar", ")", "&&", "!", "stmt_ends_bb_p", "(", "stmt", ")", ")", "{", "tree", "clobber", "=", "build_constructor", "(", "TREE_TYPE", "(", "id", "->", "retvar", ")", ",", "NULL", ")", ";", "gimple", "*", "clobber_stmt", ";", "TREE_THIS_VOLATILE", "(", "clobber", ")", "=", "1", ";", "clobber_stmt", "=", "gimple_build_assign", "(", "id", "->", "retvar", ",", "clobber", ")", ";", "gimple_set_location", "(", "clobber_stmt", ",", "gimple_location", "(", "old_stmt", ")", ")", ";", "gsi_insert_after", "(", "&", "stmt_gsi", ",", "clobber_stmt", ",", "GSI_SAME_STMT", ")", ";", "}", "/*", "Copy", "bounds", "if", "we", "copy", "structure", "with", "bounds.", "*/", "if", "(", "chkp_function_instrumented_p", "(", "id", "->", "dst_fn", ")", "&&", "!", "BOUNDED_P", "(", "use_retvar", ")", "&&", "chkp_type_has_pointer", "(", "TREE_TYPE", "(", "use_retvar", ")", ")", ")", "id", "->", "assign_stmts", ".", "safe_push", "(", "stmt", ")", ";", "}", "else", "{", "/*", "Handle", "the", "case", "of", "inlining", "a", "function", "with", "no", "return", "statement,", "which", "causes", "the", "return", "value", "to", "become", "undefined.", "*/", "if", "(", "gimple_call_lhs", "(", "stmt", ")", "&&", "TREE_CODE", "(", "gimple_call_lhs", "(", "stmt", ")", ")", "==", "SSA_NAME", ")", "{", "tree", "name", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "tree", "var", "=", "SSA_NAME_VAR", "(", "name", ")", ";", "tree", "def", "=", "var", "?", "ssa_default_def", "(", "cfun", ",", "var", ")", ":", "NULL", ";", "if", "(", "def", ")", "{", "/*", "If", "the", "variable", "is", "used", "undefined,", "make", "this", "name", "undefined", "via", "a", "move.", "*/", "stmt", "=", "gimple_build_assign", "(", "gimple_call_lhs", "(", "stmt", ")", ",", "def", ")", ";", "gsi_replace", "(", "&", "stmt_gsi", ",", "stmt", ",", "true", ")", ";", "}", "else", "{", "if", "(", "!", "var", ")", "{", "var", "=", "create_tmp_reg_fn", "(", "cfun", ",", "TREE_TYPE", "(", "name", ")", ",", "NULL", ")", ";", "SET_SSA_NAME_VAR_OR_IDENTIFIER", "(", "name", ",", "var", ")", ";", "}", "/*", "Otherwise", "make", "this", "variable", "undefined.", "*/", "gsi_remove", "(", "&", "stmt_gsi", ",", "true", ")", ";", "set_ssa_default_def", "(", "cfun", ",", "var", ",", "name", ")", ";", "SSA_NAME_DEF_STMT", "(", "name", ")", "=", "gimple_build_nop", "()", ";", "}", "}", "/*", "Replace", "with", "a", "clobber", "for", "id->retvar.", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "flag_stack_reuse", "!=", "SR_NONE", "&&", "id", "->", "retvar", "&&", "VAR_P", "(", "id", "->", "retvar", ")", "&&", "id", "->", "retvar", "!=", "return_slot", "&&", "id", "->", "retvar", "!=", "modify_dest", "&&", "!", "TREE_THIS_VOLATILE", "(", "id", "->", "retvar", ")", "&&", "!", "is_gimple_reg", "(", "id", "->", "retvar", ")", ")", "{", "tree", "clobber", "=", "build_constructor", "(", "TREE_TYPE", "(", "id", "->", "retvar", ")", ",", "NULL", ")", ";", "gimple", "*", "clobber_stmt", ";", "TREE_THIS_VOLATILE", "(", "clobber", ")", "=", "1", ";", "clobber_stmt", "=", "gimple_build_assign", "(", "id", "->", "retvar", ",", "clobber", ")", ";", "gimple_set_location", "(", "clobber_stmt", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "&", "stmt_gsi", ",", "clobber_stmt", ",", "false", ")", ";", "maybe_clean_or_replace_eh_stmt", "(", "stmt", ",", "clobber_stmt", ")", ";", "}", "else", "gsi_remove", "(", "&", "stmt_gsi", ",", "true", ")", ";", "}", "/*", "Put", "returned", "bounds", "into", "the", "correct", "place", "if", "required.", "*/", "if", "(", "return_bounds", ")", "{", "gimple", "*", "old_stmt", "=", "SSA_NAME_DEF_STMT", "(", "return_bounds", ")", ";", "gimple", "*", "new_stmt", "=", "gimple_build_assign", "(", "return_bounds", ",", "id", "->", "retbnd", ")", ";", "gimple_stmt_iterator", "bnd_gsi", "=", "gsi_for_stmt", "(", "old_stmt", ")", ";", "unlink_stmt_vdef", "(", "old_stmt", ")", ";", "gsi_replace", "(", "&", "bnd_gsi", ",", "new_stmt", ",", "false", ")", ";", "maybe_clean_or_replace_eh_stmt", "(", "old_stmt", ",", "new_stmt", ")", ";", "cgraph_update_edges_for_call_stmt", "(", "old_stmt", ",", "gimple_call_fndecl", "(", "old_stmt", ")", ",", "new_stmt", ")", ";", "}", "if", "(", "purge_dead_abnormal_edges", ")", "{", "gimple_purge_dead_eh_edges", "(", "return_block", ")", ";", "gimple_purge_dead_abnormal_call_edges", "(", "return_block", ")", ";", "}", "/*", "If", "the", "value", "of", "the", "new", "expression", "is", "ignored,", "that\\'s", "OK.", "We", "don\\'t", "warn", "about", "this", "for", "CALL_EXPRs,", "so", "we", "shouldn\\'t", "warn", "about", "the", "equivalent", "inlined", "version", "either.", "*/", "if", "(", "is_gimple_assign", "(", "stmt", ")", ")", "{", "gcc_assert", "(", "gimple_assign_single_p", "(", "stmt", ")", "||", "CONVERT_EXPR_CODE_P", "(", "gimple_assign_rhs_code", "(", "stmt", ")", ")", ")", ";", "TREE_USED", "(", "gimple_assign_rhs1", "(", "stmt", ")", ")", "=", "1", ";", "}", "/*", "Copy", "bounds", "for", "all", "generated", "assigns", "that", "need", "it.", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "id", "->", "assign_stmts", ".", "length", "()", ";", "i", "++", ")", "chkp_copy_bounds_for_assign", "(", "id", "->", "assign_stmts", "[", "i", "]", ",", "cg_edge", ")", ";", "id", "->", "assign_stmts", ".", "release", "()", ";", "/*", "Output", "the", "inlining", "info", "for", "this", "abstract", "function,", "since", "it", "has", "been", "inlined.", "If", "we", "don\\'t", "do", "this", "now,", "we", "can", "lose", "the", "information", "about", "the", "variables", "in", "the", "function", "when", "the", "blocks", "get", "blown", "away", "as", "soon", "as", "we", "remove", "the", "cgraph", "node.", "*/", "if", "(", "gimple_block", "(", "stmt", ")", ")", "(", "*", "debug_hooks", "->", "outlining_inline_function", ")", "(", "cg_edge", "->", "callee", "->", "decl", ")", ";", "/*", "Update", "callgraph", "if", "needed.", "*/", "cg_edge", "->", "callee", "->", "remove", "()", ";", "id", "->", "block", "=", "NULL_TREE", ";", "id", "->", "retvar", "=", "NULL_TREE", ";", "id", "->", "retbnd", "=", "NULL_TREE", ";", "successfully_inlined", "=", "true", ";", "egress", ":", "input_location", "=", "saved_location", ";", "return", "successfully_inlined", ";", "}'" ]

[ "Call", "cgraph_redirect_edge_call_stmt_to_callee", "on", "all", "calls", "in", "BB" ]

[ "'void", "redirect_all_calls", "(", "copy_body_data", "*", "id", ",", "basic_block", "bb", ")", "{", "gimple_stmt_iterator", "si", ";", "gimple", "*", "last", "=", "last_stmt", "(", "bb", ")", ";", "for", "(", "si", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "si", ")", ";", "gsi_next", "(", "&", "si", ")", ")", "{", "gimple", "*", "stmt", "=", "gsi_stmt", "(", "si", ")", ";", "if", "(", "is_gimple_call", "(", "stmt", ")", ")", "{", "struct", "cgraph_edge", "*", "edge", "=", "id", "->", "dst_node", "->", "get_edge", "(", "stmt", ")", ";", "if", "(", "edge", ")", "{", "edge", "->", "redirect_call_stmt_to_callee", "()", ";", "if", "(", "stmt", "==", "last", "&&", "id", "->", "call_stmt", "&&", "maybe_clean_eh_stmt", "(", "stmt", ")", ")", "gimple_purge_dead_eh_edges", "(", "bb", ")", ";", "}", "}", "}", "}'" ]

[ "Remap", "the", "block", "tree", "rooted", "at", "BLOCK", "to", "nothing" ]

[ "'static", "void", "remap_blocks_to_null", "(", "tree", "block", ",", "copy_body_data", "*", "id", ")", "{", "tree", "t", ";", "insert_decl_map", "(", "id", ",", "block", ",", "NULL_TREE", ")", ";", "for", "(", "t", "=", "BLOCK_SUBBLOCKS", "(", "block", ")", ";", "t", ";", "t", "=", "BLOCK_CHAIN", "(", "t", ")", ")", "remap_blocks_to_null", "(", "t", ",", "id", ")", ";", "}'" ]

[ "Expand", "calls", "to", "inline", "functions", "in", "the", "body", "of", "FN" ]

[ "'unsigned", "int", "optimize_inline_calls", "(", "tree", "fn", ")", "{", "copy_body_data", "id", ";", "basic_block", "bb", ";", "int", "last", "=", "n_basic_blocks_for_fn", "(", "cfun", ")", ";", "bool", "inlined_p", "=", "false", ";", "/*", "Clear", "out", "ID.", "*/", "memset", "(", "&", "id", ",", "0", ",", "sizeof", "(", "id", ")", ")", ";", "id", ".", "src_node", "=", "id", ".", "dst_node", "=", "cgraph_node", "::", "get", "(", "fn", ")", ";", "gcc_assert", "(", "id", ".", "dst_node", "->", "definition", ")", ";", "id", ".", "dst_fn", "=", "fn", ";", "/*", "Or", "any", "functions", "that", "aren\\'t", "finished", "yet.", "*/", "if", "(", "current_function_decl", ")", "id", ".", "dst_fn", "=", "current_function_decl", ";", "id", ".", "copy_decl", "=", "copy_decl_maybe_to_var", ";", "id", ".", "transform_call_graph_edges", "=", "CB_CGE_DUPLICATE", ";", "id", ".", "transform_new_cfg", "=", "false", ";", "id", ".", "transform_return_to_modify", "=", "true", ";", "id", ".", "transform_parameter", "=", "true", ";", "id", ".", "transform_lang_insert_block", "=", "NULL", ";", "id", ".", "statements_to_fold", "=", "new", "hash_set", "<argument_list", "type=\"generic\">", "<", "gimple", "*", ">", ";", "push_gimplify_context", "()", ";", "/*", "We", "make", "no", "attempts", "to", "keep", "dominance", "info", "up-to-date.", "*/", "free_dominance_info", "(", "CDI_DOMINATORS", ")", ";", "free_dominance_info", "(", "CDI_POST_DOMINATORS", ")", ";", "/*", "Register", "specific", "gimple", "functions.", "*/", "gimple_register_cfg_hooks", "()", ";", "/*", "Reach", "the", "trees", "by", "walking", "over", "the", "CFG,", "and", "note", "the", "enclosing", "basic-blocks", "in", "the", "call", "edges.", "*/", "/*", "We", "walk", "the", "blocks", "going", "forward,", "because", "inlined", "function", "bodies", "will", "split", "id->current_basic_block,", "and", "the", "new", "blocks", "will", "follow", "it;", "we\\'ll", "trudge", "through", "them,", "processing", "their", "CALL_EXPRs", "along", "the", "way.", "*/", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "inlined_p", "|=", "gimple_expand_calls_inline", "(", "bb", ",", "&", "id", ")", ";", "pop_gimplify_context", "(", "NULL", ")", ";", "if", "(", "flag_checking", ")", "{", "struct", "cgraph_edge", "*", "e", ";", "id", ".", "dst_node", "->", "verify", "()", ";", "/*", "Double", "check", "that", "we", "inlined", "everything", "we", "are", "supposed", "to", "inline.", "*/", "for", "(", "e", "=", "id", ".", "dst_node", "->", "callees", ";", "e", ";", "e", "=", "e", "->", "next_callee", ")", "gcc_assert", "(", "e", "->", "inline_failed", ")", ";", "}", "/*", "Fold", "queued", "statements.", "*/", "update_max_bb_count", "()", ";", "fold_marked_statements", "(", "last", ",", "id", ".", "statements_to_fold", ")", ";", "delete", "id", ".", "statements_to_fold", ";", "gcc_assert", "(", "!", "id", ".", "debug_stmts", ".", "exists", "()", ")", ";", "/*", "If", "we", "didn\\'t", "inline", "into", "the", "function", "there", "is", "nothing", "to", "do.", "*/", "if", "(", "!", "inlined_p", ")", "return", "0", ";", "/*", "Renumber", "the", "lexical", "scoping", "(non-code)", "blocks", "consecutively.", "*/", "number_blocks", "(", "fn", ")", ";", "delete_unreachable_blocks_update_callgraph", "(", "&", "id", ")", ";", "if", "(", "flag_checking", ")", "id", ".", "dst_node", "->", "verify", "()", ";", "/*", "It", "would", "be", "nice", "to", "check", "SSA/CFG/statement", "consistency", "here,", "but", "it", "is", "not", "possible", "yet", "-", "the", "IPA", "passes", "might", "make", "various", "functions", "to", "not", "throw", "and", "they", "don\\'t", "care", "to", "proactively", "update", "local", "EH", "info.", "This", "is", "done", "later", "in", "fixup_cfg", "pass", "that", "also", "execute", "the", "verification.", "*/", "return", "(", "TODO_update_ssa", "|", "TODO_cleanup_cfg", "|", "(", "gimple_in_ssa_p", "(", "cfun", ")", "?", "TODO_remove_unused_locals", ":", "0", ")", "|", "(", "gimple_in_ssa_p", "(", "cfun", ")", "?", "TODO_update_address_taken", ":", "0", ")", "|", "(", "profile_status_for_fn", "(", "cfun", ")", "!=", "PROFILE_ABSENT", "?", "TODO_rebuild_frequencies", ":", "0", ")", ")", ";", "}'" ]

[ "Allow", "someone", "to", "determine", "if", "SEARCH", "is", "a", "child", "of", "TOP", "from", "gdb" ]

[ "'static", "tree", "debug_find_tree_1", "(", "tree", "*", "tp", ",", "int", "*", "walk_subtrees", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "if", "(", "*", "tp", "==", "data", ")", "return", "(", "tree", ")", "data", ";", "else", "return", "NULL", ";", "}'" ]

[ "sockem", "internal", "persocket", "forwarder", "thread" ]

[ "'static", "void", "*", "sockem_run", "(", "void", "*", "arg", ")", "{", "sockem_t", "*", "skm", "=", "arg", ";", "int", "cs", "=", "-", "1", ";", "int", "ls", ";", "struct", "pollfd", "pfd", "[", "2", "]", ";", "mtx_lock", "(", "&", "skm", "->", "lock", ")", ";", "if", "(", "skm", "->", "run", "==", "SOCKEM_START", ")", "skm", "->", "run", "=", "SOCKEM_RUN", ";", "sockem_conf_use", "(", "skm", ")", ";", "ls", "=", "skm", "->", "ls", ";", "mtx_unlock", "(", "&", "skm", "->", "lock", ")", ";", "skm", "->", "recv_bufsz", "=", "skm", "->", "use", ".", "recv_bufsz", ";", "skm", "->", "recv_buf", "=", "malloc", "(", "skm", "->", "recv_bufsz", ")", ";", "/*", "Accept", "connection", "from", "sockfd", "in", "sockem_connect()", "*/", "cs", "=", "accept", "(", "ls", ",", "NULL", ",", "0", ")", ";", "if", "(", "cs", "==", "-", "1", ")", "{", "mtx_lock", "(", "&", "skm", "->", "lock", ")", ";", "if", "(", "skm", "->", "run", "==", "SOCKEM_TERM", ")", "{", "/*", "App", "socket", "was", "closed.", "*/", "goto", "done", ";", "}", "fprintf", "(", "stderr", ",", "\"%%", "sockem:", "accept(%d)", "failed:", "%s\\\"", ",", "ls", ",", "strerror", "(", "socket_errno", "()", ")", ")", ";", "assert", "(", "cs", "!=", "-", "1", ")", ";", "}", "/*", "Set", "up", "poll", "(blocking", "IO)", "*/", "memset", "(", "pfd", ",", "0", ",", "sizeof", "(", "pfd", ")", ")", ";", "pfd", "[", "1", "]", ".", "fd", "=", "cs", ";", "pfd", "[", "1", "]", ".", "events", "=", "POLLIN", ";", "mtx_lock", "(", "&", "skm", "->", "lock", ")", ";", "pfd", "[", "0", "]", ".", "fd", "=", "skm", "->", "ps", ";", "mtx_unlock", "(", "&", "skm", "->", "lock", ")", ";", "pfd", "[", "0", "]", ".", "events", "=", "POLLIN", ";", "skm", "->", "poll_fd_cnt", "=", "2", ";", "mtx_lock", "(", "&", "skm", "->", "lock", ")", ";", "while", "(", "skm", "->", "run", "==", "SOCKEM_RUN", ")", "{", "int", "r", ";", "int", "i", ";", "int", "waittime", "=", "sockem_calc_waittime", "(", "skm", ",", "sockem_clock", "()", ")", ";", "mtx_unlock", "(", "&", "skm", "->", "lock", ")", ";", "r", "=", "poll", "(", "pfd", ",", "skm", "->", "poll_fd_cnt", ",", "waittime", ")", ";", "if", "(", "r", "==", "-", "1", ")", "break;", "/*", "Send/forward", "delayed", "buffers", "*/", "mtx_lock", "(", "&", "skm", "->", "lock", ")", ";", "sockem_conf_use", "(", "skm", ")", ";", "if", "(", "sockem_fwd_bufs", "(", "skm", ",", "skm", "->", "ps", ")", "==", "-", "1", ")", "{", "mtx_unlock", "(", "&", "skm", "->", "lock", ")", ";", "skm", "->", "run", "=", "SOCKEM_TERM", ";", "break;", "}", "mtx_unlock", "(", "&", "skm", "->", "lock", ")", ";", "for", "(", "i", "=", "0", ";", "r", ">", "0", "&&", "i", "<", "2", ";", "i", "++", ")", "{", "if", "(", "pfd", "[", "i", "]", ".", "revents", "&", "(", "POLLHUP", "|", "POLLERR", ")", ")", "{", "skm", "->", "run", "=", "SOCKEM_TERM", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "pfd", "[", "i", "]", ".", "revents", "&", "POLLIN", ")", "{", "if", "(", "sockem_recv_fwd", "(", "skm", ",", "pfd", "[", "i", "]", ".", "fd", ",", "pfd", "[", "i", "^", "1", "]", ".", "fd", ",", "/*", "direct", "mode", "for", "app", "socket", "*", "without", "delay,", "and", "always", "for", "*", "peer", "socket", "(receive", "channel)", "*/", "i", "==", "0", "||", "(", "skm", "->", "use", ".", "direct", "&&", "skm", "->", "bufs_size", "==", "0", ")", ")", "==", "-", "1", ")", "{", "skm", "->", "run", "=", "SOCKEM_TERM", ";", "break;", "}", "}", "}", "mtx_lock", "(", "&", "skm", "->", "lock", ")", ";", "}", "done", ":", "if", "(", "cs", "!=", "-", "1", ")", "sockem_close0", "(", "cs", ")", ";", "sockem_close_all", "(", "skm", ")", ";", "mtx_unlock", "(", "&", "skm", "->", "lock", ")", ";", "free", "(", "skm", "->", "recv_buf", ")", ";", "return", "NULL", ";", "}'" ]

[ "Close", "all", "sockets", "and", "unsets", ">run" ]

[ "'static", "void", "sockem_close_all", "(", "sockem_t", "*", "skm", ")", "{", "int", "serr", "=", "socket_errno", "()", ";", "if", "(", "skm", "->", "ls", "!=", "-", "1", ")", "{", "sockem_close0", "(", "skm", "->", "ls", ")", ";", "skm", "->", "ls", "=", "-", "1", ";", "}", "if", "(", "skm", "->", "ps", "!=", "-", "1", ")", "{", "sockem_close0", "(", "skm", "->", "ps", ")", ";", "skm", "->", "ps", "=", "-", "1", ";", "}", "skm", "->", "run", "=", "SOCKEM_TERM", ";", "errno", "=", "serr", ";", "}'" ]

[ "Set", "single", "conf", "key" ]

[ "'static", "int", "sockem_set0", "(", "sockem_t", "*", "skm", ",", "const", "char", "*", "key", ",", "int", "val", ")", "{", "if", "(", "!", "strcmp", "(", "key", ",", "\"rx.thruput\"", ")", "||", "!", "strcmp", "(", "key", ",", "\"rx.throughput\"", ")", ")", "skm", "->", "conf", ".", "rx_thruput", "=", "val", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcmp", "(", "key", ",", "\"tx.thruput\"", ")", "||", "!", "strcmp", "(", "key", ",", "\"tx.throughput\"", ")", ")", "skm", "->", "conf", ".", "tx_thruput", "=", "val", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcmp", "(", "key", ",", "\"delay\"", ")", ")", "skm", "->", "conf", ".", "delay", "=", "val", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcmp", "(", "key", ",", "\"jitter\"", ")", ")", "skm", "->", "conf", ".", "jitter", "=", "val", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcmp", "(", "key", ",", "\"rx.bufsz\"", ")", ")", "skm", "->", "conf", ".", "recv_bufsz", "=", "val", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcmp", "(", "key", ",", "\"debug\"", ")", ")", "skm", "->", "conf", ".", "debug", "=", "val", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcmp", "(", "key", ",", "\"true\"", ")", ")", ";", "/*", "dummy", "key", "for", "allowing", "non-empty", "but", "default", "config", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strchr", "(", "key", ",", "\\',\\'", ")", ")", "{", "char", "*", "s", "=", "strdupa", "(", "key", ")", ";", "while", "(", "*", "s", ")", "{", "char", "*", "t", "=", "strchr", "(", "s", ",", "\\',\\'", ")", ";", "char", "*", "d", "=", "strchr", "(", "s", ",", "\\'=\\'", ")", ";", "if", "(", "t", ")", "*", "t", "=", "\\'\\\\0\\'", ";", "if", "(", "!", "d", ")", "return", "-", "1", ";", "*", "(", "d", "++", ")", "=", "\\'\\\\0\\'", ";", "if", "(", "sockem_set0", "(", "skm", ",", "s", ",", "atoi", "(", "d", ")", ")", "==", "-", "1", ")", "return", "-", "1", ";", "if", "(", "!", "t", ")", "break;", "s", "+=", "1", ";", "}", "}", "else", "return", "-", "1", ";", "return", "0", ";", "}'" ]

[ "<", "this", "is", "the", "draw", "task", "for", "the", "ui" ]

[ "'static", "int", "draw_entry", "(", "void", "*", "para", ")", "{", "int", "cmd", "=", "0", ";", "int", "ret", "=", "-", "1", ";", "void", "*", "data", "=", "NULL", ";", "ui_touch_t", "touch", ";", "BSP_LCD_Init", "()", ";", "void", "GT911_Init", "(", "void", ")", ";", "GT911_Init", "()", ";", "GT911_InstallHook", "(", "ui_touch", ")", ";", "touch", ".", "x", "=", "CN_UI_ICCID_STATUS_X", "-", "10", ";", "touch", ".", "w", "=", "CN_UI_W", "-", "CN_UI_ICCID_STATUS_X", "+", "10", ";", "touch", ".", "y", "=", "CN_UI_ICCID_ITEMBASE_Y", ";", "touch", ".", "h", "=", "CN_UI_ICCID_END_Y", "-", "CN_UI_ICCID_ITEMBASE_Y", ";", "touch", ".", "hook", "=", "ui_iccid_touch", ";", "ui_touch_register", "(", "&", "touch", ")", ";", "Paint_NewImage", "(", "LCD_WIDTH", ",", "LCD_HEIGHT", ",", "ROTATE_270", ",", "WHITE", ")", ";", "Paint_Clear", "(", "WHITE", ")", ";", "Paint_SetRotate", "(", "ROTATE_270", ")", ";", "draw_theme", "(", "0", ")", ";", "draw_csq", "(", "0", ")", ";", "draw_rssi", "(", "0", ")", ";", "draw_operator", "(", "0", ")", ";", "draw_dmp", "(", "0", ")", ";", "draw_eid", "(", "0", ")", ";", "draw_iccid", "(", "0", ")", ";", "draw_time", "(", "0", ")", ";", "draw_logo", "(", "0", ")", ";", "while", "(", "1", ")", "{", "ret", "=", "queue_pop", "(", "s_app_main_cb", ".", "draw_cmd_queue", ",", "&", "data", ",", "cn_osal_timeout_forever", ")", ";", "if", "(", "0", "==", "ret", ")", "{", "cmd", "=", "(", "int", ")", "data", ";", "switch", "(", "cmd", ")", "{", "case", "en_app_cmd_draw_csq", ":", "draw_csq", "(", "1", ")", ";", "break;", "case", "en_app_cmd_draw_rssi", ":", "draw_rssi", "(", "1", ")", ";", "break;", "case", "en_app_cmd_draw_operator", ":", "draw_operator", "(", "1", ")", ";", "break;", "case", "en_app_cmd_draw_dmp", ":", "draw_dmp", "(", "1", ")", ";", "break;", "case", "en_app_cmd_draw_eid", ":", "draw_eid", "(", "1", ")", ";", "break;", "case", "en_app_cmd_draw_iccid", ":", "draw_iccid", "(", "1", ")", ";", "break;", "case", "en_app_cmd_draw_time", ":", "draw_time", "(", "1", ")", ";", "break;", "case", "en_app_cmd_draw_machinestatus", ":", "draw_machinestatus", "(", "1", ")", ";", "break;", "case", "en_app_cmd_draw_network", ":", "draw_networking", "(", "1", ")", ";", "break;", "default:", "break;", "}", "}", "}", "return", "0", ";", "}'" ]

[ "<", "draw", "the", "log" ]

[ "'static", "int", "draw_theme", "(", "int", "fresh", ")", "{", "//Paint_DrawString_EN(50,", "20,", "\"HUAWEI", "OceanLink", "Demo\",", "&Font24,", "LIGHTBLUE,", "BLACK);", "Paint_DrawImage", "(", "g_img_oc", ",", "CN_UI_THEME_BASE_X", ",", "CN_UI_THEME_BASE_Y", ",", "CN_UI_THEME_W", ",", "CN_UI_THEME_IMG_H", ")", ";", "Paint_DrawLine", "(", "CN_UI_THEME_BASE_Y", ",", "CN_UI_THEME_LINE_Y", ",\\\\", "CN_UI_W", ",", "CN_UI_THEME_LINE_Y", ",", "GRAY", ",", "LINE_STYLE_SOLID", ",", "DOT_PIXEL_3X3", ")", ";", "return", "0", ";", "}'" ]

[ "<", "do", "the", "touch", "filter", "here" ]

[ "'static", "int", "ui_touch", "(", "int", "x_t", ",", "int", "y_t", ")", "{", "int", "i", "=", "0", ";", "int", "y", ";", "int", "x", ";", "static", "unsigned", "long", "long", "time_last", "=", "0", ";", "unsigned", "long", "long", "time_now", "=", "0", ";", "<comment_type=\"line\"", "format=\"doxygen\">", "///<", "do", "the", "change", "x", "=", "480", "-", "y_t", ";", "y", "=", "x_t", ";", "time_now", "=", "osal_sys_time", "()", ";", "if", "(", "(", "time_now", "-", "time_last", ")", "<=", "500", ")", "{", "time_last", "=", "time_now", ";", "return", "0", ";", "}", "time_last", "=", "time_now", ";", "printf", "(", "\"TOUCH:X:%d", "Y:%d", "%d", "\\\\\\r\"", ",", "x", ",", "y", ",", "(", "int", ")", "time_now", ")", ";", "<comment_type=\"line\"", "format=\"doxygen\">", "///<", "find", "the", "match", "one", "and", "execute", "for", "(", "i", "=", "0", ";", "i", "<", "CN_TOUCH_HOOK_NUM", ";", "i", "++", ")", "{", "if", "(", "(", "NULL", "!=", "s_ui_touch", "[", "i", "]", ".", "hook", ")", "&&", "\\\\", "(", "x", ">", "s_ui_touch", "[", "i", "]", ".", "x", ")", "&&", "(", "x", "<", "(", "s_ui_touch", "[", "i", "]", ".", "x", "+", "s_ui_touch", "[", "i", "]", ".", "w", ")", ")", "&&", "\\\\", "(", "y", ">", "s_ui_touch", "[", "i", "]", ".", "y", ")", "&&", "(", "y", "<", "(", "s_ui_touch", "[", "i", "]", ".", "y", "+", "s_ui_touch", "[", "i", "]", ".", "h", ")", ")", ")", "{", "s_ui_touch", "[", "i", "]", ".", "hook", "(", "x", ",", "y", ")", ";", "}", "}", "return", "0", ";", "}'" ]

[ "<", "THE", "TOUCH", "X", "Y", "NOT", "THE", "SAME", "AS", "THE", "PAIN:ROTATE", "270" ]

[ "'static", "int", "ui_iccid_touch", "(", "int", "x", ",", "int", "y", ")", "{", "unsigned", "int", "card", "=", "0", ";", "card", "=", "(", "y", "-", "CN_UI_ICCID_ITEMBASE_Y", ")", "/", "CN_UI_FONT_H", ";", "if", "(", "card", "<", "s_app_main_cb", ".", "iccid_tab", ".", "num", ")", "{", "printf", "(", "\"CARD", "SELECT:%d", "\\\\\\r\"", ",", "card", ")", ";", "s_app_main_cb", ".", "card_select", "=", "card", ";", "(", "void", ")", "osal_semp_post", "(", "s_app_main_cb", ".", "card_select_sync", ")", ";", "}", "return", "card", ";", "}'" ]

[ "Recompute", "TYPE_CANONICAL", "for", "NODE", "and", "related", "types" ]

[ "'static", "void", "lto_register_canonical_types", "(", "tree", "node", ",", "bool", "first_p", ")", "{", "if", "(", "!", "node", "||", "!", "TYPE_P", "(", "node", ")", ")", "return", ";", "if", "(", "first_p", ")", "TYPE_CANONICAL", "(", "node", ")", "=", "NULL_TREE", ";", "if", "(", "POINTER_TYPE_P", "(", "node", ")", "||", "TREE_CODE", "(", "node", ")", "==", "COMPLEX_TYPE", "||", "TREE_CODE", "(", "node", ")", "==", "ARRAY_TYPE", ")", "lto_register_canonical_types", "(", "TREE_TYPE", "(", "node", ")", ",", "first_p", ")", ";", "if", "(", "!", "first_p", ")", "gimple_register_canonical_type", "(", "node", ")", ";", "}'" ]

[ "Delete", "an", "allocated", "integer", "KEY", "in", "the", "splay", "tree" ]

[ "'static", "void", "lto_splay_tree_delete_id", "(", "splay_tree_key", "key", ")", "{", "free", "(", "(", "void", "*", ")", "key", ")", ";", "}'" ]

[ "Check", "if", "T", "is", "a", "decl", "and", "needs", "register", "its", "resolution", "info" ]

[ "'static", "void", "lto_maybe_register_decl", "(", "struct", "data_in", "*", "data_in", ",", "tree", "t", ",", "unsigned", "ix", ")", "{", "if", "(", "TREE_CODE", "(", "t", ")", "==", "VAR_DECL", ")", "lto_register_var_decl_in_symtab", "(", "data_in", ",", "t", ",", "ix", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "TREE_CODE", "(", "t", ")", "==", "FUNCTION_DECL", "&&", "!", "DECL_BUILT_IN", "(", "t", ")", ")", "lto_register_function_decl_in_symtab", "(", "data_in", ",", "t", ",", "ix", ")", ";", "}'" ]

[ "Actually", "stream", "out", "ENCODER", "into", "TEMP_FILENAME" ]

[ "'static", "void", "do_stream_out", "(", "char", "*", "temp_filename", ",", "lto_symtab_encoder_t", "encoder", ")", "{", "lto_file", "*", "file", "=", "lto_obj_file_open", "(", "temp_filename", ",", "true", ")", ";", "if", "(", "!", "file", ")", "fatal_error", "(", "input_location", ",", "\"lto_obj_file_open()", "failed\"", ")", ";", "lto_set_current_out_file", "(", "file", ")", ";", "ipa_write_optimization_summaries", "(", "encoder", ")", ";", "free", "(", "CONST_CAST", "(", "char", "*", ",", "file", "->", "filename", ")", ")", ";", "lto_set_current_out_file", "(", "NULL", ")", ";", "lto_obj_file_close", "(", "file", ")", ";", "free", "(", "file", ")", ";", "}'" ]

[ "Main", "worker", "for", "gimple_register_canonical_type" ]

[ "'static", "void", "gimple_register_canonical_type_1", "(", "tree", "t", ",", "hashval_t", "hash", ")", "{", "void", "*", "*", "slot", ";", "gcc_checking_assert", "(", "TYPE_P", "(", "t", ")", "&&", "!", "TYPE_CANONICAL", "(", "t", ")", "&&", "type_with_alias_set_p", "(", "t", ")", "&&", "canonical_type_used_p", "(", "t", ")", ")", ";", "slot", "=", "htab_find_slot_with_hash", "(", "gimple_canonical_types", ",", "t", ",", "hash", ",", "INSERT", ")", ";", "if", "(", "*", "slot", ")", "{", "tree", "new_type", "=", "(", "tree", ")", "(", "*", "slot", ")", ";", "gcc_checking_assert", "(", "new_type", "!=", "t", ")", ";", "TYPE_CANONICAL", "(", "t", ")", "=", "new_type", ";", "}", "else", "{", "TYPE_CANONICAL", "(", "t", ")", "=", "t", ";", "*", "slot", "=", "(", "void", "*", ")", "t", ";", "/*", "Cache", "the", "just", "computed", "hash", "value.", "*/", "num_canonical_type_hash_entries", "++", ";", "bool", "existed_p", "=", "canonical_type_hash_cache", "->", "put", "(", "t", ",", "hash", ")", ";", "gcc_assert", "(", "!", "existed_p", ")", ";", "}", "}'" ]

[ "Returns", "nonzero", "if", "P1", "and", "P2", "are", "equal" ]

[ "'static", "int", "gimple_canonical_type_eq", "(", "const", "void", "*", "p1", ",", "const", "void", "*", "p2", ")", "{", "const_tree", "t1", "=", "(", "const_tree", ")", "p1", ";", "const_tree", "t2", "=", "(", "const_tree", ")", "p2", ";", "return", "gimple_canonical_types_compatible_p", "(", "CONST_CAST_TREE", "(", "t1", ")", ",", "CONST_CAST_TREE", "(", "t2", ")", ")", ";", "}'" ]

[ "Returns", "the", "hash", "for", "a", "canonical", "type", "P" ]

[ "'static", "hashval_t", "gimple_canonical_type_hash", "(", "const", "void", "*", "p", ")", "{", "num_canonical_type_hash_queries", "++", ";", "hashval_t", "*", "slot", "=", "canonical_type_hash_cache", "->", "get", "(", "(", "const_tree", ")", "p", ")", ";", "gcc_assert", "(", "slot", "!=", "NULL", ")", ";", "return", "*", "slot", ";", "}'" ]

[ "Check", "presence", "of", "pointers", "to", "decls", "in", "fields", "of", "a", "decl_common", "T" ]

[ "'static", "inline", "bool", "mentions_vars_p_decl_common", "(", "tree", "t", ")", "{", "if", "(", "mentions_vars_p_decl_minimal", "(", "t", ")", ")", "return", "true", ";", "CHECK_VAR", "(", "DECL_SIZE", "(", "t", ")", ")", ";", "CHECK_VAR", "(", "DECL_SIZE_UNIT", "(", "t", ")", ")", ";", "CHECK_VAR", "(", "DECL_INITIAL", "(", "t", ")", ")", ";", "CHECK_NO_VAR", "(", "DECL_ATTRIBUTES", "(", "t", ")", ")", ";", "CHECK_VAR", "(", "DECL_ABSTRACT_ORIGIN", "(", "t", ")", ")", ";", "return", "false", ";", "}'" ]

[ "We", "need", "to", "record", "resolutions", "until", "symbol", "table", "is", "read" ]

[ "'static", "void", "register_resolution", "(", "struct", "lto_file_decl_data", "*", "file_data", ",", "tree", "decl", ",", "enum", "ld_plugin_symbol_resolution", "resolution", ")", "{", "bool", "existed", ";", "if", "(", "resolution", "==", "LDPR_UNKNOWN", ")", "return", ";", "if", "(", "!", "file_data", "->", "resolution_map", ")", "file_data", "->", "resolution_map", "=", "new", "hash_map", "<argument_list", "type=\"generic\">", "<", "tree", ",", "ld_plugin_symbol_resolution", ">", ";", "ld_plugin_symbol_resolution_t", "&", "res", "=", "file_data", "->", "resolution_map", "->", "get_or_insert", "(", "decl", ",", "&", "existed", ")", ";", "if", "(", "!", "existed", "||", "resolution", "==", "LDPR_PREVAILING_DEF_IRONLY", "||", "resolution", "==", "LDPR_PREVAILING_DEF", "||", "resolution", "==", "LDPR_PREVAILING_DEF_IRONLY_EXP", ")", "res", "=", "resolution", ";", "}'" ]

[ "Materialize", "all", "the", "bodies", "for", "all", "the", "nodes", "in", "the", "callgraph" ]

[ "'static", "void", "materialize_cgraph", "(", "void", ")", "{", "struct", "cgraph_node", "*", "node", ";", "timevar_id_t", "lto_timer", ";", "if", "(", "!", "quiet_flag", ")", "fprintf", "(", "stderr", ",", "flag_wpa", "?", "\"Materializing", "decls:\"", ":", "\"Reading", "function", "bodies:\"", ")", ";", "FOR_EACH_FUNCTION", "(", "node", ")", "{", "if", "(", "node", "->", "lto_file_data", ")", "{", "lto_materialize_function", "(", "node", ")", ";", "lto_stats", ".", "num_input_cgraph_nodes", "++", ";", "}", "}", "/*", "Start", "the", "appropriate", "timer", "depending", "on", "the", "mode", "that", "we", "are", "operating", "in.", "*/", "lto_timer", "=", "(", "flag_wpa", ")", "?", "TV_WHOPR_WPA", ":", "(", "flag_ltrans", ")", "?", "TV_WHOPR_LTRANS", ":", "TV_LTO", ";", "timevar_push", "(", "lto_timer", ")", ";", "current_function_decl", "=", "NULL", ";", "set_cfun", "(", "NULL", ")", ";", "if", "(", "!", "quiet_flag", ")", "fprintf", "(", "stderr", ",", "\"\\\"", ")", ";", "timevar_pop", "(", "lto_timer", ")", ";", "}'" ]

[ "Compare", "splay", "tree", "node", "ids", "A", "and", "B" ]

[ "'static", "int", "lto_splay_tree_compare_ids", "(", "splay_tree_key", "a", ",", "splay_tree_key", "b", ")", "{", "unsigned", "HOST_WIDE_INT", "ai", ";", "unsigned", "HOST_WIDE_INT", "bi", ";", "ai", "=", "*", "(", "unsigned", "HOST_WIDE_INT", "*", ")", "a", ";", "bi", "=", "*", "(", "unsigned", "HOST_WIDE_INT", "*", ")", "b", ";", "if", "(", "ai", "<", "bi", ")", "return", "-", "1", ";", "<if", "type=\"elseif\">", "else", "if", "(", "ai", ">", "bi", ")", "return", "1", ";", "return", "0", ";", "}'" ]

[ "Show", "various", "memory", "usage", "statistics", "related", "to", "LTO" ]

[ "'static", "void", "print_lto_report_1", "(", "void", ")", "{", "const", "char", "*", "pfx", "=", "(", "flag_lto", ")", "?", "\"LTO\"", ":", "(", "flag_wpa", ")", "?", "\"WPA\"", ":", "\"LTRANS\"", ";", "fprintf", "(", "stderr", ",", "\"%s", "statistics\\\"", ",", "pfx", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "read", "%lu", "SCCs", "of", "average", "size", "%f\\\"", ",", "pfx", ",", "num_sccs_read", ",", "total_scc_size", "/", "(", "double", ")", "num_sccs_read", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "%lu", "tree", "bodies", "read", "in", "total\\\"", ",", "pfx", ",", "total_scc_size", ")", ";", "if", "(", "flag_wpa", "&&", "tree_scc_hash", ")", "{", "fprintf", "(", "stderr", ",", "\"[%s]", "tree", "SCC", "table:", "size", "%ld,", "%ld", "elements,", "\"", "\"collision", "ratio:", "%f\\\"", ",", "pfx", ",", "(", "long", ")", "tree_scc_hash", "->", "size", "()", ",", "(", "long", ")", "tree_scc_hash", "->", "elements", "()", ",", "tree_scc_hash", "->", "collisions", "()", ")", ";", "hash_table", "<argument_list", "type=\"generic\">", "<", "tree_scc_hasher", ">", "::", "iterator", "hiter", ";", "tree_scc", "*", "scc", ",", "<type", "ref=\"prev\">", "*", "max_scc", "=", "NULL", ";", "unsigned", "max_length", "=", "0", ";", "FOR_EACH_HASH_TABLE_ELEMENT", "(", "*tree_scc_hash", ",", "scc", ",", "x", ",", "hiter", ")", "{", "unsigned", "length", "=", "0", ";", "tree_scc", "*", "s", "=", "scc", ";", "for", "(", ";", "s", ";", "s", "=", "s", "->", "next", ")", "length", "++", ";", "if", "(", "length", ">", "max_length", ")", "{", "max_length", "=", "length", ";", "max_scc", "=", "scc", ";", "}", "}", "fprintf", "(", "stderr", ",", "\"[%s]", "tree", "SCC", "max", "chain", "length", "%u", "(size", "%u)\\\"", ",", "pfx", ",", "max_length", ",", "max_scc", "->", "len", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "Compared", "%lu", "SCCs,", "%lu", "collisions", "(%f)\\\"", ",", "pfx", ",", "num_scc_compares", ",", "num_scc_compare_collisions", ",", "num_scc_compare_collisions", "/", "(", "double", ")", "num_scc_compares", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "Merged", "%lu", "SCCs\\\"", ",", "pfx", ",", "num_sccs_merged", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "Merged", "%lu", "tree", "bodies\\\"", ",", "pfx", ",", "total_scc_size_merged", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "Merged", "%lu", "types\\\"", ",", "pfx", ",", "num_merged_types", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "%lu", "types", "prevailed", "(%lu", "associated", "trees)\\\"", ",", "pfx", ",", "num_prevailing_types", ",", "num_type_scc_trees", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "GIMPLE", "canonical", "type", "table:", "size", "%ld,", "\"", "\"%ld", "elements,", "%ld", "searches,", "%ld", "collisions", "(ratio:", "%f)\\\"", ",", "pfx", ",", "(", "long", ")", "htab_size", "(", "gimple_canonical_types", ")", ",", "(", "long", ")", "htab_elements", "(", "gimple_canonical_types", ")", ",", "(", "long", ")", "gimple_canonical_types", "->", "searches", ",", "(", "long", ")", "gimple_canonical_types", "->", "collisions", ",", "htab_collisions", "(", "gimple_canonical_types", ")", ")", ";", "fprintf", "(", "stderr", ",", "\"[%s]", "GIMPLE", "canonical", "type", "pointer-map:", "\"", "\"%lu", "elements,", "%ld", "searches\\\"", ",", "pfx", ",", "num_canonical_type_hash_entries", ",", "num_canonical_type_hash_queries", ")", ";", "}", "print_lto_report", "(", "pfx", ")", ";", "}'" ]

[ "Helper", "for", "qsort;", "compare", "partitions", "and", "return", "one", "with", "smaller", "order" ]

[ "'static", "int", "cmp_partitions_order", "(", "const", "void", "*", "a", ",", "const", "void", "*", "b", ")", "{", "const", "struct", "ltrans_partition_def", "*", "pa", "=", "*", "(", "struct", "ltrans_partition_def", "*", "const", "*", ")", "a", ";", "const", "struct", "ltrans_partition_def", "*", "pb", "=", "*", "(", "struct", "ltrans_partition_def", "*", "const", "*", ")", "b", ";", "int", "ordera", "=", "-", "1", ",", "<type", "ref=\"prev\"/>", "orderb", "=", "-", "1", ";", "if", "(", "lto_symtab_encoder_size", "(", "pa", "->", "encoder", ")", ")", "ordera", "=", "lto_symtab_encoder_deref", "(", "pa", "->", "encoder", ",", "0", ")", "->", "order", ";", "if", "(", "lto_symtab_encoder_size", "(", "pb", "->", "encoder", ")", ")", "orderb", "=", "lto_symtab_encoder_deref", "(", "pb", "->", "encoder", ",", "0", ")", "->", "order", ";", "return", "orderb", "-", "ordera", ";", "}'" ]

[ "use", "this", "function", "to", "push", "all", "the", "message", "to", "the", "buffer" ]

[ "'static", "int", "app_msg_deal", "(", "void", "*", "msg", ",", "int", "len", ")", "{", "int", "ret", "=", "-", "1", ";", "if", "(", "len", "<=", "cn_app_rcv_buf_len", ")", "{", "memcpy", "(", "s_rcv_buffer", ",", "msg", ",", "len", ")", ";", "s_rcv_datalen", "=", "len", ";", "osal_semp_post", "(", "s_rcv_sync", ")", ";", "ret", "=", "0", ";", "}", "return", "ret", ";", "}'" ]

[ "Finish", "a", "pass", "over", "all" ]

[ "'bfd_boolean", "_bfd_elf_end_eh_frame_parsing", "(", "struct", "bfd_link_info", "*", "info", ")", "{", "struct", "eh_frame_hdr_info", "*", "hdr_info", ";", "unsigned", "int", "i", ";", "hdr_info", "=", "&", "elf_hash_table", "(", "info", ")", "->", "eh_info", ";", "if", "(", "info", "->", "eh_frame_hdr_type", "!=", "COMPACT_EH_HDR", "||", "hdr_info", "->", "array_count", "==", "0", ")", "return", "FALSE", ";", "bfd_elf_discard_eh_frame_entry", "(", "hdr_info", ")", ";", "qsort", "(", "hdr_info", "->", "u", ".", "compact", ".", "entries", ",", "hdr_info", "->", "array_count", ",", "sizeof", "(", "asection", "*", ")", ",", "cmp_eh_frame_hdr", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "hdr_info", "->", "array_count", "-", "1", ";", "i", "++", ")", "{", "add_eh_frame_hdr_terminator", "(", "hdr_info", "->", "u", ".", "compact", ".", "entries", "[", "i", "]", ",", "hdr_info", "->", "u", ".", "compact", ".", "entries", "[", "i", "+", "1", "]", ")", ";", "}", "/*", "Add", "a", "CANTUNWIND", "terminator", "after", "the", "last", "entry.", "*/", "add_eh_frame_hdr_terminator", "(", "hdr_info", "->", "u", ".", "compact", ".", "entries", "[", "i", "]", ",", "NULL", ")", ";", "return", "TRUE", ";", "}'" ]

[ "Order", "eh_frame_hdr", "entries", "by", "the", "VMA", "of", "their", "text", "section" ]

[ "'static", "int", "cmp_eh_frame_hdr", "(", "const", "void", "*", "a", ",", "const", "void", "*", "b", ")", "{", "bfd_vma", "text_a", ";", "bfd_vma", "text_b", ";", "asection", "*", "sec", ";", "sec", "=", "*", "(", "asection", "*", "const", "*", ")", "a", ";", "sec", "=", "(", "asection", "*", ")", "elf_section_data", "(", "sec", ")", "->", "sec_info", ";", "text_a", "=", "sec", "->", "output_section", "->", "vma", "+", "sec", "->", "output_offset", ";", "sec", "=", "*", "(", "asection", "*", "const", "*", ")", "b", ";", "sec", "=", "(", "asection", "*", ")", "elf_section_data", "(", "sec", ")", "->", "sec_info", ";", "text_b", "=", "sec", "->", "output_section", "->", "vma", "+", "sec", "->", "output_offset", ";", "if", "(", "text_a", "<", "text_b", ")", "return", "-", "1", ";", "return", "text_a", ">", "text_b", ";", "}'" ]

[ "Return", "the", "width", "of", "FDE", "addresses" ]

[ "'unsigned", "int", "_bfd_elf_eh_frame_address_size", "(", "bfd", "*", "abfd", ",", "const", "asection", "*", "sec", "ATTRIBUTE_UNUSED", ")", "{", "return", "elf_elfheader", "(", "abfd", ")", "->", "e_ident", "[", "EI_CLASS", "]", "==", "ELFCLASS64", "?", "8", ":", "4", ";", "}'" ]

[ "r", "scalarG", "+", "sum(scalars[i]points[i])" ]

[ "'__owur", "static", "int", "ecp_sm2z256_points_mul", "(", "const", "EC_GROUP", "*", "group", ",", "EC_POINT", "*", "r", ",", "const", "BIGNUM", "*", "scalar", ",", "size_t", "num", ",", "const", "EC_POINT", "*", "points", "[]", ",", "const", "BIGNUM", "*", "scalars", "[]", ",", "BN_CTX", "*", "ctx", ")", "{", "int", "i", "=", "0", ",", "<type", "ref=\"prev\"/>", "ret", "=", "0", ",", "<type", "ref=\"prev\"/>", "no_precomp_for_generator", "=", "0", ",", "<type", "ref=\"prev\"/>", "p_is_infinity", "=", "0", ";", "size_t", "j", ";", "unsigned", "char", "p_str", "[", "33", "]", "=", "{", "0", "}", ";", "const", "PRECOMP256_ROW", "*", "preComputedTable", "=", "NULL", ";", "const", "SM2Z256_PRE_COMP", "*", "pre_comp", "=", "NULL", ";", "const", "EC_POINT", "*", "generator", "=", "NULL", ";", "BN_CTX", "*", "new_ctx", "=", "NULL", ";", "const", "BIGNUM", "*", "*", "new_scalars", "=", "NULL", ";", "const", "EC_POINT", "*", "*", "new_points", "=", "NULL", ";", "unsigned", "int", "idx", "=", "0", ";", "const", "unsigned", "int", "window_size", "=", "7", ";", "const", "unsigned", "int", "mask", "=", "(", "1", "<<", "(", "window_size", "+", "1", ")", ")", "-", "1", ";", "unsigned", "int", "wvalue", ";", "ALIGN32", "union", "{", "P256_POINT", "p", ";", "P256_POINT_AFFINE", "a", ";", "}", "t", ",", "<type", "ref=\"prev\"/>", "p", ";", "BIGNUM", "*", "tmp_scalar", ";", "if", "(", "(", "num", "+", "1", ")", "==", "0", "||", "(", "num", "+", "1", ")", ">", "OPENSSL_MALLOC_MAX_NELEMS", "(", "void", "*", ")", ")", "{", "ECerr", "(", "EC_F_ECP_SM2Z256_POINTS_MUL", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "return", "0", ";", "}", "if", "(", "group", "->", "meth", "!=", "r", "->", "meth", ")", "{", "ECerr", "(", "EC_F_ECP_SM2Z256_POINTS_MUL", ",", "EC_R_INCOMPATIBLE_OBJECTS", ")", ";", "return", "0", ";", "}", "if", "(", "(", "scalar", "==", "NULL", ")", "&&", "(", "num", "==", "0", ")", ")", "return", "EC_POINT_set_to_infinity", "(", "group", ",", "r", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "num", ";", "j", "++", ")", "{", "if", "(", "group", "->", "meth", "!=", "points", "[", "j", "]", "->", "meth", ")", "{", "ECerr", "(", "EC_F_ECP_SM2Z256_POINTS_MUL", ",", "EC_R_INCOMPATIBLE_OBJECTS", ")", ";", "return", "0", ";", "}", "}", "if", "(", "ctx", "==", "NULL", ")", "{", "ctx", "=", "new_ctx", "=", "BN_CTX_new", "()", ";", "if", "(", "ctx", "==", "NULL", ")", "goto", "err", ";", "}", "BN_CTX_start", "(", "ctx", ")", ";", "if", "(", "scalar", ")", "{", "generator", "=", "EC_GROUP_get0_generator", "(", "group", ")", ";", "if", "(", "generator", "==", "NULL", ")", "{", "ECerr", "(", "EC_F_ECP_SM2Z256_POINTS_MUL", ",", "EC_R_UNDEFINED_GENERATOR", ")", ";", "goto", "err", ";", "}", "/*", "look", "if", "we", "can", "use", "precomputed", "multiples", "of", "generator", "*/", "pre_comp", "=", "group", "->", "pre_comp", ".", "sm2z256", ";", "if", "(", "pre_comp", ")", "{", "/*", "*", "If", "there", "is", "a", "precomputed", "table", "for", "the", "generator,", "check", "that", "*", "it", "was", "generated", "with", "the", "same", "generator.", "*/", "EC_POINT", "*", "pre_comp_generator", "=", "EC_POINT_new", "(", "group", ")", ";", "if", "(", "pre_comp_generator", "==", "NULL", ")", "goto", "err", ";", "if", "(", "!", "ecp_sm2z256_set_from_affine", "(", "pre_comp_generator", ",", "group", ",", "pre_comp", "->", "precomp", "[", "0", "]", ",", "ctx", ")", ")", "{", "EC_POINT_free", "(", "pre_comp_generator", ")", ";", "goto", "err", ";", "}", "if", "(", "0", "==", "EC_POINT_cmp", "(", "group", ",", "generator", ",", "pre_comp_generator", ",", "ctx", ")", ")", "preComputedTable", "=", "(", "const", "PRECOMP256_ROW", "*", ")", "pre_comp", "->", "precomp", ";", "EC_POINT_free", "(", "pre_comp_generator", ")", ";", "}", "if", "(", "preComputedTable", "==", "NULL", "&&", "ecp_sm2z256_is_affine_G", "(", "generator", ")", ")", "{", "/*", "*", "If", "there", "is", "no", "precomputed", "data,", "but", "the", "generator", "is", "the", "*", "default,", "a", "hardcoded", "table", "of", "precomputed", "data", "is", "used.", "This", "*", "is", "because", "applications,", "such", "as", "Apache,", "do", "not", "use", "*", "EC_KEY_precompute_mult.", "*/", "preComputedTable", "=", "ecp_sm2z256_precomputed", ";", "}", "if", "(", "preComputedTable", ")", "{", "if", "(", "(", "BN_num_bits", "(", "scalar", ")", ">", "256", ")", "||", "BN_is_negative", "(", "scalar", ")", ")", "{", "if", "(", "(", "tmp_scalar", "=", "BN_CTX_get", "(", "ctx", ")", ")", "==", "NULL", ")", "goto", "err", ";", "if", "(", "!", "BN_nnmod", "(", "tmp_scalar", ",", "scalar", ",", "group", "->", "order", ",", "ctx", ")", ")", "{", "ECerr", "(", "EC_F_ECP_SM2Z256_POINTS_MUL", ",", "ERR_R_BN_LIB", ")", ";", "goto", "err", ";", "}", "scalar", "=", "tmp_scalar", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "bn_get_top", "(", "scalar", ")", "*", "BN_BYTES", ";", "i", "+=", "BN_BYTES", ")", "{", "BN_ULONG", "d", "=", "bn_get_words", "(", "scalar", ")", "[", "i", "/", "BN_BYTES", "]", ";", "p_str", "[", "i", "+", "0", "]", "=", "(", "unsigned", "char", ")", "d", ";", "p_str", "[", "i", "+", "1", "]", "=", "(", "unsigned", "char", ")", "(", "d", ">>", "8", ")", ";", "p_str", "[", "i", "+", "2", "]", "=", "(", "unsigned", "char", ")", "(", "d", ">>", "16", ")", ";", "p_str", "[", "i", "+", "3", "]", "=", "(", "unsigned", "char", ")", "(", "d", ">>=", "24", ")", ";", "if", "(", "BN_BYTES", "==", "8", ")", "{", "d", ">>=", "8", ";", "p_str", "[", "i", "+", "4", "]", "=", "(", "unsigned", "char", ")", "d", ";", "p_str", "[", "i", "+", "5", "]", "=", "(", "unsigned", "char", ")", "(", "d", ">>", "8", ")", ";", "p_str", "[", "i", "+", "6", "]", "=", "(", "unsigned", "char", ")", "(", "d", ">>", "16", ")", ";", "p_str", "[", "i", "+", "7", "]", "=", "(", "unsigned", "char", ")", "(", "d", ">>", "24", ")", ";", "}", "}", "for", "(", ";", "i", "<", "33", ";", "i", "++", ")", "p_str", "[", "i", "]", "=", "0", ";", "#", "if", "defined", "(", "ECP_SM2Z256_AVX2", ")", "printf", "(", "\"%s", "%d:", "ECP_SM2Z256_AVX2", "defined\\\"", ",", "__FILE__", ",", "__LINE__", ")", ";", "if", "(", "ecp_sm2z_avx2_eligible", "()", ")", "{", "ecp_sm2z256_avx2_mul_g", "(", "&", "p", ".", "p", ",", "p_str", ",", "preComputedTable", ")", ";", "}", "else", "#", "endif", "{", "BN_ULONG", "infty", ";", "/*", "First", "window", "*/", "wvalue", "=", "(", "p_str", "[", "0", "]", "<<", "1", ")", "&", "mask", ";", "idx", "+=", "window_size", ";", "wvalue", "=", "_booth_recode_w7", "(", "wvalue", ")", ";", "ecp_sm2z256_gather_w7", "(", "&", "p", ".", "a", ",", "preComputedTable", "[", "0", "]", ",", "wvalue", ">>", "1", ")", ";", "ecp_sm2z256_neg", "(", "p", ".", "p", ".", "Z", ",", "p", ".", "p", ".", "Y", ")", ";", "copy_conditional", "(", "p", ".", "p", ".", "Y", ",", "p", ".", "p", ".", "Z", ",", "wvalue", "&", "1", ")", ";", "/*", "*", "Since", "affine", "infinity", "is", "encoded", "as", "(0,0)", "and", "*", "Jacobian", "ias", "(,,0),", "we", "need", "to", "harmonize", "them", "*", "by", "assigning", "\"one\"", "or", "zero", "to", "Z.", "*/", "infty", "=", "(", "p", ".", "p", ".", "X", "[", "0", "]", "|", "p", ".", "p", ".", "X", "[", "1", "]", "|", "p", ".", "p", ".", "X", "[", "2", "]", "|", "p", ".", "p", ".", "X", "[", "3", "]", "|", "p", ".", "p", ".", "Y", "[", "0", "]", "|", "p", ".", "p", ".", "Y", "[", "1", "]", "|", "p", ".", "p", ".", "Y", "[", "2", "]", "|", "p", ".", "p", ".", "Y", "[", "3", "]", ")", ";", "if", "(", "P256_LIMBS", "==", "8", ")", "infty", "|=", "(", "p", ".", "p", ".", "X", "[", "4", "]", "|", "p", ".", "p", ".", "X", "[", "5", "]", "|", "p", ".", "p", ".", "X", "[", "6", "]", "|", "p", ".", "p", ".", "X", "[", "7", "]", "|", "p", ".", "p", ".", "Y", "[", "4", "]", "|", "p", ".", "p", ".", "Y", "[", "5", "]", "|", "p", ".", "p", ".", "Y", "[", "6", "]", "|", "p", ".", "p", ".", "Y", "[", "7", "]", ")", ";", "infty", "=", "0", "-", "is_zero", "(", "infty", ")", ";", "infty", "=", "~", "infty", ";", "p", ".", "p", ".", "Z", "[", "0", "]", "=", "ONE", "[", "0", "]", "&", "infty", ";", "p", ".", "p", ".", "Z", "[", "1", "]", "=", "ONE", "[", "1", "]", "&", "infty", ";", "p", ".", "p", ".", "Z", "[", "2", "]", "=", "ONE", "[", "2", "]", "&", "infty", ";", "p", ".", "p", ".", "Z", "[", "3", "]", "=", "ONE", "[", "3", "]", "&", "infty", ";", "if", "(", "P256_LIMBS", "==", "8", ")", "{", "p", ".", "p", ".", "Z", "[", "4", "]", "=", "ONE", "[", "4", "]", "&", "infty", ";", "p", ".", "p", ".", "Z", "[", "5", "]", "=", "ONE", "[", "5", "]", "&", "infty", ";", "p", ".", "p", ".", "Z", "[", "6", "]", "=", "ONE", "[", "6", "]", "&", "infty", ";", "p", ".", "p", ".", "Z", "[", "7", "]", "=", "ONE", "[", "7", "]", "&", "infty", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<", "37", ";", "i", "++", ")", "{", "unsigned", "int", "off", "=", "(", "idx", "-", "1", ")", "/", "8", ";", "wvalue", "=", "p_str", "[", "off", "]", "|", "p_str", "[", "off", "+", "1", "]", "<<", "8", ";", "wvalue", "=", "(", "wvalue", ">>", "(", "(", "idx", "-", "1", ")", "%", "8", ")", ")", "&", "mask", ";", "idx", "+=", "window_size", ";", "wvalue", "=", "_booth_recode_w7", "(", "wvalue", ")", ";", "ecp_sm2z256_gather_w7", "(", "&", "t", ".", "a", ",", "preComputedTable", "[", "i", "]", ",", "wvalue", ">>", "1", ")", ";", "ecp_sm2z256_neg", "(", "t", ".", "p", ".", "Z", ",", "t", ".", "a", ".", "Y", ")", ";", "copy_conditional", "(", "t", ".", "a", ".", "Y", ",", "t", ".", "p", ".", "Z", ",", "wvalue", "&", "1", ")", ";", "ecp_sm2z256_point_add_affine", "(", "&", "p", ".", "p", ",", "&", "p", ".", "p", ",", "&", "t", ".", "a", ")", ";", "}", "}", "}", "else", "{", "p_is_infinity", "=", "1", ";", "no_precomp_for_generator", "=", "1", ";", "}", "}", "else", "p_is_infinity", "=", "1", ";", "if", "(", "no_precomp_for_generator", ")", "{", "/*", "*", "Without", "a", "precomputed", "table", "for", "the", "generator,", "it", "has", "to", "be", "*", "handled", "like", "a", "normal", "point.", "*/", "new_scalars", "=", "OPENSSL_malloc", "(", "(", "num", "+", "1", ")", "*", "sizeof", "(", "BIGNUM", "*", ")", ")", ";", "if", "(", "new_scalars", "==", "NULL", ")", "{", "ECerr", "(", "EC_F_ECP_SM2Z256_POINTS_MUL", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "goto", "err", ";", "}", "new_points", "=", "OPENSSL_malloc", "(", "(", "num", "+", "1", ")", "*", "sizeof", "(", "EC_POINT", "*", ")", ")", ";", "if", "(", "new_points", "==", "NULL", ")", "{", "ECerr", "(", "EC_F_ECP_SM2Z256_POINTS_MUL", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "goto", "err", ";", "}", "memcpy", "(", "new_scalars", ",", "scalars", ",", "num", "*", "sizeof", "(", "BIGNUM", "*", ")", ")", ";", "new_scalars", "[", "num", "]", "=", "scalar", ";", "memcpy", "(", "new_points", ",", "points", ",", "num", "*", "sizeof", "(", "EC_POINT", "*", ")", ")", ";", "new_points", "[", "num", "]", "=", "generator", ";", "scalars", "=", "new_scalars", ";", "points", "=", "new_points", ";", "num", "++", ";", "}", "if", "(", "num", ")", "{", "P256_POINT", "*", "out", "=", "&", "t", ".", "p", ";", "if", "(", "p_is_infinity", ")", "out", "=", "&", "p", ".", "p", ";", "if", "(", "!", "ecp_sm2z256_windowed_mul", "(", "group", ",", "out", ",", "scalars", ",", "points", ",", "num", ",", "ctx", ")", ")", "goto", "err", ";", "if", "(", "!", "p_is_infinity", ")", "ecp_sm2z256_point_add", "(", "&", "p", ".", "p", ",", "&", "p", ".", "p", ",", "out", ")", ";", "}", "/*", "Not", "constant-time,", "but", "we\\'re", "only", "operating", "on", "the", "public", "output.", "*/", "if", "(", "!", "bn_set_words", "(", "r", "->", "X", ",", "p", ".", "p", ".", "X", ",", "P256_LIMBS", ")", "||", "!", "bn_set_words", "(", "r", "->", "Y", ",", "p", ".", "p", ".", "Y", ",", "P256_LIMBS", ")", "||", "!", "bn_set_words", "(", "r", "->", "Z", ",", "p", ".", "p", ".", "Z", ",", "P256_LIMBS", ")", ")", "{", "goto", "err", ";", "}", "r", "->", "Z_is_one", "=", "is_one", "(", "r", "->", "Z", ")", "&", "1", ";", "ret", "=", "1", ";", "err", ":", "if", "(", "ctx", ")", "BN_CTX_end", "(", "ctx", ")", ";", "BN_CTX_free", "(", "new_ctx", ")", ";", "OPENSSL_free", "(", "new_points", ")", ";", "OPENSSL_free", "(", "new_scalars", ")", ";", "return", "ret", ";", "}'" ]

[ "Return", "true", "if", "X", "is", "an", "address", "that", "is", "known", "to", "not", "be", "zero" ]

[ "\"bool", "nonzero_address_p", "(", "const_rtx", "x", ")", "{", "const", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "SYMBOL_REF", ":", "return", "flag_delete_null_pointer_checks", "&&", "!", "SYMBOL_REF_WEAK", "(", "x", ")", ";", "case", "LABEL_REF", ":", "return", "true", ";", "case", "REG", ":", "/*", "As", "in", "rtx_varies_p,", "we", "have", "to", "use", "the", "actual", "rtx,", "not", "reg", "number.", "*/", "if", "(", "x", "==", "frame_pointer_rtx", "||", "x", "==", "hard_frame_pointer_rtx", "||", "x", "==", "stack_pointer_rtx", "||", "(", "x", "==", "arg_pointer_rtx", "&&", "fixed_regs", "[", "ARG_POINTER_REGNUM", "]", ")", ")", "return", "true", ";", "/*", "All", "of", "the", "virtual", "frame", "registers", "are", "stack", "references.", "*/", "if", "(", "REGNO", "(", "x", ")", ">=", "FIRST_VIRTUAL_REGISTER", "&&", "REGNO", "(", "x", ")", "<=", "LAST_VIRTUAL_REGISTER", ")", "return", "true", ";", "return", "false", ";", "case", "CONST", ":", "return", "nonzero_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "PLUS", ":", "/*", "Handle", "PIC", "references.", "*/", "if", "(", "XEXP", "(", "x", ",", "0", ")", "==", "pic_offset_table_rtx", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "case", "PRE_MODIFY", ":", "/*", "Similar", "to", "the", "above;", "allow", "positive", "offsets.", "Further,", "since", "auto-inc", "is", "only", "allowed", "in", "memories,", "the", "register", "must", "be", "a", "pointer.", "*/", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">", "0", ")", "return", "true", ";", "return", "nonzero_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "PRE_INC", ":", "/*", "Similarly.", "Further,", "the", "offset", "is", "always", "positive.", "*/", "return", "true", ";", "case", "PRE_DEC", ":", "case", "POST_DEC", ":", "case", "POST_INC", ":", "case", "POST_MODIFY", ":", "return", "nonzero_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "LO_SUM", ":", "return", "nonzero_address_p", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "default:", "break;", "}", "/*", "If", "it", "isn't", "one", "of", "the", "case", "above,", "might", "be", "zero.", "*/", "return", "false", ";", "}\"" ]

[ "If", "the", "target", "doesn't", "override,", "compute", "the", "cost", "as", "with", "arithmetic" ]

[ "'int", "default_address_cost", "(", "rtx", "x", ",", "machine_mode", ",", "addr_space_t", ",", "bool", "speed", ")", "{", "return", "rtx_cost", "(", "x", ",", "Pmode", ",", "MEM", ",", "0", ",", "speed", ")", ";", "}'" ]

[ "Return", "true", "if", "X", "is", "referenced", "in", "BODY" ]

[ "'bool", "rtx_referenced_p", "(", "const_rtx", "x", ",", "const_rtx", "body", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "body", ",", "ALL", ")", "if", "(", "const_rtx", "y", "=", "*", "iter", ")", "{", "/*", "Check", "if", "a", "label_ref", "Y", "refers", "to", "label", "X.", "*/", "if", "(", "GET_CODE", "(", "y", ")", "==", "LABEL_REF", "&&", "LABEL_P", "(", "x", ")", "&&", "label_ref_label", "(", "y", ")", "==", "x", ")", "return", "true", ";", "if", "(", "rtx_equal_p", "(", "x", ",", "y", ")", ")", "return", "true", ";", "/*", "If", "Y", "is", "a", "reference", "to", "pool", "constant", "traverse", "the", "constant.", "*/", "if", "(", "GET_CODE", "(", "y", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "y", ")", ")", "iter", ".", "substitute", "(", "get_pool_constant", "(", "y", ")", ")", ";", "}", "return", "false", ";", "}'" ]

[ "Add", "a", "register", "note", "like", "NOTE", "to", "INSN" ]

[ "'void", "add_shallow_copy_of_reg_note", "(", "rtx_insn", "*", "insn", ",", "rtx", "note", ")", "{", "if", "(", "GET_CODE", "(", "note", ")", "==", "INT_LIST", ")", "add_int_reg_note", "(", "insn", ",", "REG_NOTE_KIND", "(", "note", ")", ",", "XINT", "(", "note", ",", "0", ")", ")", ";", "else", "add_reg_note", "(", "insn", ",", "REG_NOTE_KIND", "(", "note", ")", ",", "XEXP", "(", "note", ",", "0", ")", ")", ";", "}'" ]

[ "Return", "true", "if", "X", "contains", "a", "threadlocal", "symbol" ]

[ "'bool", "tls_referenced_p", "(", "const_rtx", "x", ")", "{", "if", "(", "!", "targetm", ".", "have_tls", ")", "return", "false", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "if", "(", "GET_CODE", "(", "*", "iter", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "*", "iter", ")", "!=", "0", ")", "return", "true", ";", "return", "false", ";", "}'" ]

[ "Describe", "address", "operand", "LOC", "in", "INFO" ]

[ "'void", "decompose_lea_address", "(", "struct", "address_info", "*", "info", ",", "rtx", "*", "loc", ")", "{", "decompose_address", "(", "info", ",", "loc", ",", "VOIDmode", ",", "ADDR_SPACE_GENERIC", ",", "ADDRESS", ")", ";", "}'" ]

[ "Remove", "all", "REG_EQUAL", "and", "REG_EQUIV", "notes", "referring", "to", "REGNO" ]

[ "'void", "remove_reg_equal_equiv_notes_for_regno", "(", "unsigned", "int", "regno", ")", "{", "df_ref", "eq_use", ";", "if", "(", "!", "df", ")", "return", ";", "/*", "This", "loop", "is", "a", "little", "tricky.", "We", "cannot", "just", "go", "down", "the", "chain", "because", "it", "is", "being", "modified", "by", "some", "actions", "in", "the", "loop.", "So", "we", "just", "iterate", "over", "the", "head.", "We", "plan", "to", "drain", "the", "list", "anyway.", "*/", "while", "(", "(", "eq_use", "=", "DF_REG_EQ_USE_CHAIN", "(", "regno", ")", ")", "!=", "NULL", ")", "{", "rtx_insn", "*", "insn", "=", "DF_REF_INSN", "(", "eq_use", ")", ";", "rtx", "note", "=", "find_reg_equal_equiv_note", "(", "insn", ")", ";", "/*", "This", "assert", "is", "generally", "triggered", "when", "someone", "deletes", "a", "REG_EQUAL", "or", "REG_EQUIV", "note", "by", "hacking", "the", "list", "manually", "rather", "than", "calling", "remove_note.", "*/", "gcc_assert", "(", "note", ")", ";", "remove_note", "(", "insn", ",", "note", ")", ";", "}", "}'" ]

[ "Return", "the", "CALL", "in", "X", "if", "there", "is", "one" ]

[ "'rtx", "get_call_rtx_from", "(", "rtx", "x", ")", "{", "if", "(", "INSN_P", "(", "x", ")", ")", "x", "=", "PATTERN", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PARALLEL", ")", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SET", ")", "x", "=", "SET_SRC", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CALL", "&&", "MEM_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "return", "x", ";", "return", "NULL_RTX", ";", "}'" ]

[ "Add", "an", "integer", "register", "note", "with", "kind", "KIND", "and", "datum", "DATUM", "to", "INSN" ]

[ "'void", "add_int_reg_note", "(", "rtx_insn", "*", "insn", ",", "enum", "reg_note", "kind", ",", "int", "datum", ")", "{", "gcc_checking_assert", "(", "int_reg_note_p", "(", "kind", ")", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_INT_LIST", "(", "(", "machine_mode", ")", "kind", ",", "datum", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}'" ]

[ "Return", "true", "if", "X", "contains", "a", "MEM", "subrtx" ]

[ "'bool", "contains_mem_rtx_p", "(", "rtx", "x", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", ")", "return", "true", ";", "return", "false", ";", "}'" ]

[ "Return", "nonzero", "if", "IN", "contains", "a", "piece", "of", "rtl", "that", "has", "the", "address", "LOC" ]

[ "'int", "loc_mentioned_in_p", "(", "rtx", "*", "loc", ",", "const_rtx", "in", ")", "{", "enum", "rtx_code", "code", ";", "const", "char", "*", "fmt", ";", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "if", "(", "!", "in", ")", "return", "0", ";", "code", "=", "GET_CODE", "(", "in", ")", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "\\'e\\'", ")", "{", "if", "(", "loc", "==", "&", "XEXP", "(", "in", ",", "i", ")", "||", "loc_mentioned_in_p", "(", "loc", ",", "XEXP", "(", "in", ",", "i", ")", ")", ")", "return", "1", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "fmt", "[", "i", "]", "==", "\\'E\\'", ")", "for", "(", "j", "=", "XVECLEN", "(", "in", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "loc", "==", "&", "XVECEXP", "(", "in", ",", "i", ",", "j", ")", "||", "loc_mentioned_in_p", "(", "loc", ",", "XVECEXP", "(", "in", ",", "i", ",", "j", ")", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}'" ]

[ "Return", "the", "final", "regno", "that", "a", "subreg", "expression", "refers", "to" ]

[ "'unsigned", "int", "subreg_regno", "(", "const_rtx", "x", ")", "{", "unsigned", "int", "ret", ";", "rtx", "subreg", "=", "SUBREG_REG", "(", "x", ")", ";", "int", "regno", "=", "REGNO", "(", "subreg", ")", ";", "ret", "=", "regno", "+", "subreg_regno_offset", "(", "regno", ",", "GET_MODE", "(", "subreg", ")", ",", "SUBREG_BYTE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ")", ";", "return", "ret", ";", "}'" ]

[ "Return", "the", "mode", "of", "MEM's", "address" ]

[ "'scalar_int_mode", "get_address_mode", "(", "rtx", "mem", ")", "{", "machine_mode", "mode", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "mode", "=", "GET_MODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "if", "(", "mode", "!=", "VOIDmode", ")", "return", "as_a", "<argument_list", "type=\"generic\">", "<", "scalar_int_mode", ">", "(", "mode", ")", ";", "return", "targetm", ".", "addr_space", ".", "address_mode", "(", "MEM_ADDR_SPACE", "(", "mem", ")", ")", ";", "}'" ]

[ "Describe", "the", "address", "of", "MEM", "X", "in", "INFO" ]

[ "'void", "decompose_mem_address", "(", "struct", "address_info", "*", "info", ",", "rtx", "x", ")", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "decompose_address", "(", "info", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "GET_MODE", "(", "x", ")", ",", "MEM_ADDR_SPACE", "(", "x", ")", ",", "MEM", ")", ";", "}'" ]

[ "Utility", "function", "for", "dead_or_set_p", "to", "check", "an", "individual", "register" ]

[ "'int", "dead_or_set_regno_p", "(", "const", "rtx_insn", "*", "insn", ",", "unsigned", "int", "test_regno", ")", "{", "const_rtx", "pattern", ";", "/*", "See", "if", "there", "is", "a", "death", "note", "for", "something", "that", "includes", "TEST_REGNO.", "*/", "if", "(", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "test_regno", ")", ")", "return", "1", ";", "if", "(", "CALL_P", "(", "insn", ")", "&&", "find_regno_fusage", "(", "insn", ",", "CLOBBER", ",", "test_regno", ")", ")", "return", "1", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "/*", "If", "a", "COND_EXEC", "is", "not", "executed,", "the", "value", "survives.", "*/", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "COND_EXEC", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", "||", "GET_CODE", "(", "pattern", ")", "==", "CLOBBER", ")", "return", "covers_regno_p", "(", "SET_DEST", "(", "pattern", ")", ",", "test_regno", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "XVECLEN", "(", "pattern", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "rtx", "body", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "COND_EXEC", ")", "body", "=", "COND_EXEC_CODE", "(", "body", ")", ";", "if", "(", "(", "GET_CODE", "(", "body", ")", "==", "SET", "||", "GET_CODE", "(", "body", ")", "==", "CLOBBER", ")", "&&", "covers_regno_p", "(", "SET_DEST", "(", "body", ")", ",", "test_regno", ")", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}'" ]

[ "Duplicate", "NOTE", "and", "return", "the", "copy" ]

[ "'rtx", "duplicate_reg_note", "(", "rtx", "note", ")", "{", "reg_note", "kind", "=", "REG_NOTE_KIND", "(", "note", ")", ";", "if", "(", "GET_CODE", "(", "note", ")", "==", "INT_LIST", ")", "return", "gen_rtx_INT_LIST", "(", "(", "machine_mode", ")", "kind", ",", "XINT", "(", "note", ",", "0", ")", ",", "NULL_RTX", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "GET_CODE", "(", "note", ")", "==", "EXPR_LIST", ")", "return", "alloc_reg_note", "(", "kind", ",", "copy_insn_1", "(", "XEXP", "(", "note", ",", "0", ")", ")", ",", "NULL_RTX", ")", ";", "else", "return", "alloc_reg_note", "(", "kind", ",", "XEXP", "(", "note", ",", "0", ")", ",", "NULL_RTX", ")", ";", "}'" ]

[ "Add", "a", "REG_ARGS_SIZE", "note", "to", "INSN", "with", "value", "VALUE" ]

[ "'void", "add_args_size_note", "(", "rtx_insn", "*", "insn", ",", "poly_int64", "value", ")", "{", "gcc_checking_assert", "(", "!", "find_reg_note", "(", "insn", ",", "REG_ARGS_SIZE", ",", "NULL_RTX", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_ARGS_SIZE", ",", "gen_int_mode", "(", "value", ",", "Pmode", ")", ")", ";", "}'" ]

[ "Check", "whether", "this", "is", "a", "constant", "pool", "constant" ]

[ "'bool", "constant_pool_constant_p", "(", "rtx", "x", ")", "{", "x", "=", "avoid_constant_pool_reference", "(", "x", ")", ";", "return", "CONST_DOUBLE_P", "(", "x", ")", ";", "}'" ]

[ "Remove", "register", "note", "NOTE", "from", "the", "REG_NOTES", "of", "INSN" ]

[ "'void", "remove_note", "(", "rtx_insn", "*", "insn", ",", "const_rtx", "note", ")", "{", "rtx", "link", ";", "if", "(", "note", "==", "NULL_RTX", ")", "return", ";", "if", "(", "REG_NOTES", "(", "insn", ")", "==", "note", ")", "REG_NOTES", "(", "insn", ")", "=", "XEXP", "(", "note", ",", "1", ")", ";", "else", "for", "(", "link", "=", "REG_NOTES", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "if", "(", "XEXP", "(", "link", ",", "1", ")", "==", "note", ")", "{", "XEXP", "(", "link", ",", "1", ")", "=", "XEXP", "(", "note", ",", "1", ")", ";", "break;", "}", "switch", "(", "REG_NOTE_KIND", "(", "note", ")", ")", "{", "case", "REG_EQUAL", ":", "case", "REG_EQUIV", ":", "df_notes_rescan", "(", "insn", ")", ";", "break;", "default:", "break;", "}", "}'" ]

[ "Return", "true", "if", "REG", "is", "set", "or", "clobbered", "inside", "INSN" ]

[ "'int", "reg_set_p", "(", "const_rtx", "reg", ",", "const_rtx", "insn", ")", "{", "/*", "After", "delay", "slot", "handling,", "call", "and", "branch", "insns", "might", "be", "in", "a", "sequence.", "Check", "all", "the", "elements", "there.", "*/", "if", "(", "INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ";", "++", "i", ")", "if", "(", "reg_set_p", "(", "reg", ",", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "i", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "/*", "We", "can", "be", "passed", "an", "insn", "or", "part", "of", "one.", "If", "we", "are", "passed", "an", "insn,", "check", "if", "a", "side-effect", "of", "the", "insn", "clobbers", "REG.", "*/", "if", "(", "INSN_P", "(", "insn", ")", "&&", "(", "FIND_REG_INC_NOTE", "(", "insn", ",", "reg", ")", "||", "(", "CALL_P", "(", "insn", ")", "&&", "(", "(", "REG_P", "(", "reg", ")", "&&", "REGNO", "(", "reg", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "overlaps_hard_reg_set_p", "(", "regs_invalidated_by_call", ",", "GET_MODE", "(", "reg", ")", ",", "REGNO", "(", "reg", ")", ")", ")", "||", "MEM_P", "(", "reg", ")", "||", "find_reg_fusage", "(", "insn", ",", "CLOBBER", ",", "reg", ")", ")", ")", ")", ")", "return", "true", ";", "/*", "There", "are", "no", "REG_INC", "notes", "for", "SP", "autoinc.", "*/", "if", "(", "reg", "==", "stack_pointer_rtx", "&&", "INSN_P", "(", "insn", ")", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "PATTERN", "(insn)", ",", "NONCONST", ")", "{", "rtx", "mem", "=", "*", "iter", ";", "if", "(", "mem", "&&", "MEM_P", "(", "mem", ")", "&&", "GET_RTX_CLASS", "(", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ")", "==", "RTX_AUTOINC", ")", "{", "if", "(", "XEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "0", ")", "==", "stack_pointer_rtx", ")", "return", "true", ";", "iter", ".", "skip_subrtxes", "()", ";", "}", "}", "}", "return", "set_of", "(", "reg", ",", "insn", ")", "!=", "NULL_RTX", ";", "}'" ]

[ "Returns", "estimate", "on", "cost", "of", "computing", "SEQ" ]

[ "'unsigned", "seq_cost", "(", "const", "rtx_insn", "*", "seq", ",", "bool", "speed", ")", "{", "unsigned", "cost", "=", "0", ";", "rtx", "set", ";", "for", "(", ";", "seq", ";", "seq", "=", "NEXT_INSN", "(", "seq", ")", ")", "{", "set", "=", "single_set", "(", "seq", ")", ";", "if", "(", "set", ")", "cost", "+=", "set_rtx_cost", "(", "set", ",", "speed", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "NONDEBUG_INSN_P", "(", "seq", ")", ")", "{", "int", "this_cost", "=", "insn_cost", "(", "CONST_CAST_RTX_INSN", "(", "seq", ")", ",", "speed", ")", ";", "if", "(", "this_cost", ">", "0", ")", "cost", "+=", "this_cost", ";", "else", "cost", "++", ";", "}", "}", "return", "cost", ";", "}'" ]

[ "Like", "record_hard_reg_sets,", "but", "called", "through", "note_uses" ]

[ "'void", "record_hard_reg_uses", "(", "rtx", "*", "px", ",", "void", "*", "data", ")", "{", "find_all_hard_regs", "(", "*", "px", ",", "(", "HARD_REG_SET", "*", ")", "data", ")", ";", "}'" ]

[ "Add", "all", "hard", "register", "in", "X", "to", "PSET" ]

[ "'void", "find_all_hard_regs", "(", "const_rtx", "x", ",", "HARD_REG_SET", "*", "pset", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "add_to_hard_reg_set", "(", "pset", ",", "GET_MODE", "(", "x", ")", ",", "REGNO", "(", "x", ")", ")", ";", "}", "}'" ]

[ "Return", "the", "argument", "size", "in", "REG_ARGS_SIZE", "note", "X" ]

[ "'poly_int64", "get_args_size", "(", "const_rtx", "x", ")", "{", "gcc_checking_assert", "(", "REG_NOTE_KIND", "(", "x", ")", "==", "REG_ARGS_SIZE", ")", ";", "return", "rtx_to_poly_int64", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "}'" ]

[ "Return", "nonzero", "if", "the", "use", "of", "X", "as", "an", "address", "in", "a", "MEM", "can", "cause", "a", "trap" ]

[ "'int", "rtx_addr_can_trap_p", "(", "const_rtx", "x", ")", "{", "return", "rtx_addr_can_trap_p_1", "(", "x", ",", "0", ",", "-", "1", ",", "BLKmode", ",", "false", ")", ";", "}'" ]

[ "Helper", "function", "for", "noticing", "stores", "to", "parameter", "registers" ]

[ "'static", "void", "parms_set", "(", "rtx", "x", ",", "const_rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "struct", "parms_set_data", "*", "const", "d", "=", "(", "struct", "parms_set_data", "*", ")", "data", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "TEST_HARD_REG_BIT", "(", "d", "->", "regs", ",", "REGNO", "(", "x", ")", ")", ")", "{", "CLEAR_HARD_REG_BIT", "(", "d", "->", "regs", ",", "REGNO", "(", "x", ")", ")", ";", "d", "->", "nregs", "--", ";", "}", "}'" ]

[ "Main", "entry", "point", "of", "the", "program" ]

[ "'int", "main", "(", "int", "argc", ",", "char", "*", "argv", "[]", ")", "{", "int", "c", ";", "int", "i", "=", "1", ";", "int", "option_index", "=", "0", ";", "while", "(", "1", ")", "{", "option_index", "=", "0", ";", "c", "=", "getopt_long", "(", "argc", ",", "argv", ",", "\"vhe:\"", ",", "long_options", ",", "&", "option_index", ")", ";", "if", "(", "c", "==", "-", "1", ")", "break;", "switch", "(", "c", ")", "{", "case", "0", ":", "if", "(", "long_options", "[", "option_index", "]", ".", "flag", "!=", "0", ")", "break;", "break;", "case", "\\'h\\'", ":", "print_usage", "(", "argv", "[", "0", "]", ")", ";", "return", "EXIT_SUCCESS", ";", "case", "\\'v\\'", ":", "print_version", "()", ";", "return", "EXIT_SUCCESS", ";", "case", "\\'e\\'", ":", "return", "run_string", "(", "(", "char", "*", ")", "optarg", ")", ";", "case", "\\'?\\'", ":", "print_usage", "(", "argv", "[", "0", "]", ")", ";", "return", "EXIT_FAILURE", ";", "default:", "abort", "()", ";", "}", "}", "if", "(", "argc", ">", "1", ")", "{", "while", "(", "i", "<", "argc", ")", "if", "(", "run_file", "(", "fopen", "(", "argv", "[", "i", "++", "]", ",", "\"r\"", ")", ")", "==", "EXIT_FAILURE", ")", "fprintf", "(", "stderr", ",", "\"error:", "failed", "to", "read", "file", "%s\\\"", ",", "argv", "[", "i", "-", "1", "]", ")", ";", "}", "else", "{", "/*", "Check", "if", "someone", "is", "piping", "code", "or", "just", "calling", "it", "the", "normal", "way", "*/", "if", "(", "isatty", "(", "STDIN_FILENO", ")", ")", "{", "run_interactive_console", "()", ";", "}", "else", "{", "if", "(", "run_file", "(", "stdin", ")", "==", "EXIT_FAILURE", ")", "fprintf", "(", "stderr", ",", "\"error:", "failed", "to", "read", "from", "stdin\\\"", ")", ";", "}", "}", "return", "EXIT_SUCCESS", ";", "}'" ]

[ "Print", "the", "usage", "message", "of", "this", "program" ]

[ "'void", "print_usage", "(", "char", "*", "name", ")", "{", "fprintf", "(", "stderr", ",", "\"usage:", "%s", "[-evh]", "[file...]\\\"", ",", "name", ")", ";", "fprintf", "(", "stderr", ",", "\"\\\\t-e", "--eval\\\\t\\\\trun", "code", "directly\\\"", ")", ";", "fprintf", "(", "stderr", ",", "\"\\\\t-v", "--version\\\\t\\\\tshow", "version", "information\\\"", ")", ";", "fprintf", "(", "stderr", ",", "\"\\\\t-h", "--help\\\\t\\\\tshow", "a", "help", "message\\\"", ")", ";", "}'" ]