Datasets:

AISE-TUDelft

/

Capybara

like 2

Follow

AISE research lab at TU Delft 43

[ "rootsStepClosureCheck", "check", "a", "rootsStepClosure" ]

[ "'ATTRIBUTE_UNUSED", "static", "Bool", "rootsStepClosureCheck", "(", "rootsStepClosure", "rsc", ")", "{", "CHECKS", "(", "rootsStepClosure", ",", "rsc", ")", ";", "CHECKD", "(", "ScanState", ",", "&", "rsc", "->", "ssStruct", ")", ";", "CHECKL", "(", "FUNCHECK", "(", "rsc", "->", "f", ")", ")", ";", "/*", "p", "and", "s", "fields", "are", "arbitrary", "closures", "which", "cannot", "be", "checked", "*/", "if", "(", "rsc", "->", "root", "!=", "NULL", ")", "{", "CHECKD_NOSIG", "(", "Root", ",", "rsc", "->", "root", ")", ";", "/*", "<design/check/#.hidden-type>", "*/", "}", "return", "TRUE", ";", "}'" ]

[ "rootWalk", "the", "step", "function", "for", "ArenaRootsWalk" ]

[ "'static", "Res", "rootWalk", "(", "Root", "root", ",", "void", "*", "p", ")", "{", "ScanState", "ss", "=", "(", "ScanState", ")", "p", ";", "AVERT", "(", "ScanState", ",", "ss", ")", ";", "if", "(", "RootRank", "(", "root", ")", "==", "ss", "->", "rank", ")", "{", "/*", "set", "the", "root", "for", "the", "benefit", "of", "the", "fix", "method", "*/", "ScanState2rootsStepClosure", "(", "ss", ")", "->", "root", "=", "root", ";", "/*", "Scan", "it", "*/", "ScanStateSetSummary", "(", "ss", ",", "RefSetEMPTY", ")", ";", "return", "RootScan", "(", "ss", ",", "root", ")", ";", "}", "else", "return", "ResOK", ";", "}'" ]

[ "ArenaRootsWalk", "walks", "all", "the", "root", "in", "the", "arena" ]

[ "\"static", "Res", "ArenaRootsWalk", "(", "Globals", "arenaGlobals", ",", "mps_roots_stepper_t", "f", ",", "void", "*", "p", ",", "size_t", "s", ")", "{", "Arena", "arena", ";", "rootsStepClosureStruct", "rscStruct", ";", "rootsStepClosure", "rsc", "=", "&", "rscStruct", ";", "Trace", "trace", ";", "ScanState", "ss", ";", "Rank", "rank", ";", "Res", "res", ";", "Seg", "seg", ";", "AVERT", "(", "Globals", ",", "arenaGlobals", ")", ";", "AVER", "(", "FUNCHECK", "(", "f", ")", ")", ";", "/*", "p", "and", "s", "are", "arbitrary", "client-provided", "closure", "data.", "*/", "arena", "=", "GlobalsArena", "(", "arenaGlobals", ")", ";", "/*", "Scan", "all", "the", "roots", "with", "a", "minimal", "trace.", "Invoke", "the", "scanner", "with", "a", "*/", "/*", "rootsStepClosure,", "which", "is", "a", "subclass", "of", "ScanState", "and", "contains", "the", "*/", "/*", "client-provided", "closure.", "Supply", "a", "special", "fix", "method", "in", "order", "to", "*/", "/*", "call", "the", "client", "closure.", "This", "fix", "method", "must", "perform", "no", "tracing", "*/", "/*", "operations", "of", "its", "own.", "*/", "res", "=", "TraceCreate", "(", "&", "trace", ",", "arena", ",", "TraceStartWhyWALK", ")", ";", "/*", "Have", "to", "fail", "if", "no", "trace", "available.", "Unlikely", "due", "to", ".assume.parked.", "*/", "if", "(", "res", "!=", "ResOK", ")", "return", "res", ";", "/*", ".roots-walk.first-stage:", "In", "order", "to", "fool", "MPS_FIX12", "into", "calling", "_mps_fix2", "for", "a", "reference", "in", "a", "root,", "the", "reference", "must", "pass", "the", "first-stage", "test", "(against", "the", "summary", "of", "the", "trace's", "white", "set),", "so", "make", "the", "summary", "universal.", "*/", "trace", "->", "white", "=", "ZoneSetUNIV", ";", "/*", ".roots-walk.second-stage:", "In", "order", "to", "fool", "_mps_fix2", "into", "calling", "our", "fix", "function", "(RootsWalkFix),", "the", "reference", "must", "be", "to", "a", "segment", "that", "is", "white", "for", "the", "trace,", "so", "make", "all", "segments", "white", "for", "the", "trace.", "*/", "if", "(", "SegFirst", "(", "&", "seg", ",", "arena", ")", ")", "{", "do", "{", "SegSetWhite", "(", "seg", ",", "TraceSetAdd", "(", "SegWhite", "(", "seg", ")", ",", "trace", ")", ")", ";", "}", "while", "(", "SegNext", "(", "&", "seg", ",", "arena", ",", "seg", ")", ")", ";", "}", "/*", "Make", "the", "roots", "grey", "so", "that", "they", "are", "scanned", "*/", "res", "=", "RootsIterate", "(", "arenaGlobals", ",", "rootWalkGrey", ",", "trace", ")", ";", "/*", "Make", "this", "trace", "look", "like", "any", "other", "trace.", "*/", "arena", "->", "flippedTraces", "=", "TraceSetAdd", "(", "arena", "->", "flippedTraces", ",", "trace", ")", ";", "rootsStepClosureInit", "(", "rsc", ",", "arenaGlobals", ",", "trace", ",", "RootsWalkFix", ",", "f", ",", "p", ",", "s", ")", ";", "ss", "=", "rootsStepClosure2ScanState", "(", "rsc", ")", ";", "for", "(", "rank", "=", "RankMIN", ";", "rank", "<", "RankLIMIT", ";", "++", "rank", ")", "{", "ss", "->", "rank", "=", "rank", ";", "AVERT", "(", "ScanState", ",", "ss", ")", ";", "res", "=", "RootsIterate", "(", "arenaGlobals", ",", "rootWalk", ",", "(", "void", "*", ")", "ss", ")", ";", "if", "(", "res", "!=", "ResOK", ")", "break;", "}", "/*", "Turn", "segments", "black", "again.", "*/", "if", "(", "SegFirst", "(", "&", "seg", ",", "arena", ")", ")", "{", "do", "{", "SegSetWhite", "(", "seg", ",", "TraceSetDel", "(", "SegWhite", "(", "seg", ")", ",", "trace", ")", ")", ";", "}", "while", "(", "SegNext", "(", "&", "seg", ",", "arena", ",", "seg", ")", ")", ";", "}", "rootsStepClosureFinish", "(", "rsc", ")", ";", "/*", "Make", "this", "trace", "look", "like", "any", "other", "finished", "trace.", "*/", "trace", "->", "state", "=", "TraceFINISHED", ";", "TraceDestroyFinished", "(", "trace", ")", ";", "AVER", "(", "!", "ArenaEmergency", "(", "arena", ")", ")", ";", "/*", "There", "was", "no", "allocation.", "*/", "return", "res", ";", "}\"" ]

[ "mps_arena_roots_walk", "Client", "interface", "for", "walking" ]

[ "\"void", "mps_arena_roots_walk", "(", "mps_arena_t", "mps_arena", ",", "mps_roots_stepper_t", "f", ",", "void", "*", "p", ",", "size_t", "s", ")", "{", "Arena", "arena", "=", "(", "Arena", ")", "mps_arena", ";", "Res", "res", ";", "ArenaEnter", "(", "arena", ")", ";", "STACK_CONTEXT_BEGIN", "(", "arena", ")", "{", "AVER", "(", "FUNCHECK", "(", "f", ")", ")", ";", "/*", "p", "and", "s", "are", "arbitrary", "closures,", "hence", "can't", "be", "checked", "*/", "AVER", "(", "ArenaGlobals", "(", "arena", ")", "->", "clamped", ")", ";", "/*", ".assume.parked", "*/", "AVER", "(", "arena", "->", "busyTraces", "==", "TraceSetEMPTY", ")", ";", "/*", ".assume.parked", "*/", "res", "=", "ArenaRootsWalk", "(", "ArenaGlobals", "(", "arena", ")", ",", "f", ",", "p", ",", "s", ")", ";", "AVER", "(", "res", "==", "ResOK", ")", ";", "}", "STACK_CONTEXT_END", "(", "arena", ")", ";", "ArenaLeave", "(", "arena", ")", ";", "}\"" ]

[ "rootWalkGrey", "make", "the", "root", "grey", "for", "the", "trace", "passed", "as", "p" ]

[ "'static", "Res", "rootWalkGrey", "(", "Root", "root", ",", "void", "*", "p", ")", "{", "Trace", "trace", "=", "p", ";", "AVERT", "(", "Root", ",", "root", ")", ";", "AVERT", "(", "Trace", ",", "trace", ")", ";", "RootGrey", "(", "root", ",", "trace", ")", ";", "return", "ResOK", ";", "}'" ]

[ "Clear", "a", "Group", "of", "Pins", "Atomic" ]

[ "'void", "gpio_clear", "(", "uint32_t", "gpioport", ",", "uint16_t", "gpios", ")", "{", "GPIO_BSRR", "(", "gpioport", ")", "=", "(", "gpios", "<<", "16", ")", ";", "}'" ]

[ "Update", "a", "CRC", "with", "a", "data", "buffer" ]

[ "'uint8_t", "PIOS_CRC_updateCRC", "(", "uint8_t", "crc", ",", "const", "uint8_t", "*", "data", ",", "int32_t", "length", ")", "{", "//", "use", "registers", "for", "speed", "register", "int32_t", "len", "=", "length", ";", "register", "uint8_t", "crc8", "=", "crc", ";", "register", "const", "uint8_t", "*", "p", "=", "data", ";", "while", "(", "len", "--", ")", "{", "crc8", "=", "crc_table", "[", "crc8", "^", "*", "p", "++", "]", ";", "}", "return", "crc8", ";", "}'" ]

[ "Update", "a", "CRC", "with", "a", "data", "buffer" ]

[ "'uint16_t", "PIOS_CRC16_updateCRC", "(", "uint16_t", "crc", ",", "const", "uint8_t", "*", "data", ",", "int32_t", "length", ")", "{", "register", "uint8_t", "*", "p", "=", "(", "uint8_t", "*", ")", "data", ";", "register", "uint16_t", "_crc", "=", "crc", ";", "for", "(", "register", "uint32_t", "i", "=", "length", ";", "i", ">", "0", ";", "i", "--", ")", "{", "_crc", "=", "(", "_crc", ">>", "8", ")", "^", "CRC_Table16", "[", "(", "_crc", "^", "*", "p", "++", ")", "&", "0xff", "]", ";", "}", "return", "_crc", ";", "}'" ]

[ "returns", "the", "piece", "at", "the", "given", "location" ]

[ "'char", "cgc_getPiece", "(", "Location", "loc", ")", "{", "return", "(", "*", "ptr_array", ")", "[", "loc", ".", "x", "]", "[", "loc", ".", "y", "]", ";", "}'" ]

[ "place", "all", "the", "pieces", "on", "the", "board" ]

[ "\"void", "cgc_initboard", "()", "{", "//", "all", "the", "empty", "squares", "get", "a", "'.'", "for", "(", "int", "i", "=", "0", ";", "i", "<", "HEIGHT", ";", "i", "++", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "WIDTH", ";", "j", "++", ")", "{", "(", "*", "ptr_array", ")", "[", "i", "]", "[", "j", "]", "=", "EMPTY", ";", "}", "}", "//", "putting", "WHITE", "pieces", "in", "position", "(", "*", "ptr_array", ")", "[", "0", "]", "[", "0", "]", "=", "ROOK_WHITE", ";", "(", "*", "ptr_array", ")", "[", "1", "]", "[", "0", "]", "=", "KNIGHT_WHITE", ";", "(", "*", "ptr_array", ")", "[", "2", "]", "[", "0", "]", "=", "BISHOP_WHITE", ";", "(", "*", "ptr_array", ")", "[", "3", "]", "[", "0", "]", "=", "QUEEN_WHITE", ";", "(", "*", "ptr_array", ")", "[", "4", "]", "[", "0", "]", "=", "KING_WHITE", ";", "(", "*", "ptr_array", ")", "[", "5", "]", "[", "0", "]", "=", "BISHOP_WHITE", ";", "(", "*", "ptr_array", ")", "[", "6", "]", "[", "0", "]", "=", "KNIGHT_WHITE", ";", "(", "*", "ptr_array", ")", "[", "7", "]", "[", "0", "]", "=", "ROOK_WHITE", ";", "(", "*", "ptr_array", ")", "[", "0", "]", "[", "1", "]", "=", "PAWN_WHITE", ";", "(", "*", "ptr_array", ")", "[", "1", "]", "[", "1", "]", "=", "PAWN_WHITE", ";", "(", "*", "ptr_array", ")", "[", "2", "]", "[", "1", "]", "=", "PAWN_WHITE", ";", "(", "*", "ptr_array", ")", "[", "3", "]", "[", "1", "]", "=", "PAWN_WHITE", ";", "(", "*", "ptr_array", ")", "[", "4", "]", "[", "1", "]", "=", "PAWN_WHITE", ";", "(", "*", "ptr_array", ")", "[", "5", "]", "[", "1", "]", "=", "PAWN_WHITE", ";", "(", "*", "ptr_array", ")", "[", "6", "]", "[", "1", "]", "=", "PAWN_WHITE", ";", "(", "*", "ptr_array", ")", "[", "7", "]", "[", "1", "]", "=", "PAWN_WHITE", ";", "//", "putting", "BLACK", "pieces", "in", "position", "(", "*", "ptr_array", ")", "[", "0", "]", "[", "6", "]", "=", "PAWN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "1", "]", "[", "6", "]", "=", "PAWN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "2", "]", "[", "6", "]", "=", "PAWN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "3", "]", "[", "6", "]", "=", "PAWN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "4", "]", "[", "6", "]", "=", "PAWN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "5", "]", "[", "6", "]", "=", "PAWN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "6", "]", "[", "6", "]", "=", "PAWN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "7", "]", "[", "6", "]", "=", "PAWN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "0", "]", "[", "7", "]", "=", "ROOK_BLACK", ";", "(", "*", "ptr_array", ")", "[", "1", "]", "[", "7", "]", "=", "KNIGHT_BLACK", ";", "(", "*", "ptr_array", ")", "[", "2", "]", "[", "7", "]", "=", "BISHOP_BLACK", ";", "(", "*", "ptr_array", ")", "[", "3", "]", "[", "7", "]", "=", "QUEEN_BLACK", ";", "(", "*", "ptr_array", ")", "[", "4", "]", "[", "7", "]", "=", "KING_BLACK", ";", "(", "*", "ptr_array", ")", "[", "5", "]", "[", "7", "]", "=", "BISHOP_BLACK", ";", "(", "*", "ptr_array", ")", "[", "6", "]", "[", "7", "]", "=", "KNIGHT_BLACK", ";", "(", "*", "ptr_array", ")", "[", "7", "]", "[", "7", "]", "=", "ROOK_BLACK", ";", "}\"" ]

[ "display", "contents", "of", "board" ]

[ "'void", "cgc_displayboard", "(", "void", ")", "{", "for", "(", "int", "i", "=", "HEIGHT", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "WIDTH", ";", "j", "++", ")", "{", "cgc_transmit", "(", "0", ",", "(", "char", "*", ")", "&", "(", "*", "ptr_array", ")", "[", "j", "]", "[", "i", "]", ",", "1", ",", "NULL", ")", ";", "}", "cgc_printf", "(", "\"\\\"", ")", ";", "}", "}'" ]

[ "swap", "two", "array", "locations" ]

[ "'void", "cgc_swap", "(", "Move", "move", ")", "{", "char", "tmp", ";", "tmp", "=", "(", "*", "ptr_array", ")", "[", "move", ".", "dst", ".", "x", "]", "[", "move", ".", "dst", ".", "y", "]", ";", "(", "*", "ptr_array", ")", "[", "move", ".", "dst", ".", "x", "]", "[", "move", ".", "dst", ".", "y", "]", "=", "(", "*", "ptr_array", ")", "[", "move", ".", "src", ".", "x", "]", "[", "move", ".", "src", ".", "y", "]", ";", "(", "*", "ptr_array", ")", "[", "move", ".", "src", ".", "x", "]", "[", "move", ".", "src", ".", "y", "]", "=", "tmp", ";", "}'" ]

[ "Determine", "if", "the", "aircraft", "is", "forced", "to", "disarm", "by", "an", "explicit", "alarm" ]

[ "'static", "bool", "forcedDisArm", "(", "void", ")", "{", "//", "read", "alarms", "SystemAlarmsAlarmData", "alarms", ";", "SystemAlarmsAlarmGet", "(", "&", "alarms", ")", ";", "if", "(", "alarms", ".", "Guidance", "==", "SYSTEMALARMS_ALARM_CRITICAL", ")", "{", "return", "true", ";", "}", "if", "(", "alarms", ".", "Receiver", "==", "SYSTEMALARMS_ALARM_CRITICAL", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}'" ]

[ "Handler", "to", "interprete", "Command", "inputs", "in", "regards", "to", "arming", "disarming" ]

[ "'void", "armHandler", "(", "bool", "newinit", ",", "FrameType_t", "frameType", ")", "{", "static", "ArmState_t", "armState", ";", "if", "(", "newinit", ")", "{", "AccessoryDesiredInitialize", "()", ";", "setArmedIfChanged", "(", "FLIGHTSTATUS_ARMED_DISARMED", ")", ";", "armState", "=", "ARM_STATE_DISARMED", ";", "}", "portTickType", "sysTime", "=", "xTaskGetTickCount", "()", ";", "FlightModeSettingsData", "settings", ";", "FlightModeSettingsGet", "(", "&", "settings", ")", ";", "ManualControlCommandData", "cmd", ";", "ManualControlCommandGet", "(", "&", "cmd", ")", ";", "AccessoryDesiredData", "acc", ";", "bool", "lowThrottle", "=", "cmd", ".", "Throttle", "<", "0", ";", "if", "(", "frameType", "==", "FRAME_TYPE_GROUND", ")", "{", "//", "Deadbanding", "applied", "in", "receiver.c", "typically", "at", "2%", "but", "we", "don\\'t", "assume", "its", "enabled.", "lowThrottle", "=", "fabsf", "(", "cmd", ".", "Throttle", ")", "<", "GROUND_LOW_THROTTLE", ";", "}", "bool", "armSwitch", "=", "false", ";", "switch", "(", "settings", ".", "Arming", ")", "{", "case", "FLIGHTMODESETTINGS_ARMING_ACCESSORY0", ":", "AccessoryDesiredInstGet", "(", "0", ",", "&", "acc", ")", ";", "armSwitch", "=", "true", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_ACCESSORY1", ":", "AccessoryDesiredInstGet", "(", "1", ",", "&", "acc", ")", ";", "armSwitch", "=", "true", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_ACCESSORY2", ":", "AccessoryDesiredInstGet", "(", "2", ",", "&", "acc", ")", ";", "armSwitch", "=", "true", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_ACCESSORY3", ":", "AccessoryDesiredInstGet", "(", "3", ",", "&", "acc", ")", ";", "armSwitch", "=", "true", ";", "break;", "default:", "break;", "}", "//", "immediate", "disarm", "on", "switch", "if", "(", "armSwitch", "&&", "acc", ".", "AccessoryVal", "<=", "-", "ARMED_THRESHOLD_SWITCH", ")", "{", "lowThrottle", "=", "true", ";", "}", "if", "(", "forcedDisArm", "()", ")", "{", "//", "PathPlanner", "forces", "explicit", "disarming", "due", "to", "error", "condition", "(crash,", "impact,", "fire,", "...)", "armState", "=", "ARM_STATE_DISARMED", ";", "setArmedIfChanged", "(", "FLIGHTSTATUS_ARMED_DISARMED", ")", ";", "return", ";", "}", "if", "(", "settings", ".", "Arming", "==", "FLIGHTMODESETTINGS_ARMING_ALWAYSDISARMED", ")", "{", "//", "In", "this", "configuration", "we", "always", "disarm", "setArmedIfChanged", "(", "FLIGHTSTATUS_ARMED_DISARMED", ")", ";", "return", ";", "}", "//", "The", "throttle", "is", "not", "low,", "in", "case", "we", "where", "arming", "or", "disarming,", "abort", "if", "(", "!", "lowThrottle", ")", "{", "switch", "(", "armState", ")", "{", "case", "ARM_STATE_DISARMING_MANUAL", ":", "case", "ARM_STATE_DISARMING_TIMEOUT", ":", "armState", "=", "ARM_STATE_ARMED", ";", "break;", "case", "ARM_STATE_ARMING_MANUAL", ":", "armState", "=", "ARM_STATE_DISARMED", ";", "break;", "default:", "//", "Nothing", "needs", "to", "be", "done", "in", "the", "other", "states", "break;", "}", "return", ";", "}", "//", "The", "rest", "of", "these", "cases", "throttle", "is", "low", "if", "(", "settings", ".", "Arming", "==", "FLIGHTMODESETTINGS_ARMING_ALWAYSARMED", ")", "{", "//", "In", "this", "configuration,", "we", "go", "into", "armed", "state", "as", "soon", "as", "the", "throttle", "is", "low,", "never", "disarm", "setArmedIfChanged", "(", "FLIGHTSTATUS_ARMED_ARMED", ")", ";", "return", ";", "}", "//", "When", "the", "configuration", "is", "not", "\"Always", "armed\"", "and", "no", "\"Always", "disarmed\",", "//", "the", "state", "will", "not", "be", "changed", "when", "the", "throttle", "is", "not", "low", "static", "portTickType", "armedDisarmStart", ";", "float", "armingInputLevel", "=", "0", ";", "//", "Calc", "channel", "see", "assumptions7", "switch", "(", "settings", ".", "Arming", ")", "{", "case", "FLIGHTMODESETTINGS_ARMING_ROLLLEFT", ":", "armingInputLevel", "=", "1.0f", "*", "cmd", ".", "Roll", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_ROLLRIGHT", ":", "armingInputLevel", "=", "-", "1.0f", "*", "cmd", ".", "Roll", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_PITCHFORWARD", ":", "armingInputLevel", "=", "1.0f", "*", "cmd", ".", "Pitch", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_PITCHAFT", ":", "armingInputLevel", "=", "-", "1.0f", "*", "cmd", ".", "Pitch", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_YAWLEFT", ":", "armingInputLevel", "=", "1.0f", "*", "cmd", ".", "Yaw", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_YAWRIGHT", ":", "armingInputLevel", "=", "-", "1.0f", "*", "cmd", ".", "Yaw", ";", "break;", "case", "FLIGHTMODESETTINGS_ARMING_ACCESSORY0", ":", "case", "FLIGHTMODESETTINGS_ARMING_ACCESSORY1", ":", "case", "FLIGHTMODESETTINGS_ARMING_ACCESSORY2", ":", "case", "FLIGHTMODESETTINGS_ARMING_ACCESSORY3", ":", "armingInputLevel", "=", "-", "1.0f", "*", "acc", ".", "AccessoryVal", ";", "break;", "default:", "break;", "}", "bool", "manualArm", "=", "false", ";", "bool", "manualDisarm", "=", "false", ";", "static", "FlightModeSettingsArmingOptions", "previousArmingSettings", "=", "-", "1", ";", "static", "float", "previousArmingInputLevel", "=", "0.0f", ";", "if", "(", "previousArmingSettings", "!=", "settings", ".", "Arming", ")", "{", "previousArmingSettings", "=", "settings", ".", "Arming", ";", "previousArmingInputLevel", "=", "0.0f", ";", "}", "//", "ignore", "previous", "arming", "input", "level", "if", "not", "transitioning", "from", "fully", "ARMED/DISARMED", "states.", "if", "(", "(", "armState", "!=", "ARM_STATE_DISARMED", ")", "&&", "(", "armState", "!=", "ARM_STATE_ARMED", ")", ")", "{", "previousArmingInputLevel", "=", "0.0f", ";", "}", "float", "armedThreshold", "=", "armSwitch", "?", "ARMED_THRESHOLD_SWITCH", ":", "ARMED_THRESHOLD_STICK", ";", "if", "(", "(", "armingInputLevel", "<=", "-", "armedThreshold", ")", "&&", "(", "previousArmingInputLevel", ">", "-", "armedThreshold", ")", ")", "{", "manualArm", "=", "true", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "armingInputLevel", ">=", "+", "armedThreshold", ")", "&&", "(", "previousArmingInputLevel", "<", "+", "armedThreshold", ")", ")", "{", "manualDisarm", "=", "true", ";", "}", "previousArmingInputLevel", "=", "armingInputLevel", ";", "switch", "(", "armState", ")", "{", "case", "ARM_STATE_DISARMED", ":", "setArmedIfChanged", "(", "FLIGHTSTATUS_ARMED_DISARMED", ")", ";", "//", "only", "allow", "arming", "if", "it\\'s", "OK", "too", "if", "(", "manualArm", "&&", "okToArm", "()", ")", "{", "armedDisarmStart", "=", "sysTime", ";", "armState", "=", "ARM_STATE_ARMING_MANUAL", ";", "}", "break;", "case", "ARM_STATE_ARMING_MANUAL", ":", "setArmedIfChanged", "(", "FLIGHTSTATUS_ARMED_ARMING", ")", ";", "if", "(", "manualArm", "&&", "(", "timeDifferenceMs", "(", "armedDisarmStart", ",", "sysTime", ")", ">", "settings", ".", "ArmingSequenceTime", ")", ")", "{", "armState", "=", "ARM_STATE_ARMED", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "manualArm", ")", "{", "armState", "=", "ARM_STATE_DISARMED", ";", "}", "break;", "case", "ARM_STATE_ARMED", ":", "//", "When", "we", "get", "here,", "the", "throttle", "is", "low,", "//", "we", "go", "immediately", "to", "disarming", "due", "to", "timeout,", "also", "when", "the", "disarming", "mechanism", "is", "not", "enabled", "armedDisarmStart", "=", "sysTime", ";", "armState", "=", "ARM_STATE_DISARMING_TIMEOUT", ";", "setArmedIfChanged", "(", "FLIGHTSTATUS_ARMED_ARMED", ")", ";", "break;", "case", "ARM_STATE_DISARMING_TIMEOUT", ":", "{", "//", "we", "should", "never", "reach", "the", "disarming", "timeout", "if", "the", "pathfollower", "is", "engaged", "-", "reset", "timeout", "FlightStatusControlChainData", "cc", ";", "FlightStatusControlChainGet", "(", "&", "cc", ")", ";", "if", "(", "cc", ".", "PathFollower", "==", "FLIGHTSTATUS_CONTROLCHAIN_TRUE", ")", "{", "armedDisarmStart", "=", "sysTime", ";", "}", "}", "//", "We", "get", "here", "when", "armed", "while", "throttle", "low,", "even", "when", "the", "arming", "timeout", "is", "not", "enabled", "if", "(", "(", "settings", ".", "ArmedTimeout", "!=", "0", ")", "&&", "(", "timeDifferenceMs", "(", "armedDisarmStart", ",", "sysTime", ")", ">", "settings", ".", "ArmedTimeout", ")", ")", "{", "armState", "=", "ARM_STATE_DISARMED", ";", "}", "//", "Switch", "to", "disarming", "due", "to", "manual", "control", "when", "needed", "if", "(", "manualDisarm", ")", "{", "armedDisarmStart", "=", "sysTime", ";", "armState", "=", "ARM_STATE_DISARMING_MANUAL", ";", "}", "break;", "case", "ARM_STATE_DISARMING_MANUAL", ":", "//", "arming", "switch", "disarms", "immediately,", "if", "(", "manualDisarm", "&&", "(", "timeDifferenceMs", "(", "armedDisarmStart", ",", "sysTime", ")", ">", "settings", ".", "DisarmingSequenceTime", ")", ")", "{", "armState", "=", "ARM_STATE_DISARMED", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "manualDisarm", ")", "{", "armState", "=", "ARM_STATE_ARMED", ";", "}", "break;", "}", "//", "End", "Switch", "}'" ]

[ "Update", "the", "flightStatus", "object", "only", "if", "value", "changed" ]

[ "'static", "void", "setArmedIfChanged", "(", "uint8_t", "val", ")", "{", "FlightStatusData", "flightStatus", ";", "FlightStatusGet", "(", "&", "flightStatus", ")", ";", "if", "(", "flightStatus", ".", "Armed", "!=", "val", ")", "{", "flightStatus", ".", "Armed", "=", "val", ";", "FlightStatusSet", "(", "&", "flightStatus", ")", ";", "}", "}'" ]

[ "Determine", "if", "the", "aircraft", "is", "safe", "to", "arm" ]

[ "'static", "bool", "okToArm", "(", "void", ")", "{", "//", "update", "checks", "configuration_check", "()", ";", "//", "read", "alarms", "SystemAlarmsData", "alarms", ";", "SystemAlarmsGet", "(", "&", "alarms", ")", ";", "//", "Check", "each", "alarm", "for", "(", "int", "i", "=", "0", ";", "i", "<", "SYSTEMALARMS_ALARM_NUMELEM", ";", "i", "++", ")", "{", "if", "(", "SystemAlarmsAlarmToArray", "(", "alarms", ".", "Alarm", ")", "[", "i", "]", ">=", "SYSTEMALARMS_ALARM_CRITICAL", ")", "{", "//", "found", "an", "alarm", "thats", "set", "if", "(", "i", "==", "SYSTEMALARMS_ALARM_GPS", "||", "i", "==", "SYSTEMALARMS_ALARM_TELEMETRY", ")", "{", "continue;", "}", "return", "false", ";", "}", "}", "StabilizationDesiredStabilizationModeData", "stabDesired", ";", "FlightStatusData", "flightStatus", ";", "FlightStatusGet", "(", "&", "flightStatus", ")", ";", "switch", "(", "flightStatus", ".", "FlightMode", ")", "{", "case", "FLIGHTSTATUS_FLIGHTMODE_MANUAL", ":", "case", "FLIGHTSTATUS_FLIGHTMODE_STABILIZED1", ":", "case", "FLIGHTSTATUS_FLIGHTMODE_STABILIZED2", ":", "case", "FLIGHTSTATUS_FLIGHTMODE_STABILIZED3", ":", "case", "FLIGHTSTATUS_FLIGHTMODE_STABILIZED4", ":", "case", "FLIGHTSTATUS_FLIGHTMODE_STABILIZED5", ":", "case", "FLIGHTSTATUS_FLIGHTMODE_STABILIZED6", ":", "//", "Prevent", "arming", "if", "unsafe", "due", "to", "the", "current", "Thrust", "Mode", "StabilizationDesiredStabilizationModeGet", "(", "&", "stabDesired", ")", ";", "if", "(", "stabDesired", ".", "Thrust", "==", "STABILIZATIONDESIRED_STABILIZATIONMODE_ALTITUDEHOLD", "||", "stabDesired", ".", "Thrust", "==", "STABILIZATIONDESIRED_STABILIZATIONMODE_ALTITUDEVARIO", ")", "{", "return", "false", ";", "}", "//", "avoid", "assisted", "control", "with", "auto", "throttle.", "As", "it", "sits", "waiting", "to", "launch,", "//", "it", "will", "move", "to", "hold,", "and", "auto", "thrust", "will", "auto", "launch", "otherwise!", "if", "(", "flightStatus", ".", "FlightModeAssist", "==", "FLIGHTSTATUS_FLIGHTMODEASSIST_GPSASSIST", ")", "{", "return", "false", ";", "}", "//", "Avoid", "arming", "while", "AlwaysStabilizeWhenArmed", "is", "active", "if", "(", "flightStatus", ".", "AlwaysStabilizeWhenArmed", "==", "FLIGHTSTATUS_ALWAYSSTABILIZEWHENARMED_TRUE", ")", "{", "return", "false", ";", "}", "return", "true", ";", "break;", "case", "FLIGHTSTATUS_FLIGHTMODE_LAND", ":", "#", "if", "!", "defined", "(", "PIOS_EXCLUDE_ADVANCED_FEATURES", ")", "case", "FLIGHTSTATUS_FLIGHTMODE_AUTOTUNE", ":", "#", "endif", "/*", "!defined(PIOS_EXCLUDE_ADVANCED_FEATURES)", "*/", "return", "false", ";", "case", "FLIGHTSTATUS_FLIGHTMODE_AUTOTAKEOFF", ":", "case", "FLIGHTSTATUS_FLIGHTMODE_PATHPLANNER", ":", "//", "Avoid", "arming", "while", "AlwaysStabilizeWhenArmed", "is", "active", "if", "(", "flightStatus", ".", "AlwaysStabilizeWhenArmed", "==", "FLIGHTSTATUS_ALWAYSSTABILIZEWHENARMED_TRUE", ")", "{", "return", "false", ";", "}", "return", "true", ";", "default:", "return", "false", ";", "break;", "}", "}'" ]

[ "The", "`long'", "version", "of", "`xwcstoi'" ]

[ "\"bool", "xwcstol", "(", "const", "wchar_t", "*", "s", ",", "int", "base", ",", "long", "*", "resultp", ")", "{", "wchar_t", "*", "endp", ";", "if", "(", "*", "s", "==", "L", "'\\\\0'", ")", "{", "errno", "=", "EINVAL", ";", "return", "false", ";", "}", "errno", "=", "0", ";", "*", "resultp", "=", "wcstol", "(", "s", ",", "&", "endp", ",", "base", ")", ";", "if", "(", "errno", "!=", "0", ")", "return", "false", ";", "if", "(", "*", "endp", "!=", "L", "'\\\\0'", ")", "{", "errno", "=", "EINVAL", ";", "return", "false", ";", "}", "return", "true", ";", "}\"" ]

[ "fake", "cpubind", "for", "when", "nbprocs1", "and", "no", "binding", "support" ]

[ "'static", "int", "fake_get_cpubind", "(", "hwloc_topology_t", "topology", "__hwloc_attribute_unused", ",", "hwloc_cpuset_t", "set", "__hwloc_attribute_unused", ",", "int", "flags", "__hwloc_attribute_unused", ")", "{", "return", "0", ";", "}'" ]

[ "Scale", "base", "by", "mult", "div", "checking", "for", "overflow" ]

[ "'static", "int", "scale64_check_overflow", "(", "u64", "mult", ",", "u64", "div", ",", "u64", "*", "base", ")", "{", "u64", "tmp", ",", "<type", "ref=\"prev\"/>", "rem", ";", "tmp", "=", "div64_u64_rem", "(", "*", "base", ",", "div", ",", "&", "rem", ")", ";", "if", "(", "(", "(", "int", ")", "sizeof", "(", "u64", ")", "*", "8", "-", "fls64", "(", "mult", ")", "<", "fls64", "(", "tmp", ")", ")", "||", "(", "(", "int", ")", "sizeof", "(", "u64", ")", "*", "8", "-", "fls64", "(", "mult", ")", "<", "fls64", "(", "rem", ")", ")", ")", "return", "-", "EOVERFLOW", ";", "tmp", "*=", "mult", ";", "rem", "*=", "mult", ";", "do_div", "(", "rem", ",", "div", ")", ";", "*", "base", "=", "tmp", "+", "rem", ";", "return", "0", ";", "}'" ]

[ "Compares", "two", "strings", "byte", "by", "byte", "and", "ignores", "the", "character's", "case" ]

[ "\"static", "int", "case_insensitive_strncmp", "(", "const", "char", "*", "string1", ",", "const", "char", "*", "string2", ",", "size_t", "n", ")", "{", "if", "(", "(", "string1", "==", "NULL", ")", "&&", "(", "string2", "==", "NULL", ")", ")", "{", "return", "0", ";", "}", "if", "(", "(", "string1", "==", "NULL", ")", "&&", "(", "string2", "!=", "NULL", ")", ")", "{", "return", "-", "1", ";", "}", "if", "(", "(", "string1", "!=", "NULL", ")", "&&", "(", "string2", "==", "NULL", ")", ")", "{", "return", "1", ";", "}", "if", "(", "n", "==", "0", ")", "{", "//", "Zero", "bytes", "are", "always", "equal", "return", "0", ";", "}", "if", "(", "string1", "==", "string2", ")", "{", "//", "return", "equal", "if", "they", "point", "to", "same", "location", "return", "0", ";", "}", "int", "result", ";", "do", "{", "result", "=", "tolower", "(", "(", "unsigned", "char", ")", "*", "string1", ")", "-", "tolower", "(", "(", "unsigned", "char", ")", "*", "string2", ")", ";", "if", "(", "result", "!=", "0", ")", "{", "break;", "}", "}", "while", "(", "*", "string1", "++", "!=", "'\\\\0'", "&&", "*", "string2", "++", "!=", "'\\\\0'", "&&", "--", "n", ")", ";", "return", "result", ";", "}\"" ]

[ "Calculates", "the", "number", "of", "TCP", "transmissions", "based", "on", "SQNR", "range" ]

[ "'u_int32_t", "mops_tcp_complexity_sqnr", "(", "struct", "mops", "*", "mp", ")", "{", "u_int32_t", "a", ",", "<type", "ref=\"prev\"/>", "b", ",", "<type", "ref=\"prev\"/>", "t", ",", "<type", "ref=\"prev\"/>", "result", ";", "a", "=", "mp", "->", "tcp_seq_start", ";", "b", "=", "mp", "->", "tcp_seq_stop", ";", "t", "=", "mp", "->", "tcp_seq_delta", ";", "if", "(", "!", "t", ")", "return", "1", ";", "//", "delta", "set", "to", "zero", "means", "no", "range", "if", "(", "a", "<", "b", ")", "//", "regular", "case", "result", "=", "ceill", "(", "(", "b", "-", "a", ")", "/", "t", ")", ";", "else", "//", "range", "wraps", "around", "result", "=", "ceill", "(", "(", "(", "0xffffffff", "-", "a", ")", "+", "b", ")", "/", "t", ")", ";", "return", "result", ";", "}'" ]

[ "return", "zero", "for", "success,", "nonzero", "for", "error" ]

[ "'int", "flint_restore_thread_affinity", "()", "{", "if", "(", "!", "global_thread_pool_initialized", ")", "return", "1", ";", "return", "thread_pool_restore_affinity", "(", "global_thread_pool", ")", ";", "}'" ]

[ "return", "zero", "for", "success,", "nonzero", "for", "error" ]

[ "'int", "flint_set_thread_affinity", "(", "int", "*", "cpus", ",", "slong", "length", ")", "{", "if", "(", "!", "global_thread_pool_initialized", ")", "return", "1", ";", "return", "thread_pool_set_affinity", "(", "global_thread_pool", ",", "cpus", ",", "length", ")", ";", "}'" ]

[ "clears", "the", "rainbow", "effect", "for", "musical", "notes" ]

[ "'void", "AnimTask_MusicNotesClearRainbowBlend", "(", "u8", "taskId", ")", "{", "u16", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "NELEMS", "(", "sParticlesColorBlendTable", ")", ";", "i", "++", ")", "FreeSpritePaletteByTag", "(", "sParticlesColorBlendTable", "[", "i", "]", "[", "0", "]", ")", ";", "DestroyAnimVisualTask", "(", "taskId", ")", ";", "}'" ]

[ "free", "memorymapped", "stack", "storage" ]

[ "'void", "stack_free", "(", "void", "*", "p", ",", "int", "size", ")", "{", "size_t", "sp", "=", "(", "size_t", ")", "p", "-", "size", ";", "#", "ifdef", "DEBUG", "memset", "(", "(", "void", "*", ")", "sp", ",", "0xcd", ",", "size", ")", ";", "#", "endif", "munmap", "(", "(", "void", "*", ")", "sp", ",", "size", ")", ";", "#", "if", "STACK_OVERFLOW_PROTECT", "sp", "=", "sp", "-", "PAGE_SIZE", ";", "munmap", "(", "(", "void", "*", ")", "sp", ",", "PAGE_SIZE", ")", ";", "#", "endif", "}'" ]

[ "Returns", "the", "index", "of", "a", "member", "in", "a", "compound", "or", "enumeration", "datatype", "by", "given", "name" ]

[ "'int", "H5Tget_member_index", "(", "hid_t", "type_id", ",", "const", "char", "*", "name", ")", "{", "H5T_t", "*", "dt", "=", "NULL", ";", "int", "ret_value", "=", "FAIL", ";", "unsigned", "i", ";", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE2", "(", "\"Is\"", ",", "\"i*s\"", ",", "type_id", ",", "name", ")", ";", "/*", "Check", "arguments", "*/", "HDassert", "(", "name", ")", ";", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object_verify", "(", "type_id", ",", "H5I_DATATYPE", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "FAIL", ",", "\"not", "a", "datatype\"", ")", "/*", "Locate", "member", "by", "name", "*/", "switch", "(", "dt", "->", "shared", "->", "type", ")", "{", "case", "H5T_COMPOUND", ":", "for", "(", "i", "=", "0", ";", "i", "<", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "nmembs", ";", "i", "++", ")", "if", "(", "!", "HDstrcmp", "(", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "i", "]", ".", "name", ",", "name", ")", ")", "HGOTO_DONE", "(", "(int)i", ")", "break;", "case", "H5T_ENUM", ":", "for", "(", "i", "=", "0", ";", "i", "<", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "nmembs", ";", "i", "++", ")", "if", "(", "!", "HDstrcmp", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "i", "]", ",", "name", ")", ")", "HGOTO_DONE", "(", "(int)i", ")", "break;", "case", "H5T_NO_CLASS", ":", "case", "H5T_INTEGER", ":", "case", "H5T_FLOAT", ":", "case", "H5T_TIME", ":", "case", "H5T_STRING", ":", "case", "H5T_BITFIELD", ":", "case", "H5T_OPAQUE", ":", "case", "H5T_REFERENCE", ":", "case", "H5T_VLEN", ":", "case", "H5T_ARRAY", ":", "case", "H5T_NCLASSES", ":", "default:", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "FAIL", ",", "\"operation", "not", "supported", "for", "this", "type\"", ")", "}", "/*lint", "!e788", "All", "appropriate", "cases", "are", "covered", "*/", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Sorts", "members", "of", "a", "compound", "or", "enumeration", "datatype", "by", "their", "names" ]

[ "'herr_t", "H5T__sort_name", "(", "const", "H5T_t", "*", "dt", ",", "int", "*", "map", ")", "{", "unsigned", "i", ",", "<type", "ref=\"prev\"/>", "j", ",", "<type", "ref=\"prev\"/>", "nmembs", ";", "size_t", "size", ";", "hbool_t", "swapped", ";", "uint8_t", "tbuf", "[", "32", "]", ";", "FUNC_ENTER_PACKAGE_NOERR", "/*", "Check", "args", "*/", "HDassert", "(", "dt", ")", ";", "HDassert", "(", "H5T_COMPOUND", "==", "dt", "->", "shared", "->", "type", "||", "H5T_ENUM", "==", "dt", "->", "shared", "->", "type", ")", ";", "/*", "Use", "a", "bubble", "sort", "because", "we", "can", "short", "circuit", "*/", "if", "(", "H5T_COMPOUND", "==", "dt", "->", "shared", "->", "type", ")", "{", "if", "(", "H5T_SORT_NAME", "!=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "sorted", ")", "{", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "sorted", "=", "H5T_SORT_NAME", ";", "nmembs", "=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "nmembs", ";", "for", "(", "i", "=", "nmembs", "-", "1", ",", "swapped", "=", "TRUE", ";", "i", ">", "0", "&&", "swapped", ";", "--", "i", ")", "{", "for", "(", "j", "=", "0", ",", "swapped", "=", "FALSE", ";", "j", "<", "i", ";", "j", "++", ")", "{", "if", "(", "HDstrcmp", "(", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "]", ".", "name", ",", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "+", "1", "]", ".", "name", ")", ">", "0", ")", "{", "H5T_cmemb_t", "tmp", "=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "]", ";", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "]", "=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "+", "1", "]", ";", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "+", "1", "]", "=", "tmp", ";", "swapped", "=", "TRUE", ";", "if", "(", "map", ")", "{", "int", "x", "=", "map", "[", "j", "]", ";", "map", "[", "j", "]", "=", "map", "[", "j", "+", "1", "]", ";", "map", "[", "j", "+", "1", "]", "=", "x", ";", "}", "}", "}", "}", "#", "ifndef", "NDEBUG", "/*", "I", "never", "trust", "a", "sort", ":-)", "-RPM", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "nmembs", "-", "1", ";", "i", "++", ")", "{", "HDassert", "(", "HDstrcmp", "(", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "i", "]", ".", "name", ",", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "i", "+", "1", "]", ".", "name", ")", "<", "0", ")", ";", "}", "#", "endif", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "H5T_ENUM", "==", "dt", "->", "shared", "->", "type", ")", "{", "if", "(", "H5T_SORT_NAME", "!=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "sorted", ")", "{", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "sorted", "=", "H5T_SORT_NAME", ";", "nmembs", "=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "nmembs", ";", "size", "=", "dt", "->", "shared", "->", "size", ";", "HDassert", "(", "size", "<=", "sizeof", "(", "tbuf", ")", ")", ";", "for", "(", "i", "=", "nmembs", "-", "1", ",", "swapped", "=", "TRUE", ";", "i", ">", "0", "&&", "swapped", ";", "--", "i", ")", "{", "for", "(", "j", "=", "0", ",", "swapped", "=", "FALSE", ";", "j", "<", "i", ";", "j", "++", ")", "{", "if", "(", "HDstrcmp", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "]", ",", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "+", "1", "]", ")", ">", "0", ")", "{", "/*", "Swap", "names", "*/", "char", "*", "tmp", "=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "]", ";", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "]", "=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "+", "1", "]", ";", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "+", "1", "]", "=", "tmp", ";", "/*", "Swap", "values", "*/", "HDmemcpy", "(", "tbuf", ",", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "j", "*", "size", ",", "size", ")", ";", "HDmemcpy", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "j", "*", "size", ",", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "j", "+", "1", ")", "*", "size", ",", "size", ")", ";", "HDmemcpy", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "j", "+", "1", ")", "*", "size", ",", "tbuf", ",", "size", ")", ";", "/*", "Swap", "map", "*/", "if", "(", "map", ")", "{", "int", "x", "=", "map", "[", "j", "]", ";", "map", "[", "j", "]", "=", "map", "[", "j", "+", "1", "]", ";", "map", "[", "j", "+", "1", "]", "=", "x", ";", "}", "swapped", "=", "TRUE", ";", "}", "}", "}", "#", "ifndef", "NDEBUG", "/*", "I", "never", "trust", "a", "sort", ":-)", "-RPM", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "nmembs", "-", "1", ";", "i", "++", ")", "HDassert", "(", "HDstrcmp", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "i", "]", ",", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "i", "+", "1", "]", ")", "<", "0", ")", ";", "#", "endif", "}", "}", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Sorts", "the", "members", "of", "a", "compound", "datatype", "by", "their", "offsets;", "sorts", "the", "members", "of", "an", "enum", "type", "by", "their", "values" ]

[ "'herr_t", "H5T__sort_value", "(", "const", "H5T_t", "*", "dt", ",", "int", "*", "map", ")", "{", "unsigned", "nmembs", ";", "/*", "Number", "of", "members", "for", "datatype", "*/", "size_t", "size", ";", "hbool_t", "swapped", ";", "/*", "Whether", "we\\'ve", "swapped", "fields", "*/", "uint8_t", "tbuf", "[", "32", "]", ";", "unsigned", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "/*", "Local", "index", "variables", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_PACKAGE_NOERR", "/*", "Check", "args", "*/", "HDassert", "(", "dt", ")", ";", "HDassert", "(", "H5T_COMPOUND", "==", "dt", "->", "shared", "->", "type", "||", "H5T_ENUM", "==", "dt", "->", "shared", "->", "type", ")", ";", "/*", "Use", "a", "bubble", "sort", "because", "we", "can", "short", "circuit", "*/", "if", "(", "H5T_COMPOUND", "==", "dt", "->", "shared", "->", "type", ")", "{", "if", "(", "H5T_SORT_VALUE", "!=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "sorted", ")", "{", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "sorted", "=", "H5T_SORT_VALUE", ";", "nmembs", "=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "nmembs", ";", "for", "(", "i", "=", "nmembs", "-", "1", ",", "swapped", "=", "TRUE", ";", "i", ">", "0", "&&", "swapped", ";", "--", "i", ")", "{", "for", "(", "j", "=", "0", ",", "swapped", "=", "FALSE", ";", "j", "<", "i", ";", "j", "++", ")", "{", "if", "(", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "]", ".", "offset", ">", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "+", "1", "]", ".", "offset", ")", "{", "H5T_cmemb_t", "tmp", "=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "]", ";", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "]", "=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "+", "1", "]", ";", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "j", "+", "1", "]", "=", "tmp", ";", "if", "(", "map", ")", "{", "int", "x", "=", "map", "[", "j", "]", ";", "map", "[", "j", "]", "=", "map", "[", "j", "+", "1", "]", ";", "map", "[", "j", "+", "1", "]", "=", "x", ";", "}", "/*", "end", "if", "*/", "swapped", "=", "TRUE", ";", "}", "/*", "end", "if", "*/", "}", "/*", "end", "for", "*/", "}", "/*", "end", "for", "*/", "#", "ifndef", "NDEBUG", "/*", "I", "never", "trust", "a", "sort", ":-)", "-RPM", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "(", "nmembs", "-", "1", ")", ";", "i", "++", ")", "HDassert", "(", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "i", "]", ".", "offset", "<", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "i", "+", "1", "]", ".", "offset", ")", ";", "#", "endif", "}", "/*", "end", "if", "*/", "}", "<if", "type=\"elseif\">", "else", "if", "(", "H5T_ENUM", "==", "dt", "->", "shared", "->", "type", ")", "{", "if", "(", "H5T_SORT_VALUE", "!=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "sorted", ")", "{", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "sorted", "=", "H5T_SORT_VALUE", ";", "nmembs", "=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "nmembs", ";", "size", "=", "dt", "->", "shared", "->", "size", ";", "HDassert", "(", "size", "<=", "sizeof", "(", "tbuf", ")", ")", ";", "for", "(", "i", "=", "(", "nmembs", "-", "1", ")", ",", "swapped", "=", "TRUE", ";", "i", ">", "0", "&&", "swapped", ";", "--", "i", ")", "{", "for", "(", "j", "=", "0", ",", "swapped", "=", "FALSE", ";", "j", "<", "i", ";", "j", "++", ")", "{", "if", "(", "HDmemcmp", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "j", "*", "size", ")", ",", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "(", "j", "+", "1", ")", "*", "size", ")", ",", "size", ")", ">", "0", ")", "{", "/*", "Swap", "names", "*/", "char", "*", "tmp", "=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "]", ";", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "]", "=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "+", "1", "]", ";", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "j", "+", "1", "]", "=", "tmp", ";", "/*", "Swap", "values", "*/", "HDmemcpy", "(", "tbuf", ",", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "j", "*", "size", ")", ",", "size", ")", ";", "HDmemcpy", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "j", "*", "size", ")", ",", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "(", "j", "+", "1", ")", "*", "size", ")", ",", "size", ")", ";", "HDmemcpy", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "(", "j", "+", "1", ")", "*", "size", ")", ",", "tbuf", ",", "size", ")", ";", "/*", "Swap", "map", "*/", "if", "(", "map", ")", "{", "int", "x", "=", "map", "[", "j", "]", ";", "map", "[", "j", "]", "=", "map", "[", "j", "+", "1", "]", ";", "map", "[", "j", "+", "1", "]", "=", "x", ";", "}", "/*", "end", "if", "*/", "swapped", "=", "TRUE", ";", "}", "/*", "end", "if", "*/", "}", "/*", "end", "for", "*/", "}", "/*", "end", "for", "*/", "#", "ifndef", "NDEBUG", "/*", "I", "never", "trust", "a", "sort", ":-)", "-RPM", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "(", "nmembs", "-", "1", ")", ";", "i", "++", ")", "HDassert", "(", "HDmemcmp", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "i", "*", "size", ")", ",", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "value", "+", "(", "(", "i", "+", "1", ")", "*", "size", ")", ",", "size", ")", "<", "0", ")", ";", "#", "endif", "}", "/*", "end", "if", "*/", "}", "/*", "end", "else", "*/", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Returns", "the", "name", "of", "a", "member", "of", "a", "compound", "or", "enumeration", "datatype" ]

[ "'char", "*", "H5Tget_member_name", "(", "hid_t", "type_id", ",", "unsigned", "membno", ")", "{", "H5T_t", "*", "dt", "=", "NULL", ";", "char", "*", "ret_value", ";", "FUNC_ENTER_API", "(", "NULL", ")", "H5TRACE2", "(", "\"*s\"", ",", "\"iIu\"", ",", "type_id", ",", "membno", ")", ";", "/*", "Check", "args", "*/", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object_verify", "(", "type_id", ",", "H5I_DATATYPE", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "datatype\"", ")", "if", "(", "NULL", "==", "(", "ret_value", "=", "H5T__get_member_name", "(", "dt", ",", "membno", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"unable", "to", "get", "member", "name\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Private", "function", "for", "H5Tget_member_name" ]

[ "'char", "*", "H5T__get_member_name", "(", "H5T_t", "const", "*", "dt", ",", "unsigned", "membno", ")", "{", "char", "*", "ret_value", ";", "FUNC_ENTER_PACKAGE", "HDassert", "(", "dt", ")", ";", "switch", "(", "dt", "->", "shared", "->", "type", ")", "{", "case", "H5T_COMPOUND", ":", "if", "(", "membno", ">=", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "nmembs", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "NULL", ",", "\"invalid", "member", "number\"", ")", "ret_value", "=", "H5MM_xstrdup", "(", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "memb", "[", "membno", "]", ".", "name", ")", ";", "break;", "case", "H5T_ENUM", ":", "if", "(", "membno", ">=", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "nmembs", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "NULL", ",", "\"invalid", "member", "number\"", ")", "ret_value", "=", "H5MM_xstrdup", "(", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "name", "[", "membno", "]", ")", ";", "break;", "case", "H5T_NO_CLASS", ":", "case", "H5T_INTEGER", ":", "case", "H5T_FLOAT", ":", "case", "H5T_TIME", ":", "case", "H5T_STRING", ":", "case", "H5T_BITFIELD", ":", "case", "H5T_OPAQUE", ":", "case", "H5T_REFERENCE", ":", "case", "H5T_VLEN", ":", "case", "H5T_ARRAY", ":", "case", "H5T_NCLASSES", ":", "default:", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"operation", "not", "supported", "for", "type", "class\"", ")", "}", "/*lint", "!e788", "All", "appropriate", "cases", "are", "covered", "*/", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Private", "function", "for", "H5Tget_nmembers" ]

[ "'int", "H5T_get_nmembers", "(", "const", "H5T_t", "*", "dt", ")", "{", "int", "ret_value", ";", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "HDassert", "(", "dt", ")", ";", "if", "(", "H5T_COMPOUND", "==", "dt", "->", "shared", "->", "type", ")", "ret_value", "=", "(", "int", ")", "dt", "->", "shared", "->", "u", ".", "compnd", ".", "nmembs", ";", "<if", "type=\"elseif\">", "else", "if", "(", "H5T_ENUM", "==", "dt", "->", "shared", "->", "type", ")", "ret_value", "=", "(", "int", ")", "dt", "->", "shared", "->", "u", ".", "enumer", ".", "nmembs", ";", "else", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "FAIL", ",", "\"operation", "not", "supported", "for", "type", "class\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Determines", "how", "many", "members", "TYPE_ID", "has" ]

[ "'int", "H5Tget_nmembers", "(", "hid_t", "type_id", ")", "{", "H5T_t", "*", "dt", ";", "/*", "Datatype", "to", "query", "*/", "int", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE1", "(", "\"Is\"", ",", "\"i\"", ",", "type_id", ")", ";", "/*", "Check", "args", "*/", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object_verify", "(", "type_id", ",", "H5I_DATATYPE", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "FAIL", ",", "\"not", "a", "datatype\"", ")", "if", "(", "(", "ret_value", "=", "H5T_get_nmembers", "(", "dt", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "FAIL", ",", "\"cannot", "return", "member", "number\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Load", "Lua", "source", "code", "and", "bytecode" ]

[ "\"static", "TValue", "*", "cpparser", "(", "lua_State", "*", "L", ",", "lua_CFunction", "dummy", ",", "void", "*", "ud", ")", "{", "LexState", "*", "ls", "=", "(", "LexState", "*", ")", "ud", ";", "GCproto", "*", "pt", ";", "GCfunc", "*", "fn", ";", "int", "bc", ";", "UNUSED", "(", "dummy", ")", ";", "cframe_errfunc", "(", "L", "->", "cframe", ")", "=", "-", "1", ";", "/*", "Inherit", "error", "function.", "*/", "bc", "=", "lj_lex_setup", "(", "L", ",", "ls", ")", ";", "if", "(", "ls", "->", "mode", "&&", "!", "strchr", "(", "ls", "->", "mode", ",", "bc", "?", "'b'", ":", "'t'", ")", ")", "{", "setstrV", "(", "L", ",", "L", "->", "top", "++", ",", "lj_err_str", "(", "L", ",", "LJ_ERR_XMODE", ")", ")", ";", "lj_err_throw", "(", "L", ",", "LUA_ERRSYNTAX", ")", ";", "}", "pt", "=", "bc", "?", "lj_bcread", "(", "ls", ")", ":", "lj_parse", "(", "ls", ")", ";", "fn", "=", "lj_func_newL_empty", "(", "L", ",", "pt", ",", "tabref", "(", "L", "->", "env", ")", ")", ";", "/*", "Don't", "combine", "above/below", "into", "one", "statement.", "*/", "setfuncV", "(", "L", ",", "L", "->", "top", "++", ",", "fn", ")", ";", "return", "NULL", ";", "}\"" ]

[ "must", "have", "the", "close", "too" ]

[ "'int", "ff_tee_parse_slave_options", "(", "void", "*", "log", ",", "char", "*", "slave", ",", "AVDictionary", "*", "*", "options", ",", "char", "*", "*", "filename", ")", "{", "const", "char", "*", "p", ";", "char", "*", "key", ",", "<type", "ref=\"prev\">", "*", "val", ";", "int", "ret", ";", "if", "(", "!", "strspn", "(", "slave", ",", "slave_opt_open", ")", ")", "{", "*", "filename", "=", "slave", ";", "return", "0", ";", "}", "p", "=", "slave", "+", "1", ";", "if", "(", "strspn", "(", "p", ",", "slave_opt_close", ")", ")", "{", "*", "filename", "=", "(", "char", "*", ")", "p", "+", "1", ";", "return", "0", ";", "}", "while", "(", "1", ")", "{", "ret", "=", "av_opt_get_key_value", "(", "&", "p", ",", "\"=\"", ",", "slave_opt_delim", ",", "0", ",", "&", "key", ",", "&", "val", ")", ";", "if", "(", "ret", "<", "0", ")", "{", "av_log", "(", "log", ",", "AV_LOG_ERROR", ",", "\"No", "option", "found", "near", "\\\\\"%s\\\\\"\\\"", ",", "p", ")", ";", "goto", "fail", ";", "}", "ret", "=", "av_dict_set", "(", "options", ",", "key", ",", "val", ",", "AV_DICT_DONT_STRDUP_KEY", "|", "AV_DICT_DONT_STRDUP_VAL", ")", ";", "if", "(", "ret", "<", "0", ")", "goto", "fail", ";", "if", "(", "strspn", "(", "p", ",", "slave_opt_close", ")", ")", "break;", "p", "++", ";", "}", "*", "filename", "=", "(", "char", "*", ")", "p", "+", "1", ";", "return", "0", ";", "fail", ":", "av_dict_free", "(", "options", ")", ";", "return", "ret", ";", "}'" ]

[ "check", "if", "report", "have", "to", "be", "sent", "after", "data", "model", "update" ]

[ "'void", "Reporting_processReportEventsAfterUnlock", "(", "MmsMapping", "*", "self", ")", "{", "LinkedList", "element", "=", "self", "->", "reportControls", ";", "uint64_t", "currentTime", "=", "Hal_getTimeInMs", "()", ";", "while", "(", "(", "element", "=", "LinkedList_getNext", "(", "element", ")", ")", "!=", "NULL", ")", "{", "ReportControl", "*", "rc", "=", "(", "ReportControl", "*", ")", "element", "->", "data", ";", "ReportControl_lockNotify", "(", "rc", ")", ";", "if", "(", "(", "rc", "->", "enabled", ")", "||", "(", "rc", "->", "isBuffering", ")", ")", "{", "if", "(", "rc", "->", "triggered", ")", "{", "copyValuesToReportBuffer", "(", "rc", ")", ";", "processEventsForReport", "(", "rc", ",", "currentTime", ")", ";", "}", "}", "ReportControl_unlockNotify", "(", "rc", ")", ";", "}", "}'" ]

[ "So", "the", "player", "can", "safely", "go", "back", "through", "defeated", "floors", "to", "use", "the", "Poke", "Center", "(or", "exit", "challenge)" ]

[ "'static", "void", "GetFloorAlreadyCleared", "(", "void", ")", "{", "u16", "mapLayoutId", "=", "gMapHeader", ".", "mapLayoutId", ";", "if", "(", "mapLayoutId", "-", "LAYOUT_TRAINER_TOWER_1F", "==", "TRAINER_TOWER", ".", "floorsCleared", "&&", "mapLayoutId", "-", "LAYOUT_TRAINER_TOWER_LOBBY", "<=", "CURR_FLOOR", ".", "floorIdx", ")", "gSpecialVar_Result", "=", "FALSE", ";", "else", "gSpecialVar_Result", "=", "TRUE", ";", "}'" ]

[ "Implementation", "of", "ostream_t", "methods" ]

[ "'static", "void", "term_styled_ostream__write_mem", "(", "term_styled_ostream_t", "stream", ",", "const", "void", "*", "data", ",", "size_t", "len", ")", "{", "term_ostream_set_color", "(", "stream", "->", "destination", ",", "stream", "->", "curr_attr", "->", "color", ")", ";", "term_ostream_set_bgcolor", "(", "stream", "->", "destination", ",", "stream", "->", "curr_attr", "->", "bgcolor", ")", ";", "term_ostream_set_weight", "(", "stream", "->", "destination", ",", "stream", "->", "curr_attr", "->", "weight", ")", ";", "term_ostream_set_posture", "(", "stream", "->", "destination", ",", "stream", "->", "curr_attr", "->", "posture", ")", ";", "term_ostream_set_underline", "(", "stream", "->", "destination", ",", "stream", "->", "curr_attr", "->", "underline", ")", ";", "term_ostream_write_mem", "(", "stream", "->", "destination", ",", "data", ",", "len", ")", ";", "}'" ]

[ "Be", "to", "keep", "vec", "examples", "ex21" ]

[ "'PETSC_EXTERN", "void", "vecrestorearray_", "(", "Vec", "*", "x", ",", "PetscScalar", "*", "fa", ",", "size_t", "*", "ia", ",", "PetscErrorCode", "*", "ierr", ")", "{", "PetscInt", "m", ";", "PetscScalar", "*", "lx", ";", "*", "ierr", "=", "VecGetLocalSize", "(", "*", "x", ",", "&", "m", ")", ";", "if", "(", "*", "ierr", ")", "return", ";", "*", "ierr", "=", "PetscScalarAddressFromFortran", "(", "(", "PetscObject", ")", "*", "x", ",", "fa", ",", "*", "ia", ",", "m", ",", "&", "lx", ")", ";", "if", "(", "*", "ierr", ")", "return", ";", "*", "ierr", "=", "VecRestoreArray", "(", "*", "x", ",", "&", "lx", ")", ";", "if", "(", "*", "ierr", ")", "return", ";", "}'" ]

[ "Prepare", "an", "OCSP", "test" ]

[ "'static", "void", "ocsp_prepare_test", "(", "struct", "ocsp_test", "*", "test", ")", "{", "struct", "x509_certificate", "*", "cert", "=", "test", "->", "cert", "->", "cert", ";", "struct", "x509_certificate", "*", "issuer", "=", "test", "->", "issuer", "->", "cert", ";", "/*", "Invalidate", "certificate", "being", "checked", "*/", "x509_invalidate", "(", "cert", ")", ";", "/*", "Force-validate", "issuer", "certificate", "*/", "issuer", "->", "flags", "|=", "X509_FL_VALIDATED", ";", "issuer", "->", "path_remaining", "=", "(", "issuer", "->", "extensions", ".", "basic", ".", "path_len", "+", "1", ")", ";", "}'" ]

[ "Handle", "various", "control", "requests", "related", "to", "the", "msc", "storage" ]

[ "'static", "enum", "usbd_request_return_codes", "msc_control_request", "(", "usbd_device", "*", "usbd_dev", ",", "struct", "usb_setup_data", "*", "req", ",", "uint8_t", "*", "*", "buf", ",", "uint16_t", "*", "len", ",", "usbd_control_complete_callback", "*", "complete", ")", "{", "(", "void", ")", "complete", ";", "(", "void", ")", "usbd_dev", ";", "switch", "(", "req", "->", "bRequest", ")", "{", "case", "USB_MSC_REQ_BULK_ONLY_RESET", ":", "/*", "Do", "any", "special", "reset", "code", "here.", "*/", "return", "USBD_REQ_HANDLED", ";", "case", "USB_MSC_REQ_GET_MAX_LUN", ":", "/*", "Return", "the", "number", "of", "LUNs.", "We", "use", "0.", "*/", "*", "buf", "[", "0", "]", "=", "0", ";", "*", "len", "=", "1", ";", "return", "USBD_REQ_HANDLED", ";", "}", "return", "USBD_REQ_NOTSUPP", ";", "}'" ]

[ "Handle", "the", "USB", "'OUT'", "requests" ]

[ "'static", "void", "msc_data_rx_cb", "(", "usbd_device", "*", "usbd_dev", ",", "uint8_t", "ep", ")", "{", "usbd_mass_storage", "*", "ms", ";", "struct", "usb_msc_trans", "*", "trans", ";", "int", "len", ",", "<type", "ref=\"prev\"/>", "max_len", ",", "<type", "ref=\"prev\"/>", "left", ";", "void", "*", "p", ";", "ms", "=", "&", "_mass_storage", ";", "trans", "=", "&", "ms", "->", "trans", ";", "/*", "RX", "only", "*/", "left", "=", "sizeof", "(", "struct", "usb_msc_cbw", ")", "-", "trans", "->", "cbw_cnt", ";", "if", "(", "0", "<", "left", ")", "{", "max_len", "=", "MIN", "(", "ms", "->", "ep_out_size", ",", "left", ")", ";", "p", "=", "&", "trans", "->", "cbw", ".", "buf", "[", "0x1ff", "&", "trans", "->", "cbw_cnt", "]", ";", "len", "=", "usbd_ep_read_packet", "(", "usbd_dev", ",", "ep", ",", "p", ",", "max_len", ")", ";", "trans", "->", "cbw_cnt", "+=", "len", ";", "if", "(", "sizeof", "(", "struct", "usb_msc_cbw", ")", "==", "trans", "->", "cbw_cnt", ")", "{", "scsi_command", "(", "ms", ",", "trans", ",", "EVENT_CBW_VALID", ")", ";", "if", "(", "trans", "->", "byte_count", "<", "trans", "->", "bytes_to_read", ")", "{", "/*", "We", "must", "wait", "until", "there", "is", "something", "to", "*", "read", "again.", "*/", "return", ";", "}", "}", "}", "if", "(", "trans", "->", "byte_count", "<", "trans", "->", "bytes_to_read", ")", "{", "if", "(", "0", "<", "trans", "->", "block_count", ")", "{", "if", "(", "(", "0", "==", "trans", "->", "byte_count", ")", "&&", "(", "NULL", "!=", "ms", "->", "lock", ")", ")", "{", "(", "*", "ms", "->", "lock", ")", "()", ";", "}", "}", "left", "=", "trans", "->", "bytes_to_read", "-", "trans", "->", "byte_count", ";", "max_len", "=", "MIN", "(", "ms", "->", "ep_out_size", ",", "left", ")", ";", "p", "=", "&", "trans", "->", "msd_buf", "[", "0x1ff", "&", "trans", "->", "byte_count", "]", ";", "len", "=", "usbd_ep_read_packet", "(", "usbd_dev", ",", "ep", ",", "p", ",", "max_len", ")", ";", "trans", "->", "byte_count", "+=", "len", ";", "if", "(", "0", "<", "trans", "->", "block_count", ")", "{", "if", "(", "0", "==", "(", "0x1ff", "&", "trans", "->", "byte_count", ")", ")", "{", "uint32_t", "lba", ";", "lba", "=", "trans", "->", "lba_start", "+", "trans", "->", "current_block", ";", "if", "(", "0", "!=", "(", "*", "ms", "->", "write_block", ")", "(", "lba", ",", "trans", "->", "msd_buf", ")", ")", "{", "/*", "Error", "*/", "}", "trans", "->", "current_block", "++", ";", "}", "}", "/*", "Fix", "\"writes", "aren\\'t", "acknowledged\"", "bug", "on", "Linux", "(PR", "#409)", "*/", "if", "(", "false", "==", "trans", "->", "csw_valid", ")", "{", "scsi_command", "(", "ms", ",", "trans", ",", "EVENT_NEED_STATUS", ")", ";", "trans", "->", "csw_valid", "=", "true", ";", "}", "left", "=", "sizeof", "(", "struct", "usb_msc_csw", ")", "-", "trans", "->", "csw_sent", ";", "if", "(", "0", "<", "left", ")", "{", "max_len", "=", "MIN", "(", "ms", "->", "ep_out_size", ",", "left", ")", ";", "p", "=", "&", "trans", "->", "csw", ".", "buf", "[", "trans", "->", "csw_sent", "]", ";", "len", "=", "usbd_ep_write_packet", "(", "usbd_dev", ",", "ms", "->", "ep_in", ",", "p", ",", "max_len", ")", ";", "trans", "->", "csw_sent", "+=", "len", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "trans", "->", "byte_count", "<", "trans", "->", "bytes_to_write", ")", "{", "if", "(", "0", "<", "trans", "->", "block_count", ")", "{", "if", "(", "(", "0", "==", "trans", "->", "byte_count", ")", "&&", "(", "NULL", "!=", "ms", "->", "lock", ")", ")", "{", "(", "*", "ms", "->", "lock", ")", "()", ";", "}", "if", "(", "0", "==", "(", "0x1ff", "&", "trans", "->", "byte_count", ")", ")", "{", "uint32_t", "lba", ";", "lba", "=", "trans", "->", "lba_start", "+", "trans", "->", "current_block", ";", "if", "(", "0", "!=", "(", "*", "ms", "->", "read_block", ")", "(", "lba", ",", "trans", "->", "msd_buf", ")", ")", "{", "/*", "Error", "*/", "}", "trans", "->", "current_block", "++", ";", "}", "}", "left", "=", "trans", "->", "bytes_to_write", "-", "trans", "->", "byte_count", ";", "max_len", "=", "MIN", "(", "ms", "->", "ep_out_size", ",", "left", ")", ";", "p", "=", "&", "trans", "->", "msd_buf", "[", "0x1ff", "&", "trans", "->", "byte_count", "]", ";", "len", "=", "usbd_ep_write_packet", "(", "usbd_dev", ",", "ms", "->", "ep_in", ",", "p", ",", "max_len", ")", ";", "trans", "->", "byte_count", "+=", "len", ";", "}", "else", "{", "if", "(", "0", "<", "trans", "->", "block_count", ")", "{", "if", "(", "trans", "->", "current_block", "==", "trans", "->", "block_count", ")", "{", "uint32_t", "lba", ";", "lba", "=", "trans", "->", "lba_start", "+", "trans", "->", "current_block", ";", "if", "(", "0", "!=", "(", "*", "ms", "->", "write_block", ")", "(", "lba", ",", "trans", "->", "msd_buf", ")", ")", "{", "/*", "Error", "*/", "}", "trans", "->", "current_block", "=", "0", ";", "if", "(", "NULL", "!=", "ms", "->", "unlock", ")", "{", "(", "*", "ms", "->", "unlock", ")", "()", ";", "}", "}", "}", "if", "(", "false", "==", "trans", "->", "csw_valid", ")", "{", "scsi_command", "(", "ms", ",", "trans", ",", "EVENT_NEED_STATUS", ")", ";", "trans", "->", "csw_valid", "=", "true", ";", "}", "left", "=", "sizeof", "(", "struct", "usb_msc_csw", ")", "-", "trans", "->", "csw_sent", ";", "if", "(", "0", "<", "left", ")", "{", "max_len", "=", "MIN", "(", "ms", "->", "ep_out_size", ",", "left", ")", ";", "p", "=", "&", "trans", "->", "csw", ".", "buf", "[", "trans", "->", "csw_sent", "]", ";", "len", "=", "usbd_ep_write_packet", "(", "usbd_dev", ",", "ms", "->", "ep_in", ",", "p", ",", "max_len", ")", ";", "trans", "->", "csw_sent", "+=", "len", ";", "}", "}", "}'" ]

[ "Initializes", "the", "USB", "Mass", "Storage", "subsystem" ]

[ "'usbd_mass_storage", "*", "usb_msc_init", "(", "usbd_device", "*", "usbd_dev", ",", "uint8_t", "ep_in", ",", "uint8_t", "ep_in_size", ",", "uint8_t", "ep_out", ",", "uint8_t", "ep_out_size", ",", "const", "char", "*", "vendor_id", ",", "const", "char", "*", "product_id", ",", "const", "char", "*", "product_revision_level", ",", "const", "uint32_t", "block_count", ",", "int", "(", "*", "read_block", ")", "(", "uint32_t", "lba", ",", "uint8_t", "*", "copy_to", ")", ",", "int", "(", "*", "write_block", ")", "(", "uint32_t", "lba", ",", "const", "uint8_t", "*", "copy_from", ")", ")", "{", "_mass_storage", ".", "usbd_dev", "=", "usbd_dev", ";", "_mass_storage", ".", "ep_in", "=", "ep_in", ";", "_mass_storage", ".", "ep_in_size", "=", "ep_in_size", ";", "_mass_storage", ".", "ep_out", "=", "ep_out", ";", "_mass_storage", ".", "ep_out_size", "=", "ep_out_size", ";", "_mass_storage", ".", "vendor_id", "=", "vendor_id", ";", "_mass_storage", ".", "product_id", "=", "product_id", ";", "_mass_storage", ".", "product_revision_level", "=", "product_revision_level", ";", "_mass_storage", ".", "block_count", "=", "block_count", "-", "1", ";", "_mass_storage", ".", "read_block", "=", "read_block", ";", "_mass_storage", ".", "write_block", "=", "write_block", ";", "_mass_storage", ".", "lock", "=", "NULL", ";", "_mass_storage", ".", "unlock", "=", "NULL", ";", "_mass_storage", ".", "trans", ".", "lba_start", "=", "0xffffffff", ";", "_mass_storage", ".", "trans", ".", "block_count", "=", "0", ";", "_mass_storage", ".", "trans", ".", "current_block", "=", "0", ";", "_mass_storage", ".", "trans", ".", "cbw_cnt", "=", "0", ";", "_mass_storage", ".", "trans", ".", "bytes_to_read", "=", "0", ";", "_mass_storage", ".", "trans", ".", "bytes_to_write", "=", "0", ";", "_mass_storage", ".", "trans", ".", "byte_count", "=", "0", ";", "_mass_storage", ".", "trans", ".", "csw_valid", "=", "false", ";", "_mass_storage", ".", "trans", ".", "csw_sent", "=", "0", ";", "set_sbc_status_good", "(", "&", "_mass_storage", ")", ";", "usbd_register_set_config_callback", "(", "usbd_dev", ",", "msc_set_config", ")", ";", "return", "&", "_mass_storage", ";", "}'" ]

[ "Run", "the", "fast", "dce", "as", "a", "side", "effect", "of", "building", "LR" ]

[ "'static", "void", "df_lr_finalize", "(", "bitmap", "all_blocks", ")", "{", "df_lr", "->", "solutions_dirty", "=", "false", ";", "if", "(", "df", "->", "changeable_flags", "&", "DF_LR_RUN_DCE", ")", "{", "run_fast_df_dce", "()", ";", "/*", "If", "dce", "deletes", "some", "instructions,", "we", "need", "to", "recompute", "the", "lr", "solution", "before", "proceeding", "further.", "The", "problem", "is", "that", "fast", "dce", "is", "a", "pessimestic", "dataflow", "algorithm.", "In", "the", "case", "where", "it", "deletes", "a", "statement", "S", "inside", "of", "a", "loop,", "the", "uses", "inside", "of", "S", "may", "not", "be", "deleted", "from", "the", "dataflow", "solution", "because", "they", "were", "carried", "around", "the", "loop.", "While", "it", "is", "conservatively", "correct", "to", "leave", "these", "extra", "bits,", "the", "standards", "of", "df", "require", "that", "we", "maintain", "the", "best", "possible", "(least", "fixed", "point)", "solution.", "The", "only", "way", "to", "do", "that", "is", "to", "redo", "the", "iteration", "from", "the", "beginning.", "See", "PR35805", "for", "an", "example.", "*/", "if", "(", "df_lr", "->", "solutions_dirty", ")", "{", "df_clear_flags", "(", "DF_LR_RUN_DCE", ")", ";", "df_lr_alloc", "(", "all_blocks", ")", ";", "df_lr_local_compute", "(", "all_blocks", ")", ";", "df_worklist_dataflow", "(", "df_lr", ",", "all_blocks", ",", "df", "->", "postorder", ",", "df", "->", "n_blocks", ")", ";", "df_lr_finalize", "(", "all_blocks", ")", ";", "df_set_flags", "(", "DF_LR_RUN_DCE", ")", ";", "}", "}", "}'" ]

[ "Compute", "local", "uninitialized", "register", "info" ]

[ "'static", "void", "df_live_local_compute", "(", "bitmap", "all_blocks", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "bb_index", ";", "bitmap_iterator", "bi", ";", "df_grow_insn_info", "()", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "df_live->out_of_date_transfer_functions", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "df_live_bb_local_compute", "(", "bb_index", ")", ";", "}", "bitmap_clear", "(", "df_live", "->", "out_of_date_transfer_functions", ")", ";", "}'" ]

[ "Simulate", "the", "forwards", "effects", "of", "INSN", "on", "the", "bitmap", "LIVE" ]

[ "'void", "df_simulate_one_insn_forwards", "(", "basic_block", "bb", ",", "rtx", "insn", ",", "bitmap", "live", ")", "{", "rtx", "link", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", ";", "/*", "Make", "sure", "that", "DF_NOTE", "really", "is", "an", "active", "df", "problem.", "*/", "gcc_assert", "(", "df_note", ")", ";", "/*", "Note", "that", "this", "is", "the", "opposite", "as", "how", "the", "problem", "is", "defined,", "because", "in", "the", "LR", "problem", "defs", "_kill_", "liveness.", "However,", "they", "do", "so", "backwards,", "while", "here", "the", "scan", "is", "performed", "forwards!", "So,", "first", "assume", "that", "the", "def", "is", "live,", "and", "if", "this", "is", "not", "true", "REG_UNUSED", "notes", "will", "rectify", "the", "situation.", "*/", "df_simulate_find_noclobber_defs", "(", "insn", ",", "live", ")", ";", "/*", "Clear", "all", "of", "the", "registers", "that", "go", "dead.", "*/", "for", "(", "link", "=", "REG_NOTES", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "{", "switch", "(", "REG_NOTE_KIND", "(", "link", ")", ")", "{", "case", "REG_DEAD", ":", "case", "REG_UNUSED", ":", "{", "rtx", "reg", "=", "XEXP", "(", "link", ",", "0", ")", ";", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "bitmap_clear_range", "(", "live", ",", "regno", ",", "hard_regno_nregs", "[", "regno", "]", "[", "GET_MODE", "(", "reg", ")", "]", ")", ";", "else", "bitmap_clear_bit", "(", "live", ",", "regno", ")", ";", "}", "break;", "default:", "break;", "}", "}", "df_simulate_fixup_sets", "(", "bb", ",", "live", ")", ";", "}'" ]

[ "Transfer", "function", "for", "the", "forwards", "mustinitialized", "problem" ]

[ "'static", "bool", "df_live_transfer_function", "(", "int", "bb_index", ")", "{", "struct", "df_live_bb_info", "*", "bb_info", "=", "df_live_get_bb_info", "(", "bb_index", ")", ";", "struct", "df_lr_bb_info", "*", "bb_lr_info", "=", "df_lr_get_bb_info", "(", "bb_index", ")", ";", "bitmap", "in", "=", "&", "bb_info", "->", "in", ";", "bitmap", "out", "=", "&", "bb_info", "->", "out", ";", "bitmap", "gen", "=", "&", "bb_info", "->", "gen", ";", "bitmap", "kill", "=", "&", "bb_info", "->", "kill", ";", "/*", "We", "need", "to", "use", "a", "scratch", "set", "here", "so", "that", "the", "value", "returned", "from", "this", "function", "invocation", "properly", "reflects", "whether", "the", "sets", "changed", "in", "a", "significant", "way;", "i.e.", "not", "just", "because", "the", "lr", "set", "was", "anded", "in.", "*/", "bitmap_and", "(", "&", "df_live_scratch", ",", "gen", ",", "&", "bb_lr_info", "->", "out", ")", ";", "/*", "No", "register", "may", "reach", "a", "location", "where", "it", "is", "not", "used.", "Thus", "we", "trim", "the", "rr", "result", "to", "the", "places", "where", "it", "is", "used.", "*/", "bitmap_and_into", "(", "in", ",", "&", "bb_lr_info", "->", "in", ")", ";", "return", "bitmap_ior_and_compl", "(", "out", ",", "&", "df_live_scratch", ",", "in", ",", "kill", ")", ";", "}'" ]

[ "Compute", "local", "live", "register", "info", "for", "basic", "block", "BB" ]

[ "'static", "void", "df_lr_bb_local_compute", "(", "unsigned", "int", "bb_index", ")", "{", "basic_block", "bb", "=", "BASIC_BLOCK", "(", "bb_index", ")", ";", "struct", "df_lr_bb_info", "*", "bb_info", "=", "df_lr_get_bb_info", "(", "bb_index", ")", ";", "rtx", "insn", ";", "df_ref", "*", "def_rec", ";", "df_ref", "*", "use_rec", ";", "/*", "Process", "the", "registers", "set", "in", "an", "exception", "handler.", "*/", "for", "(", "def_rec", "=", "df_get_artificial_defs", "(", "bb_index", ")", ";", "*", "def_rec", ";", "def_rec", "++", ")", "{", "df_ref", "def", "=", "*", "def_rec", ";", "if", "(", "(", "DF_REF_FLAGS", "(", "def", ")", "&", "DF_REF_AT_TOP", ")", "==", "0", ")", "{", "unsigned", "int", "dregno", "=", "DF_REF_REGNO", "(", "def", ")", ";", "bitmap_set_bit", "(", "&", "bb_info", "->", "def", ",", "dregno", ")", ";", "bitmap_clear_bit", "(", "&", "bb_info", "->", "use", ",", "dregno", ")", ";", "}", "}", "/*", "Process", "the", "hardware", "registers", "that", "are", "always", "live.", "*/", "for", "(", "use_rec", "=", "df_get_artificial_uses", "(", "bb_index", ")", ";", "*", "use_rec", ";", "use_rec", "++", ")", "{", "df_ref", "use", "=", "*", "use_rec", ";", "/*", "Add", "use", "to", "set", "of", "uses", "in", "this", "BB.", "*/", "if", "(", "(", "DF_REF_FLAGS", "(", "use", ")", "&", "DF_REF_AT_TOP", ")", "==", "0", ")", "bitmap_set_bit", "(", "&", "bb_info", "->", "use", ",", "DF_REF_REGNO", "(", "use", ")", ")", ";", "}", "FOR_BB_INSNS_REVERSE", "(", "bb", ",", "insn", ")", "{", "unsigned", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "continue;", "for", "(", "def_rec", "=", "DF_INSN_UID_DEFS", "(", "uid", ")", ";", "*", "def_rec", ";", "def_rec", "++", ")", "{", "df_ref", "def", "=", "*", "def_rec", ";", "/*", "If", "the", "def", "is", "to", "only", "part", "of", "the", "reg,", "it", "does", "not", "kill", "the", "other", "defs", "that", "reach", "here.", "*/", "if", "(", "!", "(", "DF_REF_FLAGS", "(", "def", ")", "&", "(", "DF_REF_PARTIAL", "|", "DF_REF_CONDITIONAL", ")", ")", ")", "{", "unsigned", "int", "dregno", "=", "DF_REF_REGNO", "(", "def", ")", ";", "bitmap_set_bit", "(", "&", "bb_info", "->", "def", ",", "dregno", ")", ";", "bitmap_clear_bit", "(", "&", "bb_info", "->", "use", ",", "dregno", ")", ";", "}", "}", "for", "(", "use_rec", "=", "DF_INSN_UID_USES", "(", "uid", ")", ";", "*", "use_rec", ";", "use_rec", "++", ")", "{", "df_ref", "use", "=", "*", "use_rec", ";", "/*", "Add", "use", "to", "set", "of", "uses", "in", "this", "BB.", "*/", "bitmap_set_bit", "(", "&", "bb_info", "->", "use", ",", "DF_REF_REGNO", "(", "use", ")", ")", ";", "}", "}", "/*", "Process", "the", "registers", "set", "in", "an", "exception", "handler", "or", "the", "hard", "frame", "pointer", "if", "this", "block", "is", "the", "target", "of", "a", "non", "local", "goto.", "*/", "for", "(", "def_rec", "=", "df_get_artificial_defs", "(", "bb_index", ")", ";", "*", "def_rec", ";", "def_rec", "++", ")", "{", "df_ref", "def", "=", "*", "def_rec", ";", "if", "(", "DF_REF_FLAGS", "(", "def", ")", "&", "DF_REF_AT_TOP", ")", "{", "unsigned", "int", "dregno", "=", "DF_REF_REGNO", "(", "def", ")", ";", "bitmap_set_bit", "(", "&", "bb_info", "->", "def", ",", "dregno", ")", ";", "bitmap_clear_bit", "(", "&", "bb_info", "->", "use", ",", "dregno", ")", ";", "}", "}", "#", "ifdef", "EH_USES", "/*", "Process", "the", "uses", "that", "are", "live", "into", "an", "exception", "handler.", "*/", "for", "(", "use_rec", "=", "df_get_artificial_uses", "(", "bb_index", ")", ";", "*", "use_rec", ";", "use_rec", "++", ")", "{", "df_ref", "use", "=", "*", "use_rec", ";", "/*", "Add", "use", "to", "set", "of", "uses", "in", "this", "BB.", "*/", "if", "(", "DF_REF_FLAGS", "(", "use", ")", "&", "DF_REF_AT_TOP", ")", "bitmap_set_bit", "(", "&", "bb_info", "->", "use", ",", "DF_REF_REGNO", "(", "use", ")", ")", ";", "}", "#", "endif", "/*", "If", "the", "df_live", "problem", "is", "not", "defined,", "such", "as", "at", "-O0", "and", "-O1,", "we", "still", "need", "to", "keep", "the", "luids", "up", "to", "date.", "This", "is", "normally", "done", "in", "the", "df_live", "problem", "since", "this", "problem", "has", "a", "forwards", "scan.", "*/", "if", "(", "!", "df_live", ")", "df_recompute_luids", "(", "bb", ")", ";", "}'" ]

[ "Compute", "local", "reaching", "def", "info", "for", "each", "basic", "block", "within", "BLOCKS" ]

[ "'static", "void", "df_rd_local_compute", "(", "bitmap", "all_blocks", ")", "{", "unsigned", "int", "bb_index", ";", "bitmap_iterator", "bi", ";", "unsigned", "int", "regno", ";", "struct", "df_rd_problem_data", "*", "problem_data", "=", "(", "struct", "df_rd_problem_data", "*", ")", "df_rd", "->", "problem_data", ";", "bitmap", "sparse_invalidated", "=", "&", "problem_data", "->", "sparse_invalidated_by_call", ";", "bitmap", "dense_invalidated", "=", "&", "problem_data", "->", "dense_invalidated_by_call", ";", "bitmap_initialize", "(", "&", "seen_in_block", ",", "&", "df_bitmap_obstack", ")", ";", "bitmap_initialize", "(", "&", "seen_in_insn", ",", "&", "df_bitmap_obstack", ")", ";", "df_maybe_reorganize_def_refs", "(", "DF_REF_ORDER_BY_REG", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "df_rd_bb_local_compute", "(", "bb_index", ")", ";", "}", "/*", "Set", "up", "the", "knockout", "bit", "vectors", "to", "be", "applied", "across", "EH_EDGES.", "*/", "EXECUTE_IF_SET_IN_BITMAP", "(", "regs_invalidated_by_call_regset", ",", "0", ",", "regno", ",", "bi", ")", "{", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", "||", "!", "(", "df", "->", "changeable_flags", "&", "DF_NO_HARD_REGS", ")", ")", "{", "if", "(", "DF_DEFS_COUNT", "(", "regno", ")", ">", "DF_SPARSE_THRESHOLD", ")", "bitmap_set_bit", "(", "sparse_invalidated", ",", "regno", ")", ";", "else", "bitmap_set_range", "(", "dense_invalidated", ",", "DF_DEFS_BEGIN", "(", "regno", ")", ",", "DF_DEFS_COUNT", "(", "regno", ")", ")", ";", "}", "}", "bitmap_clear", "(", "&", "seen_in_block", ")", ";", "bitmap_clear", "(", "&", "seen_in_insn", ")", ";", "}'" ]

[ "Delete", "a", "du", "or", "ud", "chain", "that", "leave", "or", "point", "to", "REF" ]

[ "'void", "df_chain_unlink", "(", "df_ref", "ref", ")", "{", "struct", "df_link", "*", "chain", "=", "DF_REF_CHAIN", "(", "ref", ")", ";", "while", "(", "chain", ")", "{", "struct", "df_link", "*", "next", "=", "chain", "->", "next", ";", "/*", "Delete", "the", "other", "side", "if", "it", "exists.", "*/", "df_chain_unlink_1", "(", "chain", "->", "ref", ",", "ref", ")", ";", "pool_free", "(", "df_chain", "->", "block_pool", ",", "chain", ")", ";", "chain", "=", "next", ";", "}", "DF_REF_CHAIN", "(", "ref", ")", "=", "NULL", ";", "}'" ]

[ "Remove", "this", "problem", "from", "the", "stack", "of", "dataflow", "problems" ]

[ "'static", "void", "df_chain_remove_problem", "(", "void", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "int", "bb_index", ";", "/*", "Wholesale", "destruction", "of", "the", "old", "chains.", "*/", "if", "(", "df_chain", "->", "block_pool", ")", "free_alloc_pool", "(", "df_chain", "->", "block_pool", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "df_chain->out_of_date_transfer_functions", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "rtx", "insn", ";", "df_ref", "*", "def_rec", ";", "df_ref", "*", "use_rec", ";", "basic_block", "bb", "=", "BASIC_BLOCK", "(", "bb_index", ")", ";", "if", "(", "df_chain_problem_p", "(", "DF_DU_CHAIN", ")", ")", "for", "(", "def_rec", "=", "df_get_artificial_defs", "(", "bb", "->", "index", ")", ";", "*", "def_rec", ";", "def_rec", "++", ")", "DF_REF_CHAIN", "(", "*", "def_rec", ")", "=", "NULL", ";", "if", "(", "df_chain_problem_p", "(", "DF_UD_CHAIN", ")", ")", "for", "(", "use_rec", "=", "df_get_artificial_uses", "(", "bb", "->", "index", ")", ";", "*", "use_rec", ";", "use_rec", "++", ")", "DF_REF_CHAIN", "(", "*", "use_rec", ")", "=", "NULL", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "unsigned", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "df_chain_problem_p", "(", "DF_DU_CHAIN", ")", ")", "for", "(", "def_rec", "=", "DF_INSN_UID_DEFS", "(", "uid", ")", ";", "*", "def_rec", ";", "def_rec", "++", ")", "DF_REF_CHAIN", "(", "*", "def_rec", ")", "=", "NULL", ";", "if", "(", "df_chain_problem_p", "(", "DF_UD_CHAIN", ")", ")", "{", "for", "(", "use_rec", "=", "DF_INSN_UID_USES", "(", "uid", ")", ";", "*", "use_rec", ";", "use_rec", "++", ")", "DF_REF_CHAIN", "(", "*", "use_rec", ")", "=", "NULL", ";", "for", "(", "use_rec", "=", "DF_INSN_UID_EQ_USES", "(", "uid", ")", ";", "*", "use_rec", ";", "use_rec", "++", ")", "DF_REF_CHAIN", "(", "*", "use_rec", ")", "=", "NULL", ";", "}", "}", "}", "}", "bitmap_clear", "(", "df_chain", "->", "out_of_date_transfer_functions", ")", ";", "df_chain", "->", "block_pool", "=", "NULL", ";", "}'" ]

[ "Initialize", "the", "solution", "bit", "vectors", "for", "problem" ]

[ "'static", "void", "df_rd_init_solution", "(", "bitmap", "all_blocks", ")", "{", "unsigned", "int", "bb_index", ";", "bitmap_iterator", "bi", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "struct", "df_rd_bb_info", "*", "bb_info", "=", "df_rd_get_bb_info", "(", "bb_index", ")", ";", "bitmap_copy", "(", "&", "bb_info", "->", "out", ",", "&", "bb_info", "->", "gen", ")", ";", "bitmap_clear", "(", "&", "bb_info", "->", "in", ")", ";", "}", "}'" ]

[ "Simulate", "the", "effects", "of", "the", "uses", "of", "INSN", "on", "LIVE" ]

[ "'void", "df_word_lr_simulate_uses", "(", "rtx", "insn", ",", "bitmap", "live", ")", "{", "df_ref", "*", "use_rec", ";", "unsigned", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "for", "(", "use_rec", "=", "DF_INSN_UID_USES", "(", "uid", ")", ";", "*", "use_rec", ";", "use_rec", "++", ")", "df_word_lr_mark_ref", "(", "*", "use_rec", ",", "true", ",", "live", ")", ";", "}'" ]

[ "Free", "all", "storage", "associated", "with", "the", "problem" ]

[ "'static", "void", "df_lr_free", "(", "void", ")", "{", "struct", "df_lr_problem_data", "*", "problem_data", "=", "(", "struct", "df_lr_problem_data", "*", ")", "df_lr", "->", "problem_data", ";", "if", "(", "df_lr", "->", "block_info", ")", "{", "df_lr", "->", "block_info_size", "=", "0", ";", "free", "(", "df_lr", "->", "block_info", ")", ";", "df_lr", "->", "block_info", "=", "NULL", ";", "bitmap_obstack_release", "(", "&", "problem_data", "->", "lr_bitmaps", ")", ";", "free", "(", "df_lr", "->", "problem_data", ")", ";", "df_lr", "->", "problem_data", "=", "NULL", ";", "}", "BITMAP_FREE", "(", "df_lr", "->", "out_of_date_transfer_functions", ")", ";", "free", "(", "df_lr", ")", ";", "}'" ]

[ "Debugging", "info", "at", "top", "of", "bb" ]

[ "'static", "void", "df_rd_top_dump", "(", "basic_block", "bb", ",", "FILE", "*", "file", ")", "{", "struct", "df_rd_bb_info", "*", "bb_info", "=", "df_rd_get_bb_info", "(", "bb", "->", "index", ")", ";", "if", "(", "!", "bb_info", ")", "return", ";", "df_rd_dump_defs_set", "(", "&", "bb_info", "->", "in", ",", "\";;", "rd", "in", "\"", ",", "file", ")", ";", "df_rd_dump_defs_set", "(", "&", "bb_info", "->", "gen", ",", "\";;", "rd", "gen", "\"", ",", "file", ")", ";", "df_rd_dump_defs_set", "(", "&", "bb_info", "->", "kill", ",", "\";;", "rd", "kill\"", ",", "file", ")", ";", "}'" ]

[ "Compute", "local", "uninitialized", "register", "info", "for", "basic", "block", "BB" ]

[ "'static", "void", "df_live_bb_local_compute", "(", "unsigned", "int", "bb_index", ")", "{", "basic_block", "bb", "=", "BASIC_BLOCK", "(", "bb_index", ")", ";", "struct", "df_live_bb_info", "*", "bb_info", "=", "df_live_get_bb_info", "(", "bb_index", ")", ";", "rtx", "insn", ";", "df_ref", "*", "def_rec", ";", "int", "luid", "=", "0", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "unsigned", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_UID_GET", "(", "uid", ")", ";", "/*", "Inserting", "labels", "does", "not", "always", "trigger", "the", "incremental", "rescanning.", "*/", "if", "(", "!", "insn_info", ")", "{", "gcc_assert", "(", "!", "INSN_P", "(", "insn", ")", ")", ";", "insn_info", "=", "df_insn_create_insn_record", "(", "insn", ")", ";", "}", "DF_INSN_INFO_LUID", "(", "insn_info", ")", "=", "luid", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue;", "luid", "++", ";", "for", "(", "def_rec", "=", "DF_INSN_INFO_DEFS", "(", "insn_info", ")", ";", "*", "def_rec", ";", "def_rec", "++", ")", "{", "df_ref", "def", "=", "*", "def_rec", ";", "unsigned", "int", "regno", "=", "DF_REF_REGNO", "(", "def", ")", ";", "if", "(", "DF_REF_FLAGS_IS_SET", "(", "def", ",", "DF_REF_PARTIAL", "|", "DF_REF_CONDITIONAL", ")", ")", "/*", "All", "partial", "or", "conditional", "def", "seen", "are", "included", "in", "the", "gen", "set.", "*/", "bitmap_set_bit", "(", "&", "bb_info", "->", "gen", ",", "regno", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "DF_REF_FLAGS_IS_SET", "(", "def", ",", "DF_REF_MUST_CLOBBER", ")", ")", "/*", "Only", "must", "clobbers", "for", "the", "entire", "reg", "destroy", "the", "value.", "*/", "bitmap_set_bit", "(", "&", "bb_info", "->", "kill", ",", "regno", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "DF_REF_FLAGS_IS_SET", "(", "def", ",", "DF_REF_MAY_CLOBBER", ")", ")", "bitmap_set_bit", "(", "&", "bb_info", "->", "gen", ",", "regno", ")", ";", "}", "}", "for", "(", "def_rec", "=", "df_get_artificial_defs", "(", "bb_index", ")", ";", "*", "def_rec", ";", "def_rec", "++", ")", "{", "df_ref", "def", "=", "*", "def_rec", ";", "bitmap_set_bit", "(", "&", "bb_info", "->", "gen", ",", "DF_REF_REGNO", "(", "def", ")", ")", ";", "}", "}'" ]

[ "Free", "all", "storage", "associated", "with", "the", "problem" ]

[ "'static", "void", "df_chain_free", "(", "void", ")", "{", "free_alloc_pool", "(", "df_chain", "->", "block_pool", ")", ";", "BITMAP_FREE", "(", "df_chain", "->", "out_of_date_transfer_functions", ")", ";", "free", "(", "df_chain", ")", ";", "}'" ]

[ "Create", "defuse", "or", "usedef", "chains" ]

[ "'static", "void", "df_chain_alloc", "(", "bitmap", "all_blocks", "ATTRIBUTE_UNUSED", ")", "{", "df_chain_remove_problem", "()", ";", "df_chain", "->", "block_pool", "=", "create_alloc_pool", "(", "\"df_chain_block", "pool\"", ",", "sizeof", "(", "struct", "df_link", ")", ",", "50", ")", ";", "df_chain", "->", "optional_p", "=", "true", ";", "}'" ]

[ "In", "of", "target", "gets", "or", "of", "out", "of", "source" ]

[ "'static", "bool", "df_rd_confluence_n", "(", "edge", "e", ")", "{", "bitmap", "op1", "=", "&", "df_rd_get_bb_info", "(", "e", "->", "dest", "->", "index", ")", "->", "in", ";", "bitmap", "op2", "=", "&", "df_rd_get_bb_info", "(", "e", "->", "src", "->", "index", ")", "->", "out", ";", "bool", "changed", "=", "false", ";", "if", "(", "e", "->", "flags", "&", "EDGE_FAKE", ")", "return", "false", ";", "if", "(", "e", "->", "flags", "&", "EDGE_EH", ")", "{", "struct", "df_rd_problem_data", "*", "problem_data", "=", "(", "struct", "df_rd_problem_data", "*", ")", "df_rd", "->", "problem_data", ";", "bitmap", "sparse_invalidated", "=", "&", "problem_data", "->", "sparse_invalidated_by_call", ";", "bitmap", "dense_invalidated", "=", "&", "problem_data", "->", "dense_invalidated_by_call", ";", "bitmap_iterator", "bi", ";", "unsigned", "int", "regno", ";", "bitmap_head", "tmp", ";", "bitmap_initialize", "(", "&", "tmp", ",", "&", "df_bitmap_obstack", ")", ";", "bitmap_copy", "(", "&", "tmp", ",", "op2", ")", ";", "bitmap_and_compl_into", "(", "&", "tmp", ",", "dense_invalidated", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "sparse_invalidated", ",", "0", ",", "regno", ",", "bi", ")", "{", "bitmap_clear_range", "(", "&", "tmp", ",", "DF_DEFS_BEGIN", "(", "regno", ")", ",", "DF_DEFS_COUNT", "(", "regno", ")", ")", ";", "}", "changed", "|=", "bitmap_ior_into", "(", "op1", ",", "&", "tmp", ")", ";", "bitmap_clear", "(", "&", "tmp", ")", ";", "return", "changed", ";", "}", "else", "return", "bitmap_ior_into", "(", "op1", ",", "op2", ")", ";", "}'" ]

[ "Compute", "local", "live", "register", "info", "for", "each", "basic", "block", "within", "BLOCKS" ]

[ "'static", "void", "df_lr_local_compute", "(", "bitmap", "all_blocks", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "bb_index", ",", "<type", "ref=\"prev\"/>", "i", ";", "bitmap_iterator", "bi", ";", "bitmap_clear", "(", "&", "df", "->", "hardware_regs_used", ")", ";", "/*", "The", "all-important", "stack", "pointer", "must", "always", "be", "live.", "*/", "bitmap_set_bit", "(", "&", "df", "->", "hardware_regs_used", ",", "STACK_POINTER_REGNUM", ")", ";", "/*", "Global", "regs", "are", "always", "live,", "too.", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "global_regs", "[", "i", "]", ")", "bitmap_set_bit", "(", "&", "df", "->", "hardware_regs_used", ",", "i", ")", ";", "/*", "Before", "reload,", "there", "are", "a", "few", "registers", "that", "must", "be", "forced", "live", "everywhere", "--", "which", "might", "not", "already", "be", "the", "case", "for", "blocks", "within", "infinite", "loops.", "*/", "if", "(", "!", "reload_completed", ")", "{", "unsigned", "int", "pic_offset_table_regnum", "=", "PIC_OFFSET_TABLE_REGNUM", ";", "/*", "Any", "reference", "to", "any", "pseudo", "before", "reload", "is", "a", "potential", "reference", "of", "the", "frame", "pointer.", "*/", "bitmap_set_bit", "(", "&", "df", "->", "hardware_regs_used", ",", "FRAME_POINTER_REGNUM", ")", ";", "#", "if", "FRAME_POINTER_REGNUM", "!=", "ARG_POINTER_REGNUM", "/*", "Pseudos", "with", "argument", "area", "equivalences", "may", "require", "reloading", "via", "the", "argument", "pointer.", "*/", "if", "(", "fixed_regs", "[", "ARG_POINTER_REGNUM", "]", ")", "bitmap_set_bit", "(", "&", "df", "->", "hardware_regs_used", ",", "ARG_POINTER_REGNUM", ")", ";", "#", "endif", "/*", "Any", "constant,", "or", "pseudo", "with", "constant", "equivalences,", "may", "require", "reloading", "from", "memory", "using", "the", "pic", "register.", "*/", "if", "(", "pic_offset_table_regnum", "!=", "INVALID_REGNUM", "&&", "fixed_regs", "[", "pic_offset_table_regnum", "]", ")", "bitmap_set_bit", "(", "&", "df", "->", "hardware_regs_used", ",", "pic_offset_table_regnum", ")", ";", "}", "EXECUTE_IF_SET_IN_BITMAP", "(", "df_lr->out_of_date_transfer_functions", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "if", "(", "bb_index", "==", "EXIT_BLOCK", ")", "{", "/*", "The", "exit", "block", "is", "special", "for", "this", "problem", "and", "its", "bits", "are", "computed", "from", "thin", "air.", "*/", "struct", "df_lr_bb_info", "*", "bb_info", "=", "df_lr_get_bb_info", "(", "EXIT_BLOCK", ")", ";", "bitmap_copy", "(", "&", "bb_info", "->", "use", ",", "df", "->", "exit_block_uses", ")", ";", "}", "else", "df_lr_bb_local_compute", "(", "bb_index", ")", ";", "}", "bitmap_clear", "(", "df_lr", "->", "out_of_date_transfer_functions", ")", ";", "}'" ]

[ "Print", "some", "basic", "block", "info", "as", "part", "of", "df_dump" ]

[ "'void", "df_print_bb_index", "(", "basic_block", "bb", ",", "FILE", "*", "file", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "fprintf", "(", "file", ",", "\"\\(", "\"", ")", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb->preds", ")", "{", "basic_block", "pred", "=", "e", "->", "src", ";", "fprintf", "(", "file", ",", "\"%d%s", "\"", ",", "pred", "->", "index", ",", "e", "->", "flags", "&", "EDGE_EH", "?", "\"(EH)\"", ":", "\"\"", ")", ";", "}", "fprintf", "(", "file", ",", "\")->[%d]->(", "\"", ",", "bb", "->", "index", ")", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb->succs", ")", "{", "basic_block", "succ", "=", "e", "->", "dest", ";", "fprintf", "(", "file", ",", "\"%d%s", "\"", ",", "succ", "->", "index", ",", "e", "->", "flags", "&", "EDGE_EH", "?", "\"(EH)\"", ":", "\"\"", ")", ";", "}", "fprintf", "(", "file", ",", "\")\\\"", ")", ";", "}'" ]

[ "Reset", "the", "global", "solution", "for", "recalculation" ]

[ "'static", "void", "df_word_lr_reset", "(", "bitmap", "all_blocks", ")", "{", "unsigned", "int", "bb_index", ";", "bitmap_iterator", "bi", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "struct", "df_word_lr_bb_info", "*", "bb_info", "=", "df_word_lr_get_bb_info", "(", "bb_index", ")", ";", "gcc_assert", "(", "bb_info", ")", ";", "bitmap_clear", "(", "&", "bb_info", "->", "in", ")", ";", "bitmap_clear", "(", "&", "bb_info", "->", "out", ")", ";", "}", "}'" ]

[ "Confluence", "function", "that", "ignores", "fake", "edges" ]

[ "'static", "bool", "df_lr_confluence_n", "(", "edge", "e", ")", "{", "bitmap", "op1", "=", "&", "df_lr_get_bb_info", "(", "e", "->", "src", "->", "index", ")", "->", "out", ";", "bitmap", "op2", "=", "&", "df_lr_get_bb_info", "(", "e", "->", "dest", "->", "index", ")", "->", "in", ";", "bool", "changed", "=", "false", ";", "/*", "Call-clobbered", "registers", "die", "across", "exception", "and", "call", "edges.", "*/", "/*", "???", "Abnormal", "call", "edges", "ignored", "for", "the", "moment,", "as", "this", "gets", "confused", "by", "sibling", "call", "edges,", "which", "crashes", "reg-stack.", "*/", "if", "(", "e", "->", "flags", "&", "EDGE_EH", ")", "changed", "=", "bitmap_ior_and_compl_into", "(", "op1", ",", "op2", ",", "regs_invalidated_by_call_regset", ")", ";", "else", "changed", "=", "bitmap_ior_into", "(", "op1", ",", "op2", ")", ";", "changed", "|=", "bitmap_ior_into", "(", "op1", ",", "&", "df", "->", "hardware_regs_used", ")", ";", "return", "changed", ";", "}'" ]

[ "And", "the", "LR", "info", "with", "the", "mustinitialized", "registers,", "to", "produce", "the", "LIVE", "info" ]

[ "'static", "void", "df_live_finalize", "(", "bitmap", "all_blocks", ")", "{", "if", "(", "df_live", "->", "solutions_dirty", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "int", "bb_index", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "struct", "df_lr_bb_info", "*", "bb_lr_info", "=", "df_lr_get_bb_info", "(", "bb_index", ")", ";", "struct", "df_live_bb_info", "*", "bb_live_info", "=", "df_live_get_bb_info", "(", "bb_index", ")", ";", "/*", "No", "register", "may", "reach", "a", "location", "where", "it", "is", "not", "used.", "Thus", "we", "trim", "the", "rr", "result", "to", "the", "places", "where", "it", "is", "used.", "*/", "bitmap_and_into", "(", "&", "bb_live_info", "->", "in", ",", "&", "bb_lr_info", "->", "in", ")", ";", "bitmap_and_into", "(", "&", "bb_live_info", "->", "out", ",", "&", "bb_lr_info", "->", "out", ")", ";", "}", "df_live", "->", "solutions_dirty", "=", "false", ";", "}", "}'" ]

[ "Simulate", "the", "effects", "of", "the", "uses", "of", "INSN", "on", "LIVE" ]

[ "'void", "df_simulate_uses", "(", "rtx", "insn", ",", "bitmap", "live", ")", "{", "df_ref", "*", "use_rec", ";", "unsigned", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "DEBUG_INSN_P", "(", "insn", ")", ")", "return", ";", "for", "(", "use_rec", "=", "DF_INSN_UID_USES", "(", "uid", ")", ";", "*", "use_rec", ";", "use_rec", "++", ")", "{", "df_ref", "use", "=", "*", "use_rec", ";", "/*", "Add", "use", "to", "set", "of", "uses", "in", "this", "BB.", "*/", "bitmap_set_bit", "(", "live", ",", "DF_REF_REGNO", "(", "use", ")", ")", ";", "}", "}'" ]

[ "Initialize", "the", "solution", "vectors" ]

[ "'static", "void", "df_live_init", "(", "bitmap", "all_blocks", ")", "{", "unsigned", "int", "bb_index", ";", "bitmap_iterator", "bi", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "struct", "df_live_bb_info", "*", "bb_info", "=", "df_live_get_bb_info", "(", "bb_index", ")", ";", "struct", "df_lr_bb_info", "*", "bb_lr_info", "=", "df_lr_get_bb_info", "(", "bb_index", ")", ";", "/*", "No", "register", "may", "reach", "a", "location", "where", "it", "is", "not", "used.", "Thus", "we", "trim", "the", "rr", "result", "to", "the", "places", "where", "it", "is", "used.", "*/", "bitmap_and", "(", "&", "bb_info", "->", "out", ",", "&", "bb_info", "->", "gen", ",", "&", "bb_lr_info", "->", "out", ")", ";", "bitmap_clear", "(", "&", "bb_info", "->", "in", ")", ";", "}", "}'" ]

[ "Simulate", "the", "backwards", "effects", "of", "INSN", "on", "the", "bitmap", "LIVE" ]

[ "'void", "df_simulate_one_insn_backwards", "(", "basic_block", "bb", ",", "rtx", "insn", ",", "bitmap", "live", ")", "{", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "return", ";", "df_simulate_defs", "(", "insn", ",", "live", ")", ";", "df_simulate_uses", "(", "insn", ",", "live", ")", ";", "df_simulate_fixup_sets", "(", "bb", ",", "live", ")", ";", "}'" ]

[ "Compute", "local", "reaching", "def", "info", "for", "each", "basic", "block", "within", "BLOCKS" ]

[ "'static", "void", "df_md_local_compute", "(", "bitmap", "all_blocks", ")", "{", "unsigned", "int", "bb_index", ",", "<type", "ref=\"prev\"/>", "df_bb_index", ";", "bitmap_iterator", "bi1", ",", "<type", "ref=\"prev\"/>", "bi2", ";", "basic_block", "bb", ";", "bitmap_head", "*", "frontiers", ";", "bitmap_initialize", "(", "&", "seen_in_insn", ",", "&", "bitmap_default_obstack", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi1", ")", "{", "df_md_bb_local_compute", "(", "bb_index", ")", ";", "}", "bitmap_clear", "(", "&", "seen_in_insn", ")", ";", "frontiers", "=", "XNEWVEC", "(", "bitmap_head", ",", "last_basic_block", ")", ";", "FOR_ALL_BB", "(", "bb", ")", "bitmap_initialize", "(", "&", "frontiers", "[", "bb", "->", "index", "]", ",", "&", "bitmap_default_obstack", ")", ";", "compute_dominance_frontiers", "(", "frontiers", ")", ";", "/*", "Add", "each", "basic", "block\\'s", "kills", "to", "the", "nodes", "in", "the", "frontier", "of", "the", "BB.", "*/", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi1", ")", "{", "bitmap", "kill", "=", "&", "df_md_get_bb_info", "(", "bb_index", ")", "->", "kill", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "&frontiers[bb_index]", ",", "0", ",", "df_bb_index", ",", "bi2", ")", "{", "basic_block", "bb", "=", "BASIC_BLOCK", "(", "df_bb_index", ")", ";", "if", "(", "bitmap_bit_p", "(", "all_blocks", ",", "df_bb_index", ")", ")", "bitmap_ior_and_into", "(", "&", "df_md_get_bb_info", "(", "df_bb_index", ")", "->", "init", ",", "kill", ",", "df_get_live_in", "(", "bb", ")", ")", ";", "}", "}", "FOR_ALL_BB", "(", "bb", ")", "bitmap_clear", "(", "&", "frontiers", "[", "bb", "->", "index", "]", ")", ";", "free", "(", "frontiers", ")", ";", "}'" ]

[ "Initialize", "the", "solution", "bit", "vectors", "for", "problem" ]

[ "'static", "void", "df_md_init", "(", "bitmap", "all_blocks", ")", "{", "unsigned", "int", "bb_index", ";", "bitmap_iterator", "bi", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "struct", "df_md_bb_info", "*", "bb_info", "=", "df_md_get_bb_info", "(", "bb_index", ")", ";", "bitmap_copy", "(", "&", "bb_info", "->", "in", ",", "&", "bb_info", "->", "init", ")", ";", "df_md_transfer_function", "(", "bb_index", ")", ";", "}", "}'" ]

[ "Create", "the", "chains", "for", "a", "list", "of", "USEs" ]

[ "'static", "void", "df_chain_create_bb_process_use", "(", "bitmap", "local_rd", ",", "df_ref", "*", "use_rec", ",", "int", "top_flag", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "int", "def_index", ";", "while", "(", "*", "use_rec", ")", "{", "df_ref", "use", "=", "*", "use_rec", ";", "unsigned", "int", "uregno", "=", "DF_REF_REGNO", "(", "use", ")", ";", "if", "(", "(", "!", "(", "df", "->", "changeable_flags", "&", "DF_NO_HARD_REGS", ")", ")", "||", "(", "uregno", ">=", "FIRST_PSEUDO_REGISTER", ")", ")", "{", "/*", "Do", "not", "want", "to", "go", "through", "this", "for", "an", "uninitialized", "var.", "*/", "int", "count", "=", "DF_DEFS_COUNT", "(", "uregno", ")", ";", "if", "(", "count", ")", "{", "if", "(", "top_flag", "==", "(", "DF_REF_FLAGS", "(", "use", ")", "&", "DF_REF_AT_TOP", ")", ")", "{", "unsigned", "int", "first_index", "=", "DF_DEFS_BEGIN", "(", "uregno", ")", ";", "unsigned", "int", "last_index", "=", "first_index", "+", "count", "-", "1", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "local_rd", ",", "first_index", ",", "def_index", ",", "bi", ")", "{", "df_ref", "def", ";", "if", "(", "def_index", ">", "last_index", ")", "break;", "def", "=", "DF_DEFS_GET", "(", "def_index", ")", ";", "if", "(", "df_chain_problem_p", "(", "DF_DU_CHAIN", ")", ")", "df_chain_create", "(", "def", ",", "use", ")", ";", "if", "(", "df_chain_problem_p", "(", "DF_UD_CHAIN", ")", ")", "df_chain_create", "(", "use", ",", "def", ")", ";", "}", "}", "}", "}", "use_rec", "++", ";", "}", "}'" ]

[ "Compute", "local", "live", "register", "info", "for", "each", "basic", "block", "within", "BLOCKS" ]

[ "'static", "void", "df_word_lr_local_compute", "(", "bitmap", "all_blocks", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "bb_index", ";", "bitmap_iterator", "bi", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "df_word_lr->out_of_date_transfer_functions", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "if", "(", "bb_index", "==", "EXIT_BLOCK", ")", "{", "unsigned", "regno", ";", "bitmap_iterator", "bi", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "df->exit_block_uses", ",", "FIRST_PSEUDO_REGISTER", ",", "regno", ",", "bi", ")", "gcc_unreachable", "()", ";", "}", "else", "df_word_lr_bb_local_compute", "(", "bb_index", ")", ";", "}", "bitmap_clear", "(", "df_word_lr", "->", "out_of_date_transfer_functions", ")", ";", "}'" ]

[ "Debugging", "info", "at", "bottom", "of", "bb" ]

[ "'static", "void", "df_md_bottom_dump", "(", "basic_block", "bb", ",", "FILE", "*", "file", ")", "{", "struct", "df_md_bb_info", "*", "bb_info", "=", "df_md_get_bb_info", "(", "bb", "->", "index", ")", ";", "if", "(", "!", "bb_info", ")", "return", ";", "fprintf", "(", "file", ",", "\";;", "md", "out", "\\\\t\"", ")", ";", "df_print_regset", "(", "file", ",", "&", "bb_info", "->", "out", ")", ";", "}'" ]

[ "Find", "the", "set", "of", "real", "DEFs,", "which", "are", "not", "clobbers,", "for", "INSN" ]

[ "'void", "df_simulate_find_noclobber_defs", "(", "rtx", "insn", ",", "bitmap", "defs", ")", "{", "df_ref", "*", "def_rec", ";", "unsigned", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "for", "(", "def_rec", "=", "DF_INSN_UID_DEFS", "(", "uid", ")", ";", "*", "def_rec", ";", "def_rec", "++", ")", "{", "df_ref", "def", "=", "*", "def_rec", ";", "if", "(", "!", "(", "DF_REF_FLAGS", "(", "def", ")", "&", "(", "DF_REF_MUST_CLOBBER", "|", "DF_REF_MAY_CLOBBER", ")", ")", ")", "bitmap_set_bit", "(", "defs", ",", "DF_REF_REGNO", "(", "def", ")", ")", ";", "}", "}'" ]

[ "Debugging", "info", "at", "top", "of", "bb" ]

[ "'static", "void", "df_md_top_dump", "(", "basic_block", "bb", ",", "FILE", "*", "file", ")", "{", "struct", "df_md_bb_info", "*", "bb_info", "=", "df_md_get_bb_info", "(", "bb", "->", "index", ")", ";", "if", "(", "!", "bb_info", ")", "return", ";", "fprintf", "(", "file", ",", "\";;", "md", "in", "\\\\t\"", ")", ";", "df_print_regset", "(", "file", ",", "&", "bb_info", "->", "in", ")", ";", "fprintf", "(", "file", ",", "\";;", "md", "init", "\\\\t\"", ")", ";", "df_print_regset", "(", "file", ",", "&", "bb_info", "->", "init", ")", ";", "fprintf", "(", "file", ",", "\";;", "md", "gen", "\\\\t\"", ")", ";", "df_print_regset", "(", "file", ",", "&", "bb_info", "->", "gen", ")", ";", "fprintf", "(", "file", ",", "\";;", "md", "kill", "\\\\t\"", ")", ";", "df_print_regset", "(", "file", ",", "&", "bb_info", "->", "kill", ")", ";", "}'" ]

[ "Compute", "register", "info:", "lifetime,", "bb,", "and", "number", "of", "defs", "and", "uses" ]

[ "'static", "void", "df_note_compute", "(", "bitmap", "all_blocks", ")", "{", "unsigned", "int", "bb_index", ";", "bitmap_iterator", "bi", ";", "bitmap_head", "live", ",", "<type", "ref=\"prev\"/>", "do_not_gen", ",", "<type", "ref=\"prev\"/>", "artificial_uses", ";", "bitmap_initialize", "(", "&", "live", ",", "&", "df_bitmap_obstack", ")", ";", "bitmap_initialize", "(", "&", "do_not_gen", ",", "&", "df_bitmap_obstack", ")", ";", "bitmap_initialize", "(", "&", "artificial_uses", ",", "&", "df_bitmap_obstack", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "all_blocks", ",", "0", ",", "bb_index", ",", "bi", ")", "{", "/*", "???", "Unlike", "fast", "DCE,", "we", "don\\'t", "use", "global_debug", "for", "uses", "of", "dead", "pseudos", "in", "debug", "insns", "because", "we", "don\\'t", "always", "(re)visit", "blocks", "with", "death", "points", "after", "visiting", "dead", "uses.", "Even", "changing", "this", "loop", "to", "postorder", "would", "still", "leave", "room", "for", "visiting", "a", "death", "point", "before", "visiting", "a", "subsequent", "debug", "use.", "*/", "df_note_bb_compute", "(", "bb_index", ",", "&", "live", ",", "&", "do_not_gen", ",", "&", "artificial_uses", ")", ";", "}", "bitmap_clear", "(", "&", "live", ")", ";", "bitmap_clear", "(", "&", "do_not_gen", ")", ";", "bitmap_clear", "(", "&", "artificial_uses", ")", ";", "}'" ]

[ "Free", "basic", "block", "info" ]

[ "'static", "void", "df_rd_free_bb_info", "(", "basic_block", "bb", "ATTRIBUTE_UNUSED", ",", "void", "*", "vbb_info", ")", "{", "struct", "df_rd_bb_info", "*", "bb_info", "=", "(", "struct", "df_rd_bb_info", "*", ")", "vbb_info", ";", "if", "(", "bb_info", ")", "{", "bitmap_clear", "(", "&", "bb_info", "->", "kill", ")", ";", "bitmap_clear", "(", "&", "bb_info", "->", "sparse_kill", ")", ";", "bitmap_clear", "(", "&", "bb_info", "->", "gen", ")", ";", "bitmap_clear", "(", "&", "bb_info", "->", "in", ")", ";", "bitmap_clear", "(", "&", "bb_info", "->", "out", ")", ";", "}", "}'" ]

[ "Debugging", "info", "at", "bottom", "of", "bb" ]

[ "'static", "void", "df_lr_bottom_dump", "(", "basic_block", "bb", ",", "FILE", "*", "file", ")", "{", "struct", "df_lr_bb_info", "*", "bb_info", "=", "df_lr_get_bb_info", "(", "bb", "->", "index", ")", ";", "struct", "df_lr_problem_data", "*", "problem_data", ";", "if", "(", "!", "bb_info", ")", "return", ";", "fprintf", "(", "file", ",", "\";;", "lr", "out", "\\\\t\"", ")", ";", "df_print_regset", "(", "file", ",", "&", "bb_info", "->", "out", ")", ";", "if", "(", "df_lr", "->", "problem_data", ")", "{", "problem_data", "=", "(", "struct", "df_lr_problem_data", "*", ")", "df_lr", "->", "problem_data", ";", "if", "(", "problem_data", "->", "out", ")", "{", "fprintf", "(", "file", ",", "\";;", "old", "out", "\\\\t\"", ")", ";", "df_print_regset", "(", "file", ",", "&", "problem_data", "->", "out", "[", "bb", "->", "index", "]", ")", ";", "}", "}", "}'" ]

[ "Create", "a", "du", "or", "ud", "chain", "from", "SRC", "to", "DST", "and", "link", "it", "into", "SRC" ]

[ "'struct", "df_link", "*", "df_chain_create", "(", "df_ref", "src", ",", "df_ref", "dst", ")", "{", "struct", "df_link", "*", "head", "=", "DF_REF_CHAIN", "(", "src", ")", ";", "struct", "df_link", "*", "link", "=", "(", "struct", "df_link", "*", ")", "pool_alloc", "(", "df_chain", "->", "block_pool", ")", ";", "DF_REF_CHAIN", "(", "src", ")", "=", "link", ";", "link", "->", "next", "=", "head", ";", "link", "->", "ref", "=", "dst", ";", "return", "link", ";", "}'" ]

[ "Remove", "the", "chain", "problem", "completely" ]

[ "'static", "void", "df_chain_fully_remove_problem", "(", "void", ")", "{", "df_chain_remove_problem", "()", ";", "BITMAP_FREE", "(", "df_chain", "->", "out_of_date_transfer_functions", ")", ";", "free", "(", "df_chain", ")", ";", "}'" ]

[ "Convert", "lla", "to", "utm", "(float)" ]

[ "'void", "utm_of_lla_f", "(", "struct", "UtmCoor_f", "*", "utm", ",", "struct", "LlaCoor_f", "*", "lla", ")", "{", "//", "compute", "zone", "if", "not", "initialised", "if", "(", "utm", "->", "zone", "==", "0", ")", "{", "utm", "->", "zone", "=", "UtmZoneOfLlaLonRad", "(", "lla", "->", "lon", ")", ";", "}", "float", "lambda_c", "=", "LambdaOfUtmZone", "(", "utm", "->", "zone", ")", ";", "float", "ll", "=", "isometric_latitude_f", "(", "lla", "->", "lat", ",", "E", ")", ";", "float", "dl", "=", "lla", "->", "lon", "-", "lambda_c", ";", "float", "phi_", "=", "asinf", "(", "sinf", "(", "dl", ")", "/", "coshf", "(", "ll", ")", ")", ";", "float", "ll_", "=", "isometric_latitude_fast_f", "(", "phi_", ")", ";", "float", "lambda_", "=", "atanf", "(", "sinhf", "(", "ll", ")", "/", "cosf", "(", "dl", ")", ")", ";", "struct", "complex", "z_", "=", "{", "lambda_", ",", "ll_", "}", ";", "CScal", "(", "serie_coeff_proj_mercator", "[", "0", "]", ",", "z_", ")", ";", "int8_t", "k", ";", "for", "(", "k", "=", "1", ";", "k", "<", "3", ";", "k", "++", ")", "{", "struct", "complex", "z", "=", "{", "lambda_", ",", "ll_", "}", ";", "CScal", "(", "2.", "*", "k", ",", "z", ")", ";", "CSin", "(", "z", ")", ";", "CScal", "(", "serie_coeff_proj_mercator", "[", "k", "]", ",", "z", ")", ";", "CAdd", "(", "z", ",", "z_", ")", ";", "}", "CScal", "(", "N", ",", "z_", ")", ";", "utm", "->", "east", "=", "DELTA_EAST", "+", "z_", ".", "im", ";", "utm", "->", "north", "=", "DELTA_NORTH", "+", "z_", ".", "re", ";", "//", "copy", "alt", "above", "reference", "ellipsoid", "utm", "->", "alt", "=", "lla", "->", "alt", ";", "}'" ]

[ "Convert", "utm", "to", "lla", "(float)" ]

[ "'void", "lla_of_utm_f", "(", "struct", "LlaCoor_f", "*", "lla", ",", "struct", "UtmCoor_f", "*", "utm", ")", "{", "float", "scale", "=", "1", "/", "N", "/", "serie_coeff_proj_mercator", "[", "0", "]", ";", "float", "real", "=", "(", "utm", "->", "north", "-", "DELTA_NORTH", ")", "*", "scale", ";", "float", "img", "=", "(", "utm", "->", "east", "-", "DELTA_EAST", ")", "*", "scale", ";", "struct", "complex", "z", "=", "{", "real", ",", "img", "}", ";", "int8_t", "k", ";", "for", "(", "k", "=", "1", ";", "k", "<", "2", ";", "k", "++", ")", "{", "struct", "complex", "z_", "=", "{", "real", ",", "img", "}", ";", "CScal", "(", "2.", "*", "k", ",", "z_", ")", ";", "CSin", "(", "z_", ")", ";", "CScal", "(", "serie_coeff_proj_mercator_inverse", "[", "k", "]", ",", "z_", ")", ";", "CSub", "(", "z_", ",", "z", ")", ";", "}", "float", "lambda_c", "=", "LambdaOfUtmZone", "(", "utm", "->", "zone", ")", ";", "lla", "->", "lon", "=", "lambda_c", "+", "atanf", "(", "sinhf", "(", "z", ".", "im", ")", "/", "cosf", "(", "z", ".", "re", ")", ")", ";", "float", "phi_", "=", "asinf", "(", "sinf", "(", "z", ".", "re", ")", "/", "coshf", "(", "z", ".", "im", ")", ")", ";", "float", "il", "=", "isometric_latitude_fast_f", "(", "phi_", ")", ";", "lla", "->", "lat", "=", "inverse_isometric_latitude_f", "(", "il", ",", "E", ",", "1e-8", ")", ";", "//", "copy", "alt", "above", "reference", "ellipsoid", "lla", "->", "alt", "=", "utm", "->", "alt", ";", "}'" ]

[ "Same", "as", "UI_add_input_string(),", "excepts", "it", "takes", "a", "copy", "of", "the", "prompt" ]

[ "'int", "UI_dup_input_string", "(", "UI", "*", "ui", ",", "const", "char", "*", "prompt", ",", "int", "flags", ",", "char", "*", "result_buf", ",", "int", "minsize", ",", "int", "maxsize", ")", "{", "char", "*", "prompt_copy", "=", "NULL", ";", "if", "(", "prompt", ")", "{", "prompt_copy", "=", "BUF_strdup", "(", "prompt", ")", ";", "if", "(", "prompt_copy", "==", "NULL", ")", "{", "UIerr", "(", "UI_F_UI_DUP_INPUT_STRING", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "return", "0", ";", "}", "}", "return", "general_allocate_string", "(", "ui", ",", "prompt_copy", ",", "1", ",", "UIT_PROMPT", ",", "flags", ",", "result_buf", ",", "minsize", ",", "maxsize", ",", "NULL", ")", ";", "}'" ]

[ "cleanup:", "only", "called", "for", "threadshared", "itimer", "for", "last", "thread", "in", "group" ]

[ "\"void", "pcprofile_thread_exit", "(", "dcontext_t", "*", "dcontext", ")", "{", "int", "size", ";", "thread_pc_info_t", "*", "info", "=", "(", "thread_pc_info_t", "*", ")", "dcontext", "->", "pcprofile_field", ";", "/*", "don't", "want", "any", "alarms", "while", "holding", "lock", "for", "printing", "results", "*", "(see", "notes", "under", "pcprofile_cache_flush", "below)", "*/", "set_itimer_callback", "(", "dcontext", ",", "ITIMER_VIRTUAL", ",", "0", ",", "NULL", ",", "NULL", ")", ";", "pcprofile_results", "(", "info", ")", ";", "size", "=", "HASHTABLE_SIZE", "(", "HASH_BITS", ")", "*", "sizeof", "(", "pc_profile_entry_t", "*", ")", ";", "pcprofile_reset", "(", "info", ")", ";", "/*", "special", "heap", "so", "no", "fast", "path", "*/", "#", "ifdef", "DEBUG", "/*", "for", "non-debug", "we", "do", "fast", "exit", "path", "and", "don't", "free", "local", "heap", "*/", "global_heap_free", "(", "info->htable", ",", "size", "HEAPACCT(ACCT_OTHER)", ")", ";", "#", "endif", "#", "if", "USE_SYMTAB", "if", "(", "valid_symtab", ")", "symtab_exit", "()", ";", "#", "endif", "close_log_file", "(", "info", "->", "file", ")", ";", "special_heap_exit", "(", "info", "->", "special_heap", ")", ";", "#", "ifdef", "DEBUG", "/*", "for", "non-debug", "we", "do", "fast", "exit", "path", "and", "don't", "free", "local", "heap", "*/", "global_heap_free", "(", "info", ",", "sizeof", "(", "thread_pc_info_t", ")", "HEAPACCT", "(", "ACCT_OTHER", ")", ")", ";", "#", "endif", "}\"" ]

[ "CAN", "Initialize", "a", "16bit", "Message", "ID", "List", "Filter" ]

[ "'void", "can_filter_id_list_16bit_init", "(", "uint32_t", "nr", ",", "uint16_t", "id1", ",", "uint16_t", "id2", ",", "uint16_t", "id3", ",", "uint16_t", "id4", ",", "uint32_t", "fifo", ",", "bool", "enable", ")", "{", "can_filter_init", "(", "nr", ",", "false", ",", "true", ",", "(", "(", "uint32_t", ")", "id1", "<<", "16", ")", "|", "(", "uint32_t", ")", "id2", ",", "(", "(", "uint32_t", ")", "id3", "<<", "16", ")", "|", "(", "uint32_t", ")", "id4", ",", "fifo", ",", "enable", ")", ";", "}'" ]

[ "Returns:", "count", "of", "1", "bits" ]

[ "'COMPILER_RT_ABI", "si_int", "__popcountdi2", "(", "di_int", "a", ")", "{", "du_int", "x2", "=", "(", "du_int", ")", "a", ";", "x2", "=", "x2", "-", "(", "(", "x2", ">>", "1", ")", "&", "0x5555555555555555uLL", ")", ";", "/*", "Every", "2", "bits", "holds", "the", "sum", "of", "every", "pair", "of", "bits", "(32)", "*/", "x2", "=", "(", "(", "x2", ">>", "2", ")", "&", "0x3333333333333333uLL", ")", "+", "(", "x2", "&", "0x3333333333333333uLL", ")", ";", "/*", "Every", "4", "bits", "holds", "the", "sum", "of", "every", "4-set", "of", "bits", "(3", "significant", "bits)", "(16)", "*/", "x2", "=", "(", "x2", "+", "(", "x2", ">>", "4", ")", ")", "&", "0x0F0F0F0F0F0F0F0FuLL", ";", "/*", "Every", "8", "bits", "holds", "the", "sum", "of", "every", "8-set", "of", "bits", "(4", "significant", "bits)", "(8)", "*/", "su_int", "x", "=", "(", "su_int", ")", "(", "x2", "+", "(", "x2", ">>", "32", ")", ")", ";", "/*", "The", "lower", "32", "bits", "hold", "four", "16", "bit", "sums", "(5", "significant", "bits).", "*/", "/*", "Upper", "32", "bits", "are", "garbage", "*/", "x", "=", "x", "+", "(", "x", ">>", "16", ")", ";", "/*", "The", "lower", "16", "bits", "hold", "two", "32", "bit", "sums", "(6", "significant", "bits).", "*/", "/*", "Upper", "16", "bits", "are", "garbage", "*/", "return", "(", "x", "+", "(", "x", ">>", "8", ")", ")", "&", "0x0000007F", ";", "/*", "(7", "significant", "bits)", "*/", "}'" ]

[ "Executes", "periodic", "maintenance", "activities", "required", "by", "the", "process", "module" ]

[ "'void", "process_run", "(", "void", ")", "{", "#", "ifndef", "_WIN32", "char", "buf", "[", "_POSIX_PIPE_BUF", "]", ";", "if", "(", "!", "ovs_list_is_empty", "(", "&", "all_processes", ")", "&&", "read", "(", "fds", "[", "0", "]", ",", "buf", ",", "sizeof", "buf", ")", ">", "0", ")", "{", "struct", "process", "*", "p", ";", "LIST_FOR_EACH", "(", "p", ",", "node", ",", "&all_processes", ")", "{", "if", "(", "!", "p", "->", "exited", ")", "{", "int", "retval", ",", "<type", "ref=\"prev\"/>", "status", ";", "do", "{", "retval", "=", "waitpid", "(", "p", "->", "pid", ",", "&", "status", ",", "WNOHANG", ")", ";", "}", "while", "(", "retval", "==", "-", "1", "&&", "errno", "==", "EINTR", ")", ";", "if", "(", "retval", "==", "p", "->", "pid", ")", "{", "p", "->", "exited", "=", "true", ";", "p", "->", "status", "=", "status", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "retval", "<", "0", ")", "{", "VLOG_WARN", "(", "\"waitpid:", "%s\"", ",", "ovs_strerror", "(", "errno", ")", ")", ";", "p", "->", "exited", "=", "true", ";", "p", "->", "status", "=", "-", "1", ";", "}", "}", "}", "}", "#", "endif", "}'" ]

[ "Skip", "len", "uncompressed", "bytes", "of", "output" ]

[ "'local", "int", "gz_skip", "(", "state", ",", "len", ")", "gz_statep", "state", ";", "z_off64_t", "len", ";", "{", "unsigned", "n", ";", "/*", "skip", "over", "len", "bytes", "or", "reach", "end-of-file,", "whichever", "comes", "first", "*/", "while", "(", "len", ")", "/*", "skip", "over", "whatever", "is", "in", "output", "buffer", "*/", "if", "(", "state", "->", "x", ".", "have", ")", "{", "n", "=", "GT_OFF", "(", "state", "->", "x", ".", "have", ")", "||", "(", "z_off64_t", ")", "state", "->", "x", ".", "have", ">", "len", "?", "(", "unsigned", ")", "len", ":", "state", "->", "x", ".", "have", ";", "state", "->", "x", ".", "have", "-=", "n", ";", "state", "->", "x", ".", "next", "+=", "n", ";", "state", "->", "x", ".", "pos", "+=", "n", ";", "len", "-=", "n", ";", "}", "/*", "output", "buffer", "empty", "--", "return", "if", "we\\'re", "at", "the", "end", "of", "the", "input", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "state", "->", "eof", "&&", "state", "->", "strm", ".", "avail_in", "==", "0", ")", "break;", "/*", "need", "more", "data", "to", "skip", "--", "load", "up", "output", "buffer", "*/", "else", "{", "/*", "get", "more", "output,", "looking", "for", "header", "if", "required", "*/", "if", "(", "gz_fetch", "(", "state", ")", "==", "-", "1", ")", "return", "-", "1", ";", "}", "return", "0", ";", "}'" ]

[ "called", "via", "clean", "call", "at", "return", "address(es)", "of", "callee" ]

[ "'static", "void", "drwrap_after_callee", "(", "app_pc", "retaddr", ",", "reg_t", "xsp", ")", "{", "void", "*", "drcontext", "=", "dr_get_current_drcontext", "()", ";", "per_thread_t", "*", "pt", "=", "(", "per_thread_t", "*", ")", "drmgr_get_tls_field", "(", "drcontext", ",", "tls_idx", ")", ";", "dr_mcontext_t", "mc", ";", "mc", ".", "size", "=", "sizeof", "(", "mc", ")", ";", "/*", "we", "use", "a", "passed-in", "xsp", "to", "avoid", "dr_get_mcontext", "*/", "mc", ".", "xsp", "=", "xsp", ";", "mc", ".", "flags", "=", "0", ";", "/*", "if", "anything", "else", "is", "asked", "for,", "lazily", "initialize", "*/", "ASSERT", "(", "pt", "!=", "NULL", ",", "\"drwrap_after_callee:", "pt", "is", "NULL!\"", ")", ";", "if", "(", "pt", "->", "wrap_level", "<", "0", ")", "{", "/*", "jump", "or", "other", "method", "of", "targeting", "post-call", "site", "w/o", "executing", "*", "call;", "or,", "did", "an", "indirect", "call", "that", "no", "longer", "matches", "*/", "return", ";", "}", "/*", "process", "post", "for", "all", "funcs", "whose", "frames", "we", "bypassed.", "*", "we", "assume", "they", "were", "all", "bypassed", "b/c", "of", "tailcalls", "and", "that", "their", "*", "posts", "should", "be", "called", "(on", "an", "exception", "we", "clear", "out", "our", "data", "*", "and", "won\\'t", "come", "here;", "for", "longjmp", "we", "assume", "we", "want", "to", "call", "the", "post", "*", "although", "the", "retval", "won\\'t", "be", "there...XXX).", "*", "*", "we", "no", "longer", "store", "the", "callee", "for", "a", "post-call", "site", "b/c", "there", "*", "can", "be", "multiple", "and", "it\\'s", "complex", "to", "control", "which", "one", "is", "used", "*", "(outer", "or", "inner", "or", "middle)", "consistently.", "we", "don\\'t", "need", "the", "*", "callee", "to", "distinguish", "a", "jump", "or", "other", "transfer", "to", "a", "post-call", "*", "site", "where", "the", "transfer", "happens", "inside", "a", "wrapped", "routine", "(passing", "*", "the", "wrap_level==0", "check", "above)", "b/c", "our", "stack", "*", "check", "will", "identify", "whether", "we\\'ve", "left", "any", "wrapped", "routines", "we", "*", "entered.", "*/", "/*", "XXX:", "I\\'m", "worried", "about", "the", "<=", "here.", "We", "need", "it", "for", "ARM", "b/c", "w/", "no", "retaddr", "on", "*", "the", "stack", "it\\'s", "easy", "to", "have", "the", "same", "sp", "value,", "but", "I\\'m", "being", "conservative", "*", "and", "leaving", "the", "<", "for", "x86.", "*/", "while", "(", "pt", "->", "wrap_level", ">=", "0", "&&", "pt", "->", "app_esp", "[", "pt", "->", "wrap_level", "]", "IF_X86_ELSE", "(", "<", ",", "<=", ")", "mc", ".", "xsp", ")", "{", "drwrap_after_callee_func", "(", "drcontext", ",", "pt", ",", "&", "mc", ",", "pt", "->", "wrap_level", ",", "retaddr", ",", "false", ",", "false", ")", ";", "}", "}'" ]

[ "event", "for", "function", "replacing" ]

[ "'static", "dr_emit_flags_t", "drwrap_event_bb_app2app", "(", "void", "*", "drcontext", ",", "void", "*", "tag", ",", "instrlist_t", "*", "bb", ",", "bool", "for_trace", ",", "bool", "translating", ")", "{", "instr_t", "*", "inst", ";", "app_pc", "pc", ",", "<type", "ref=\"prev\"/>", "replace", ";", "if", "(", "replace_table", ".", "entries", "==", "0", "&&", "replace_native_table", ".", "entries", "==", "0", ")", "return", "DR_EMIT_DEFAULT", ";", "/*", "XXX:", "if", "we", "had", "dr_bbs_cross_ctis()", "query", "(i#427)", "we", "could", "just", "check", "1st", "instr", "*/", "for", "(", "inst", "=", "instrlist_first", "(", "bb", ")", ";", "inst", "!=", "NULL", ";", "inst", "=", "instr_get_next", "(", "inst", ")", ")", "{", "/*", "XXX", "i#1689:", "supporting", "LSB=1", "or", "LSB=0", "gets", "complex.", "For", "now", "we", "*", "assume", "calls", "from", "the", "client", "always", "pass", "LSB=1", "(b/c", "from", "*", "dr_get_proc_address()),", "which", "we", "store", "in", "the", "table.", "We", "assume", "that", "*", "DR", "always", "gives", "us", "LSB=0,", "so", "we", "add", "LSB=1", "before", "table", "lookups.", "This", "*", "breaks", "down", "if", "the", "client", "passes", "dr_fragment_app_pc()!", "*/", "pc", "=", "dr_app_pc_as_jump_target", "(", "instr_get_isa_mode", "(", "inst", ")", ",", "instr_get_app_pc", "(", "inst", ")", ")", ";", "/*", "non-native", "takes", "precedence", "*/", "if", "(", "replace_table", ".", "entries", ">", "0", ")", "{", "replace", "=", "hashtable_lookup", "(", "&", "replace_table", ",", "pc", ")", ";", "if", "(", "replace", "!=", "NULL", ")", "{", "drwrap_replace_bb", "(", "drcontext", ",", "bb", ",", "inst", ",", "pc", ",", "replace", ")", ";", "break;", "}", "}", "if", "(", "replace_native_table", ".", "entries", ">", "0", ")", "{", "replace_native_t", "*", "rn", ";", "hashtable_lock", "(", "&", "replace_native_table", ")", ";", "rn", "=", "hashtable_lookup", "(", "&", "replace_native_table", ",", "pc", ")", ";", "if", "(", "rn", "!=", "NULL", ")", "{", "app_pc", "topush", "=", "NULL", ";", "if", "(", "!", "rn", "->", "at_entry", ")", "{", "if", "(", "instr_is_call", "(", "inst", ")", ")", "{", "topush", "=", "pc", "+", "instr_length", "(", "drcontext", ",", "inst", ")", ";", "topush", "=", "dr_app_pc_as_jump_target", "(", "instr_get_isa_mode", "(", "inst", ")", ",", "topush", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "instr_is_ubr", "(", "inst", ")", ")", "{", "/*", "usage", "error?", "no,", "we\\'ll", "trust", "user", "knows", "what", "they\\'re", "doing", "*/", "}", "}", "drwrap_replace_native_bb", "(", "drcontext", ",", "bb", ",", "inst", ",", "pc", ",", "rn", ",", "topush", ")", ";", "hashtable_unlock", "(", "&", "replace_native_table", ")", ";", "break;", "}", "hashtable_unlock", "(", "&", "replace_native_table", ")", ";", "}", "}", "return", "DR_EMIT_DEFAULT", ";", "}'" ]

[ "i#1713:", "redirect", "execution", "from", "a", "postfunction", "callback" ]

[ "'drext_status_t", "drwrap_redirect_execution", "(", "void", "*", "wrapcxt_opaque", ")", "{", "drwrap_context_t", "*", "wrapcxt", "=", "(", "drwrap_context_t", "*", ")", "wrapcxt_opaque", ";", "if", "(", "wrapcxt_opaque", "==", "NULL", ")", "{", "NOTIFY", "(", "2", ",", "\"%s:", "rejected", "redirect:", "NULL", "wrapcxt\\\"", ",", "__FUNCTION__", ")", ";", "return", "DREXT_ERROR", ";", "}", "if", "(", "wrapcxt", "->", "where_am_i", "!=", "DRWRAP_WHERE_POST_FUNC", ")", "{", "NOTIFY", "(", "2", ",", "\"%s:", "rejected", "redirect", "in", "state", "%d\\\"", ",", "__FUNCTION__", ",", "wrapcxt", "->", "where_am_i", ")", ";", "return", "DREXT_ERROR_INCOMPATIBLE_STATE", ";", "}", "if", "(", "wrapcxt", "->", "is_redirect_requested", ")", "{", "NOTIFY", "(", "2", ",", "\"%s:", "rejected", "redirect:", "already", "redirected\\\"", ",", "__FUNCTION__", ")", ";", "return", "DREXT_ERROR_INCOMPATIBLE_STATE", ";", "}", "DODEBUG", "(", "{", "per_thread_t", "*pt", "=", "(per_thread_t", "*)drmgr_get_tls_field(wrapcxt->drcontext,", "tls_idx);", "ASSERT(pt->wrap_level", ">=", "0", ",", "\"must", "be", "in", "a", "post-wrap\"", ");", "NOTIFY(", "2", ",", "\"%s:", "accepted", "redirect", "request", "from", "the", "return", "of", "\"", "PFX", "\"", "to", "\"", "PFX", "\"\\\"", ",", "__FUNCTION__,", "pt->last_wrap_func[pt->wrap_level],", "wrapcxt->mc->pc);", "}", ")", ";", "drwrap_set_mcontext", "(", "wrapcxt_opaque", ")", ";", "wrapcxt", "->", "is_redirect_requested", "=", "true", ";", "return", "DREXT_SUCCESS", ";", "}'" ]

[ "Set", "the", "Program", "Parallelism", "Size" ]

[ "'static", "inline", "void", "flash_set_program_size", "(", "uint32_t", "psize", ")", "{", "FLASH_CR", "&=", "~", "(", "FLASH_CR_PROGRAM_MASK", "<<", "FLASH_CR_PROGRAM_SHIFT", ")", ";", "FLASH_CR", "|=", "psize", "<<", "FLASH_CR_PROGRAM_SHIFT", ";", "}'" ]

[ "Clear", "the", "Programming", "Alignment", "Error", "Flag" ]

[ "'void", "flash_clear_pgaerr_flag", "(", "void", ")", "{", "FLASH_SR", "|=", "FLASH_SR_PGAERR", ";", "}'" ]

[ "Lock", "the", "Option", "Byte", "Access" ]

[ "'void", "flash_lock_option_bytes", "(", "void", ")", "{", "FLASH_OPTCR", "|=", "FLASH_OPTCR_OPTLOCK", ";", "}'" ]

[ "Clear", "the", "Write", "Protect", "Error", "Flag" ]

[ "'void", "flash_clear_wrperr_flag", "(", "void", ")", "{", "FLASH_SR", "|=", "FLASH_SR_WRPERR", ";", "}'" ]

[ "Get", "cos(angle)", "using", "the", "sine", "lookup", "table" ]

[ "'float", "cos_lookup_deg", "(", "float", "angle", ")", "{", "return", "sin_lookup_deg", "(", "angle", "+", "90", ")", ";", "}'" ]

[ "Use", "the", "lookup", "table", "to", "return", "sine(angle)", "where", "angle", "is", "in", "radians" ]

[ "'float", "sin_lookup_rad", "(", "float", "angle", ")", "{", "int", "degrees", "=", "RAD2DEG", "(", "angle", ")", ";", "return", "sin_lookup_deg", "(", "degrees", ")", ";", "}'" ]

[ "ifdef", "FLASH_TABLE", "Use", "the", "lookup", "table", "to", "return", "sine(angle)", "where", "angle", "is", "in", "radians", "to", "save", "flash", "this", "cheats", "and", "uses", "trig", "functions", "to", "only", "save", "90", "values" ]

[ "'float", "sin_lookup_deg", "(", "float", "angle", ")", "{", "if", "(", "sin_table", "==", "NULL", ")", "{", "return", "0", ";", "}", "//", "<bug,", "was>", "int", "i_ang", "=", "((int32_t)angle)", "%", "360;", "//", "1073741760", "is", "a", "multiple", "of", "360", "that", "is", "close", "to", "0x3fffffff", "//", "so", "angle", "can", "be", "a", "very", "large", "number", "of", "positive", "or", "negative", "rotations", "//", "this", "is", "the", "fastest", "fix", "(no", "tests,", "one", "integer", "addition)", "//", "and", "has", "the", "largest", "range", "since", "float", "mantissas", "are", "23-4", "bit", "//", "we", "could", "halve", "the", "lookup", "table", "size", "//", "we", "could", "interpolate", "for", "greater", "accuracy", "int", "i_ang", "=", "(", "(", "int32_t", ")", "(", "angle", "+", "0.5f", ")", "+", "(", "int32_t", ")", "1073741760", ")", "%", "360", ";", "if", "(", "i_ang", ">=", "180", ")", "{", "//", "for", "180", "to", "360", "deg", "return", "-", "sin_table", "[", "i_ang", "-", "180", "]", ";", "}", "else", "{", "//", "for", "0", "to", "179", "deg", "return", "sin_table", "[", "i_ang", "]", ";", "}", "return", "0", ";", "}'" ]

[ "Get", "exit", "status", "of", "executed", "programs" ]

[ "'int", "pex_get_status", "(", "struct", "pex_obj", "*", "obj", ",", "int", "count", ",", "int", "*", "vector", ")", "{", "if", "(", "obj", "->", "status", "==", "NULL", ")", "{", "const", "char", "*", "errmsg", ";", "int", "err", ";", "if", "(", "!", "pex_get_status_and_time", "(", "obj", ",", "0", ",", "&", "errmsg", ",", "&", "err", ")", ")", "return", "0", ";", "}", "if", "(", "count", ">", "obj", "->", "count", ")", "{", "memset", "(", "vector", "+", "obj", "->", "count", ",", "0", ",", "(", "count", "-", "obj", "->", "count", ")", "*", "sizeof", "(", "int", ")", ")", ";", "count", "=", "obj", "->", "count", ";", "}", "memcpy", "(", "vector", ",", "obj", "->", "status", ",", "count", "*", "sizeof", "(", "int", ")", ")", ";", "return", "1", ";", "}'" ]

[ "end", "is", "openended", "(so", "pass", "pos,pos+1", "to", "remove", "just", "the", "posth", "src)" ]

[ "'void", "instr_remove_srcs", "(", "dcontext_t", "*", "dcontext", ",", "instr_t", "*", "instr", ",", "uint", "start", ",", "uint", "end", ")", "{", "opnd_t", "*", "new_srcs", ";", "CLIENT_ASSERT", "(", "!", "TEST", "(", "INSTR_IS_NOALLOC_STRUCT", ",", "instr", "->", "flags", ")", ",", "/*", "We", "could", "implement,", "but", "it", "does", "not", "seem", "an", "important", "use", "case.", "*/", "\"instr_remove_srcs", "not", "supported", "for", "instr_noalloc_t\"", ")", ";", "CLIENT_ASSERT", "(", "start", ">=", "0", "&&", "end", "<=", "instr", "->", "num_srcs", "&&", "start", "<", "end", ",", "\"instr_remove_srcs:", "ordinals", "invalid\"", ")", ";", "if", "(", "instr", "->", "num_srcs", "-", "1", ">", "(", "byte", ")", "(", "end", "-", "start", ")", ")", "{", "new_srcs", "=", "(", "opnd_t", "*", ")", "heap_alloc", "(", "dcontext", ",", "(", "instr", "->", "num_srcs", "-", "1", "-", "(", "end", "-", "start", ")", ")", "*", "sizeof", "(", "opnd_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "if", "(", "start", ">", "1", ")", "memcpy", "(", "new_srcs", ",", "instr", "->", "srcs", ",", "(", "start", "-", "1", ")", "*", "sizeof", "(", "opnd_t", ")", ")", ";", "if", "(", "(", "byte", ")", "end", "<", "instr", "->", "num_srcs", "-", "1", ")", "{", "memcpy", "(", "new_srcs", "+", "(", "start", "==", "0", "?", "0", ":", "(", "start", "-", "1", ")", ")", ",", "instr", "->", "srcs", "+", "end", ",", "(", "instr", "->", "num_srcs", "-", "1", "-", "end", ")", "*", "sizeof", "(", "opnd_t", ")", ")", ";", "}", "}", "else", "new_srcs", "=", "NULL", ";", "if", "(", "start", "==", "0", "&&", "end", "<", "instr", "->", "num_srcs", ")", "instr", "->", "src0", "=", "instr", "->", "srcs", "[", "end", "-", "1", "]", ";", "heap_free", "(", "dcontext", ",", "instr", "->", "srcs", ",", "(", "instr", "->", "num_srcs", "-", "1", ")", "*", "sizeof", "(", "opnd_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "instr", "->", "num_srcs", "-=", "(", "byte", ")", "(", "end", "-", "start", ")", ";", "instr", "->", "srcs", "=", "new_srcs", ";", "instr_being_modified", "(", "instr", ",", "false", "/*raw", "bits", "invalid*/", ")", ";", "instr_set_operands_valid", "(", "instr", ",", "true", ")", ";", "}'" ]

[ "returns", "the", "4", "bytes", "starting", "at", "position", "pos" ]

[ "'uint", "instr_get_raw_word", "(", "instr_t", "*", "instr", ",", "uint", "pos", ")", "{", "CLIENT_ASSERT", "(", "pos", ">=", "0", "&&", "pos", "+", "3", "<", "instr", "->", "length", "&&", "instr", "->", "bytes", "!=", "NULL", ",", "\"instr_get_raw_word:", "ordinal", "invalid,", "or", "no", "raw", "bits\"", ")", ";", "return", "*", "(", "(", "uint", "*", ")", "(", "instr", "->", "bytes", "+", "pos", ")", ")", ";", "}'" ]

[ "end", "is", "openended", "(so", "pass", "pos,pos+1", "to", "remove", "just", "the", "posth", "dst)" ]

[ "'void", "instr_remove_dsts", "(", "dcontext_t", "*", "dcontext", ",", "instr_t", "*", "instr", ",", "uint", "start", ",", "uint", "end", ")", "{", "opnd_t", "*", "new_dsts", ";", "CLIENT_ASSERT", "(", "!", "TEST", "(", "INSTR_IS_NOALLOC_STRUCT", ",", "instr", "->", "flags", ")", ",", "/*", "We", "could", "implement,", "but", "it", "does", "not", "seem", "an", "important", "use", "case.", "*/", "\"instr_remove_srcs", "not", "supported", "for", "instr_noalloc_t\"", ")", ";", "CLIENT_ASSERT", "(", "start", ">=", "0", "&&", "end", "<=", "instr", "->", "num_dsts", "&&", "start", "<", "end", ",", "\"instr_remove_dsts:", "ordinals", "invalid\"", ")", ";", "if", "(", "instr", "->", "num_dsts", ">", "(", "byte", ")", "(", "end", "-", "start", ")", ")", "{", "new_dsts", "=", "(", "opnd_t", "*", ")", "heap_alloc", "(", "dcontext", ",", "(", "instr", "->", "num_dsts", "-", "(", "end", "-", "start", ")", ")", "*", "sizeof", "(", "opnd_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "if", "(", "start", ">", "0", ")", "memcpy", "(", "new_dsts", ",", "instr", "->", "dsts", ",", "start", "*", "sizeof", "(", "opnd_t", ")", ")", ";", "if", "(", "end", "<", "instr", "->", "num_dsts", ")", "{", "memcpy", "(", "new_dsts", "+", "start", ",", "instr", "->", "dsts", "+", "end", ",", "(", "instr", "->", "num_dsts", "-", "end", ")", "*", "sizeof", "(", "opnd_t", ")", ")", ";", "}", "}", "else", "new_dsts", "=", "NULL", ";", "heap_free", "(", "dcontext", ",", "instr", "->", "dsts", ",", "instr", "->", "num_dsts", "*", "sizeof", "(", "opnd_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "instr", "->", "num_dsts", "-=", "(", "byte", ")", "(", "end", "-", "start", ")", ";", "instr", "->", "dsts", "=", "new_dsts", ";", "instr_being_modified", "(", "instr", ",", "false", "/*raw", "bits", "invalid*/", ")", ";", "instr_set_operands_valid", "(", "instr", ",", "true", ")", ";", "}'" ]