Datasets:

AISE-TUDelft

/

Capybara

like 3

Follow

AISE research lab at TU Delft 44

[ "zeroes", "out", "the", "fields", "of", "instr" ]

[ "'void", "instr_noalloc_init", "(", "dcontext_t", "*", "dcontext", ",", "instr_noalloc_t", "*", "instr", ")", "{", "memset", "(", "instr", ",", "0", ",", "sizeof", "(", "*", "instr", ")", ")", ";", "instr", "->", "instr", ".", "flags", "|=", "INSTR_IS_NOALLOC_STRUCT", ";", "instr_set_isa_mode", "(", "&", "instr", "->", "instr", ",", "dr_get_isa_mode", "(", "dcontext", ")", ")", ";", "}'" ]

[ "In", "this", "func,", "it", "must", "be", "the", "exact", "same", "register,", "not", "a", "sub", "reg" ]

[ "'bool", "instr_writes_to_exact_reg", "(", "instr_t", "*", "instr", ",", "reg_id_t", "reg", ",", "dr_opnd_query_flags_t", "flags", ")", "{", "int", "i", ";", "opnd_t", "opnd", ";", "if", "(", "!", "TEST", "(", "DR_QUERY_INCLUDE_COND_DSTS", ",", "flags", ")", "&&", "instr_is_predicated", "(", "instr", ")", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "instr_num_dsts", "(", "instr", ")", ";", "i", "++", ")", "{", "opnd", "=", "instr_get_dst", "(", "instr", ",", "i", ")", ";", "if", "(", "opnd_is_reg", "(", "opnd", ")", "&&", "(", "opnd_get_reg", "(", "opnd", ")", "==", "reg", ")", "/*", "for", "case", "like", "OP_movt", "on", "ARM", "and", "SIMD", "regs", "on", "X86,", "*", "partial", "reg", "written", "with", "full", "reg", "name", "in", "opnd", "*/", "&&", "opnd_get_size", "(", "opnd", ")", "==", "reg_get_size", "(", "reg", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}'" ]

[ "Frees", "all", "dynamically", "allocated", "storage", "that", "was", "allocated", "by", "instr" ]

[ "'void", "instr_free", "(", "dcontext_t", "*", "dcontext", ",", "instr_t", "*", "instr", ")", "{", "if", "(", "instr_is_label", "(", "instr", ")", "&&", "instr_get_label_callback", "(", "instr", ")", "!=", "NULL", ")", "(", "*", "instr", "->", "label_cb", ")", "(", "dcontext", ",", "instr", ")", ";", "if", "(", "TEST", "(", "INSTR_IS_NOALLOC_STRUCT", ",", "instr", "->", "flags", ")", ")", "return", ";", "if", "(", "TEST", "(", "INSTR_RAW_BITS_ALLOCATED", ",", "instr", "->", "flags", ")", ")", "{", "instr_free_raw_bits", "(", "dcontext", ",", "instr", ")", ";", "}", "if", "(", "instr", "->", "num_dsts", ">", "0", ")", "{", "/*", "checking", "num_dsts,", "not", "dsts,", "b/c", "of", "label", "data", "*/", "heap_free", "(", "dcontext", ",", "instr", "->", "dsts", ",", "instr", "->", "num_dsts", "*", "sizeof", "(", "opnd_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "instr", "->", "dsts", "=", "NULL", ";", "instr", "->", "num_dsts", "=", "0", ";", "}", "if", "(", "instr", "->", "num_srcs", ">", "1", ")", "{", "/*", "checking", "num_src,", "not", "src,", "b/c", "of", "label", "data", "*/", "/*", "remember", "one", "src", "is", "static,", "rest", "are", "dynamic", "*/", "heap_free", "(", "dcontext", ",", "instr", "->", "srcs", ",", "(", "instr", "->", "num_srcs", "-", "1", ")", "*", "sizeof", "(", "opnd_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "instr", "->", "srcs", "=", "NULL", ";", "instr", "->", "num_srcs", "=", "0", ";", "}", "}'" ]

[ "sets", "the", "dst", "opnd", "at", "position", "pos", "in", "instr" ]

[ "'void", "instr_set_dst", "(", "instr_t", "*", "instr", ",", "uint", "pos", ",", "opnd_t", "opnd", ")", "{", "CLIENT_ASSERT", "(", "pos", ">=", "0", "&&", "pos", "<", "instr", "->", "num_dsts", ",", "\"instr_set_dst:", "ordinal", "invalid\"", ")", ";", "instr", "->", "dsts", "[", "pos", "]", "=", "opnd", ";", "/*", "if", "we\\'re", "modifying", "operands,", "don\\'t", "use", "original", "bits", "to", "encode!", "*/", "instr_being_modified", "(", "instr", ",", "false", "/*raw", "bits", "invalid*/", ")", ";", "/*", "assume", "all", "operands", "are", "valid", "*/", "instr_set_operands_valid", "(", "instr", ",", "true", ")", ";", "}'" ]

[ "Returns", "true", "iff", "instr", "has", "been", "marked", "as", "a", "special", "exit", "cti" ]

[ "'bool", "instr_branch_special_exit", "(", "instr_t", "*", "instr", ")", "{", "return", "TEST", "(", "INSTR_BRANCH_SPECIAL_EXIT", ",", "instr", "->", "flags", ")", ";", "}'" ]

[ "i#682:", "add", "pos", "so", "that", "the", "caller", "knows", "which", "opnd", "is", "used" ]

[ "'DR_API", "bool", "instr_compute_address_ex_pos", "(", "instr_t", "*", "instr", ",", "dr_mcontext_t", "*", "mc", ",", "uint", "index", ",", "OUT", "app_pc", "*", "addr", ",", "OUT", "bool", "*", "is_write", ",", "OUT", "uint", "*", "pos", ")", "{", "return", "instr_compute_address_helper", "(", "instr", ",", "dr_mcontext_as_priv_mcontext", "(", "mc", ")", ",", "mc", "->", "size", ",", "mc", "->", "flags", ",", "index", ",", "addr", ",", "is_write", ",", "pos", ")", ";", "}'" ]

[ "zeroes", "out", "the", "fields", "of", "instr" ]

[ "'void", "instr_init", "(", "dcontext_t", "*", "dcontext", ",", "instr_t", "*", "instr", ")", "{", "/*", "everything", "initializes", "to", "0,", "even", "flags,", "to", "indicate", "*", "an", "uninitialized", "instruction", "*/", "memset", "(", "(", "void", "*", ")", "instr", ",", "0", ",", "sizeof", "(", "instr_t", ")", ")", ";", "instr_set_isa_mode", "(", "instr", ",", "dr_get_isa_mode", "(", "dcontext", ")", ")", ";", "}'" ]

[ "deletes", "the", "instr_t", "object", "with", "handle", "\"instr\"", "and", "frees", "its", "storage" ]

[ "'void", "instr_destroy", "(", "dcontext_t", "*", "dcontext", ",", "instr_t", "*", "instr", ")", "{", "instr_free", "(", "dcontext", ",", "instr", ")", ";", "/*", "CAUTION:", "assumes", "that", "instr", "is", "not", "part", "of", "any", "instrlist", "*/", "heap_free", "(", "dcontext", ",", "instr", ",", "sizeof", "(", "instr_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "}'" ]

[ "returns", "an", "empty", "instr_t", "object" ]

[ "'instr_t", "*", "instr_create", "(", "dcontext_t", "*", "dcontext", ")", "{", "instr_t", "*", "instr", "=", "(", "instr_t", "*", ")", "heap_alloc", "(", "dcontext", ",", "sizeof", "(", "instr_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "/*", "everything", "initializes", "to", "0,", "even", "flags,", "to", "indicate", "*", "an", "uninitialized", "instruction", "*/", "memset", "(", "(", "void", "*", ")", "instr", ",", "0", ",", "sizeof", "(", "instr_t", ")", ")", ";", "#", "if", "defined", "(", "X86", ")", "&&", "defined", "(", "X64", ")", "instr_set_isa_mode", "(", "instr", ",", "X64_CACHE_MODE_DC", "(", "dcontext", ")", "?", "DR_ISA_AMD64", ":", "DR_ISA_IA32", ")", ";", "#", "elif", "defined", "(", "ARM", ")", "instr_set_isa_mode", "(", "instr", ",", "dr_get_isa_mode", "(", "dcontext", ")", ")", ";", "#", "endif", "return", "instr", ";", "}'" ]

[ "checks", "regs", "in", "dest", "basedisp", "but", "not", "dest", "reg" ]

[ "'bool", "instr_reads_from_reg", "(", "instr_t", "*", "instr", ",", "reg_id_t", "reg", ",", "dr_opnd_query_flags_t", "flags", ")", "{", "int", "i", ";", "opnd_t", "opnd", ";", "if", "(", "!", "TEST", "(", "DR_QUERY_INCLUDE_COND_SRCS", ",", "flags", ")", "&&", "instr_is_predicated", "(", "instr", ")", "&&", "!", "instr_predicate_reads_srcs", "(", "instr_get_predicate", "(", "instr", ")", ")", ")", "return", "false", ";", "if", "(", "instr_reg_in_src", "(", "instr", ",", "reg", ")", ")", "return", "true", ";", "/*", "As", "a", "special", "case,", "the", "addressing", "registers", "inside", "a", "destination", "memory", "*", "operand", "are", "covered", "by", "DR_QUERY_INCLUDE_COND_SRCS", "rather", "than", "*", "DR_QUERY_INCLUDE_COND_DSTS", "(i#1849).", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "instr_num_dsts", "(", "instr", ")", ";", "i", "++", ")", "{", "opnd", "=", "instr_get_dst", "(", "instr", ",", "i", ")", ";", "if", "(", "!", "opnd_is_reg", "(", "opnd", ")", "&&", "opnd_uses_reg", "(", "opnd", ",", "reg", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}'" ]

[ "In", "this", "func,", "it", "must", "be", "the", "exact", "same", "register,", "not", "a", "sub", "reg" ]

[ "'bool", "instr_reads_from_exact_reg", "(", "instr_t", "*", "instr", ",", "reg_id_t", "reg", ",", "dr_opnd_query_flags_t", "flags", ")", "{", "int", "i", ";", "opnd_t", "opnd", ";", "if", "(", "!", "TEST", "(", "DR_QUERY_INCLUDE_COND_SRCS", ",", "flags", ")", "&&", "instr_is_predicated", "(", "instr", ")", "&&", "!", "instr_predicate_reads_srcs", "(", "instr_get_predicate", "(", "instr", ")", ")", ")", "return", "false", ";", "#", "ifdef", "X86", "/*", "special", "case", "*/", "if", "(", "instr_get_opcode", "(", "instr", ")", "==", "OP_nop_modrm", ")", "return", "false", ";", "#", "endif", "for", "(", "i", "=", "0", ";", "i", "<", "instr_num_srcs", "(", "instr", ")", ";", "i", "++", ")", "{", "opnd", "=", "instr_get_src", "(", "instr", ",", "i", ")", ";", "if", "(", "opnd_is_reg", "(", "opnd", ")", "&&", "opnd_get_reg", "(", "opnd", ")", "==", "reg", "&&", "opnd_get_size", "(", "opnd", ")", "==", "reg_get_size", "(", "reg", ")", ")", "return", "true", ";", "<if", "type=\"elseif\">", "else", "if", "(", "opnd_is_base_disp", "(", "opnd", ")", "&&", "(", "opnd_get_base", "(", "opnd", ")", "==", "reg", "||", "opnd_get_index", "(", "opnd", ")", "==", "reg", "||", "opnd_get_segment", "(", "opnd", ")", "==", "reg", ")", ")", "return", "true", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "instr_num_dsts", "(", "instr", ")", ";", "i", "++", ")", "{", "opnd", "=", "instr_get_dst", "(", "instr", ",", "i", ")", ";", "if", "(", "opnd_is_base_disp", "(", "opnd", ")", "&&", "(", "opnd_get_base", "(", "opnd", ")", "==", "reg", "||", "opnd_get_index", "(", "opnd", ")", "==", "reg", "||", "opnd_get_segment", "(", "opnd", ")", "==", "reg", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}'" ]

[ "returns", "a", "clone", "of", "orig,", "but", "with", "next", "and", "prev", "fields", "set", "to", "NULL" ]

[ "'instr_t", "*", "instr_clone", "(", "dcontext_t", "*", "dcontext", ",", "instr_t", "*", "orig", ")", "{", "/*", "We", "could", "heap-allocate", "an", "instr_noalloc_t", "but", "it\\'s", "intended", "for", "use", "in", "a", "*", "signal", "handler", "or", "other", "places", "where", "we", "don\\'t", "want", "any", "heap", "allocation.", "*/", "CLIENT_ASSERT", "(", "!", "TEST", "(", "INSTR_IS_NOALLOC_STRUCT", ",", "orig", "->", "flags", ")", ",", "\"Cloning", "an", "instr_noalloc_t", "is", "not", "supported.\"", ")", ";", "instr_t", "*", "instr", "=", "(", "instr_t", "*", ")", "heap_alloc", "(", "dcontext", ",", "sizeof", "(", "instr_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "memcpy", "(", "(", "void", "*", ")", "instr", ",", "(", "void", "*", ")", "orig", ",", "sizeof", "(", "instr_t", ")", ")", ";", "instr", "->", "next", "=", "NULL", ";", "instr", "->", "prev", "=", "NULL", ";", "/*", "PR", "214962:", "clients", "can", "see", "some", "of", "our", "mangling", "*", "(dr_insert_mbr_instrumentation(),", "traces),", "but", "don\\'t", "let", "the", "flag", "*", "mark", "other", "client", "instrs,", "which", "could", "mess", "up", "state", "translation", "*/", "instr_set_our_mangling", "(", "instr", ",", "false", ")", ";", "if", "(", "(", "orig", "->", "flags", "&", "INSTR_RAW_BITS_ALLOCATED", ")", "!=", "0", ")", "{", "/*", "instr", "length", "already", "set", "from", "memcpy", "*/", "instr", "->", "bytes", "=", "(", "byte", "*", ")", "heap_reachable_alloc", "(", "dcontext", ",", "instr->length", "HEAPACCT(ACCT_IR)", ")", ";", "memcpy", "(", "(", "void", "*", ")", "instr", "->", "bytes", ",", "(", "void", "*", ")", "orig", "->", "bytes", ",", "instr", "->", "length", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "instr_is_label", "(", "orig", ")", ")", "{", "/*", "We", "don\\'t", "know", "what", "this", "callback", "does,", "we", "can\\'t", "copy", "this.", "The", "caller", "that", "*", "makes", "the", "clone", "needs", "to", "take", "care", "of", "this,", "xref", "i#3926.", "*/", "instr_set_label_callback", "(", "instr", ",", "NULL", ")", ";", "}", "if", "(", "orig", "->", "num_dsts", ">", "0", ")", "{", "/*", "checking", "num_dsts,", "not", "dsts,", "b/c", "of", "label", "data", "*/", "instr", "->", "dsts", "=", "(", "opnd_t", "*", ")", "heap_alloc", "(", "dcontext", ",", "instr", "->", "num_dsts", "*", "sizeof", "(", "opnd_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "memcpy", "(", "(", "void", "*", ")", "instr", "->", "dsts", ",", "(", "void", "*", ")", "orig", "->", "dsts", ",", "instr", "->", "num_dsts", "*", "sizeof", "(", "opnd_t", ")", ")", ";", "}", "if", "(", "orig", "->", "num_srcs", ">", "1", ")", "{", "/*", "checking", "num_src,", "not", "srcs,", "b/c", "of", "label", "data", "*/", "instr", "->", "srcs", "=", "(", "opnd_t", "*", ")", "heap_alloc", "(", "dcontext", ",", "(", "instr", "->", "num_srcs", "-", "1", ")", "*", "sizeof", "(", "opnd_t", ")", "HEAPACCT", "(", "ACCT_IR", ")", ")", ";", "memcpy", "(", "(", "void", "*", ")", "instr", "->", "srcs", ",", "(", "void", "*", ")", "orig", "->", "srcs", ",", "(", "instr", "->", "num_srcs", "-", "1", ")", "*", "sizeof", "(", "opnd_t", ")", ")", ";", "}", "/*", "copy", "note", "(we", "make", "no", "guarantee,", "and", "have", "no", "way,", "to", "do", "a", "deep", "clone)", "*/", "instr", "->", "note", "=", "orig", "->", "note", ";", "if", "(", "instr_is_label", "(", "orig", ")", ")", "memcpy", "(", "&", "instr", "->", "label_data", ",", "&", "orig", "->", "label_data", ",", "sizeof", "(", "instr", "->", "label_data", ")", ")", ";", "return", "instr", ";", "}'" ]

[ "sets", "the", "src", "opnd", "at", "position", "pos", "in", "instr" ]

[ "'void", "instr_set_src", "(", "instr_t", "*", "instr", ",", "uint", "pos", ",", "opnd_t", "opnd", ")", "{", "CLIENT_ASSERT", "(", "pos", ">=", "0", "&&", "pos", "<", "instr", "->", "num_srcs", ",", "\"instr_set_src:", "ordinal", "invalid\"", ")", ";", "/*", "remember", "that", "src0", "is", "static,", "rest", "are", "dynamic", "*/", "if", "(", "pos", "==", "0", ")", "instr", "->", "src0", "=", "opnd", ";", "else", "instr", "->", "srcs", "[", "pos", "-", "1", "]", "=", "opnd", ";", "/*", "if", "we\\'re", "modifying", "operands,", "don\\'t", "use", "original", "bits", "to", "encode!", "*/", "instr_being_modified", "(", "instr", ",", "false", "/*raw", "bits", "invalid*/", ")", ";", "/*", "assume", "all", "operands", "are", "valid", "*/", "instr_set_operands_valid", "(", "instr", ",", "true", ")", ";", "}'" ]

[ "Returns", "true", "iff", "instr", "is", "a", "label", "metainstruction" ]

[ "'bool", "instr_is_label", "(", "instr_t", "*", "instr", ")", "{", "return", "instr_opcode_valid", "(", "instr", ")", "&&", "instr_get_opcode", "(", "instr", ")", "==", "OP_LABEL", ";", "}'" ]

[ "Return", "the", "location", "of", "the", "ith", "Greville", "abscissa" ]

[ "'double", "gsl_bspline_greville_abscissa", "(", "size_t", "i", ",", "gsl_bspline_workspace", "*", "w", ")", "{", "const", "size_t", "stride", "=", "w", "->", "knots", "->", "stride", ";", "size_t", "km1", "=", "w", "->", "km1", ";", "double", "*", "data", "=", "w", "->", "knots", "->", "data", "+", "(", "i", "+", "1", ")", "*", "stride", ";", "#", "if", "GSL_RANGE_CHECK", "if", "(", "GSL_RANGE_COND", "(", "i", ">=", "gsl_bspline_ncoeffs", "(", "w", ")", ")", ")", "{", "GSL_ERROR_VAL", "(", "\"Greville", "abscissa", "index", "out", "of", "range\"", ",", "GSL_EINVAL", ",", "0", ")", ";", "}", "#", "endif", "if", "(", "km1", "==", "0", ")", "{", "/*", "Return", "interval", "midpoints", "in", "degenerate", "k", "=", "1", "case*/", "km1", "=", "2", ";", "data", "-=", "stride", ";", "}", "return", "gsl_stats_mean", "(", "data", ",", "stride", ",", "km1", ")", ";", "}'" ]

[ "Add", "a", "language", "to", "the", "set", "of", "known", "languages" ]

[ "'void", "add_language", "(", "const", "struct", "language_defn", "*", "lang", ")", "{", "/*", "For", "the", "\"set", "language\"", "command.", "*/", "static", "const", "char", "*", "*", "language_names", "=", "NULL", ";", "/*", "For", "the", "\"help", "set", "language\"", "command.", "*/", "char", "*", "language_set_doc", "=", "NULL", ";", "int", "i", ";", "struct", "ui_file", "*", "tmp_stream", ";", "if", "(", "lang", "->", "la_magic", "!=", "LANG_MAGIC", ")", "{", "fprintf_unfiltered", "(", "gdb_stderr", ",", "\"Magic", "number", "of", "%s", "language", "struct", "wrong\\\"", ",", "lang", "->", "la_name", ")", ";", "internal_error", "(", "__FILE__", ",", "__LINE__", ",", "_", "(", "\"failed", "internal", "consistency", "check\"", ")", ")", ";", "}", "if", "(", "!", "languages", ")", "{", "languages_allocsize", "=", "DEFAULT_ALLOCSIZE", ";", "languages", "=", "(", "const", "struct", "language_defn", "*", "*", ")", "xmalloc", "(", "languages_allocsize", "*", "sizeof", "(", "*", "languages", ")", ")", ";", "}", "if", "(", "languages_size", ">=", "languages_allocsize", ")", "{", "languages_allocsize", "*=", "2", ";", "languages", "=", "(", "const", "struct", "language_defn", "*", "*", ")", "xrealloc", "(", "(", "char", "*", ")", "languages", ",", "languages_allocsize", "*", "sizeof", "(", "*", "languages", ")", ")", ";", "}", "languages", "[", "languages_size", "++", "]", "=", "lang", ";", "/*", "Build", "the", "language", "names", "array,", "to", "be", "used", "as", "enumeration", "in", "the", "set", "language\"", "enum", "command.", "*/", "language_names", "=", "xrealloc", "(", "language_names", ",", "(", "languages_size", "+", "1", ")", "*", "sizeof", "(", "const", "char", "*", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "languages_size", ";", "++", "i", ")", "language_names", "[", "i", "]", "=", "languages", "[", "i", "]", "->", "la_name", ";", "language_names", "[", "i", "]", "=", "NULL", ";", "/*", "Build", "the", "\"help", "set", "language\"", "docs.", "*/", "tmp_stream", "=", "mem_fileopen", "()", ";", "fprintf_unfiltered", "(", "tmp_stream", ",", "_", "(", "\"Set", "the", "current", "source", "language.\\\"", "\"The", "currently", "understood", "settings", "are:\\\\local", "or", "\"", "\"auto", "Automatic", "setting", "based", "on", "source", "file\\\"", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "languages_size", ";", "++", "i", ")", "{", "/*", "Already", "dealt", "with", "these", "above.", "*/", "if", "(", "languages", "[", "i", "]", "->", "la_language", "==", "language_unknown", "||", "languages", "[", "i", "]", "->", "la_language", "==", "language_auto", ")", "continue;", "/*", "FIXME:", "i18n:", "for", "now", "assume", "that", "the", "human-readable", "name", "is", "just", "a", "capitalization", "of", "the", "internal", "name.", "*/", "fprintf_unfiltered", "(", "tmp_stream", ",", "\"%-16s", "Use", "the", "%c%s", "language\\\"", ",", "languages", "[", "i", "]", "->", "la_name", ",", "/*", "Capitalize", "first", "letter", "of", "language", "name.", "*/", "toupper", "(", "languages", "[", "i", "]", "->", "la_name", "[", "0", "]", ")", ",", "languages", "[", "i", "]", "->", "la_name", "+", "1", ")", ";", "}", "language_set_doc", "=", "ui_file_xstrdup", "(", "tmp_stream", ",", "NULL", ")", ";", "ui_file_delete", "(", "tmp_stream", ")", ";", "add_setshow_enum_cmd", "(", "\"language\"", ",", "class_support", ",", "(", "const", "char", "*", "*", ")", "language_names", ",", "&", "language", ",", "language_set_doc", ",", "_", "(", "\"Show", "the", "current", "source", "language.\"", ")", ",", "NULL", ",", "set_language_command", ",", "show_language_command", ",", "&", "setlist", ",", "&", "showlist", ")", ";", "xfree", "(", "language_set_doc", ")", ";", "}'" ]

[ "Unknown", "languages", "just", "use", "the", "cplus", "demangler" ]

[ "'static", "char", "*", "unk_lang_demangle", "(", "const", "char", "*", "mangled", ",", "int", "options", ")", "{", "return", "gdb_demangle", "(", "mangled", ",", "options", ")", ";", "}'" ]

[ "Print", "the", "index", "of", "array", "elements", "using", "the", "C99", "syntax" ]

[ "'void", "default_print_array_index", "(", "struct", "value", "*", "index_value", ",", "struct", "ui_file", "*", "stream", ",", "const", "struct", "value_print_options", "*", "options", ")", "{", "fprintf_filtered", "(", "stream", ",", "\"[\"", ")", ";", "LA_VALUE_PRINT", "(", "index_value", ",", "stream", ",", "options", ")", ";", "fprintf_filtered", "(", "stream", ",", "\"]", "=", "\"", ")", ";", "}'" ]

[ "Returns", "nonzero", "if", "the", "value", "is", "a", "pointer", "type" ]

[ "'int", "pointer_type", "(", "struct", "type", "*", "type", ")", "{", "return", "TYPE_CODE", "(", "type", ")", "==", "TYPE_CODE_PTR", "||", "TYPE_CODE", "(", "type", ")", "==", "TYPE_CODE_REF", ";", "}'" ]

[ "Return", "the", "language", "struct", "for", "a", "given", "language", "enum" ]

[ "'const", "struct", "language_defn", "*", "language_def", "(", "enum", "language", "lang", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "languages_size", ";", "i", "++", ")", "{", "if", "(", "languages", "[", "i", "]", "->", "la_language", "==", "lang", ")", "{", "return", "languages", "[", "i", "]", ";", "}", "}", "return", "NULL", ";", "}'" ]

[ "Return", "class", "name", "from", "physname", "or", "NULL" ]

[ "'char", "*", "language_class_name_from_physname", "(", "const", "struct", "language_defn", "*", "lang", ",", "const", "char", "*", "physname", ")", "{", "if", "(", "lang", "!=", "NULL", "&&", "lang", "->", "la_class_name_from_physname", ")", "return", "lang", "->", "la_class_name_from_physname", "(", "physname", ")", ";", "return", "NULL", ";", "}'" ]

[ "Return", "the", "language", "as", "a", "string" ]

[ "'const", "char", "*", "language_str", "(", "enum", "language", "lang", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "languages_size", ";", "i", "++", ")", "{", "if", "(", "languages", "[", "i", "]", "->", "la_language", "==", "lang", ")", "{", "return", "languages", "[", "i", "]", "->", "la_name", ";", "}", "}", "return", "\"Unknown\"", ";", "}'" ]

[ "Initialize", "the", "language", "routines" ]

[ "'void", "_initialize_language", "(", "void", ")", "{", "static", "const", "char", "*", "const", "type_or_range_names", "[]", "=", "{", "\"on\"", ",", "\"off\"", ",", "\"warn\"", ",", "\"auto\"", ",", "NULL", "}", ";", "static", "const", "char", "*", "const", "case_sensitive_names", "[]", "=", "{", "\"on\"", ",", "\"off\"", ",", "\"auto\"", ",", "NULL", "}", ";", "language_gdbarch_data", "=", "gdbarch_data_register_post_init", "(", "language_gdbarch_post_init", ")", ";", "/*", "GDB", "commands", "for", "language", "specific", "stuff.", "*/", "add_prefix_cmd", "(", "\"check\"", ",", "no_class", ",", "set_check", ",", "_", "(", "\"Set", "the", "status", "of", "the", "type/range", "checker.\"", ")", ",", "&", "setchecklist", ",", "\"set", "check", "\"", ",", "0", ",", "&", "setlist", ")", ";", "add_alias_cmd", "(", "\"c\"", ",", "\"check\"", ",", "no_class", ",", "1", ",", "&", "setlist", ")", ";", "add_alias_cmd", "(", "\"ch\"", ",", "\"check\"", ",", "no_class", ",", "1", ",", "&", "setlist", ")", ";", "add_prefix_cmd", "(", "\"check\"", ",", "no_class", ",", "show_check", ",", "_", "(", "\"Show", "the", "status", "of", "the", "type/range", "checker.\"", ")", ",", "&", "showchecklist", ",", "\"show", "check", "\"", ",", "0", ",", "&", "showlist", ")", ";", "add_alias_cmd", "(", "\"c\"", ",", "\"check\"", ",", "no_class", ",", "1", ",", "&", "showlist", ")", ";", "add_alias_cmd", "(", "\"ch\"", ",", "\"check\"", ",", "no_class", ",", "1", ",", "&", "showlist", ")", ";", "add_setshow_enum_cmd", "(", "\"range\"", ",", "class_support", ",", "type_or_range_names", ",", "&", "range", ",", "_", "(", "\"Set", "range", "checking.", "(on/warn/off/auto)\"", ")", ",", "_", "(", "\"Show", "range", "checking.", "(on/warn/off/auto)\"", ")", ",", "NULL", ",", "set_range_command", ",", "show_range_command", ",", "&", "setchecklist", ",", "&", "showchecklist", ")", ";", "add_setshow_enum_cmd", "(", "\"case-sensitive\"", ",", "class_support", ",", "case_sensitive_names", ",", "&", "case_sensitive", ",", "_", "(", "\"\\\\", "Set", "case", "sensitivity", "in", "name", "search.", "(on/off/auto)\"", ")", ",", "_", "(", "\"\\\\", "Show", "case", "sensitivity", "in", "name", "search.", "(on/off/auto)\"", ")", ",", "_", "(", "\"\\\\", "For", "Fortran", "the", "default", "is", "off;", "for", "other", "languages", "the", "default", "is", "on.\"", ")", ",", "set_case_command", ",", "show_case_command", ",", "&", "setlist", ",", "&", "showlist", ")", ";", "add_language", "(", "&", "auto_language_defn", ")", ";", "add_language", "(", "&", "local_language_defn", ")", ";", "add_language", "(", "&", "unknown_language_defn", ")", ";", "language", "=", "xstrdup", "(", "\"auto\"", ")", ";", "type", "=", "xstrdup", "(", "\"auto\"", ")", ";", "range", "=", "xstrdup", "(", "\"auto\"", ")", ";", "case_sensitive", "=", "xstrdup", "(", "\"auto\"", ")", ";", "/*", "Have", "the", "above", "take", "effect.", "*/", "set_language", "(", "language_auto", ")", ";", "}'" ]

[ "Define", "the", "language", "that", "is", "no", "language" ]

[ "'static", "int", "unk_lang_parser", "(", "struct", "parser_state", "*", "ps", ")", "{", "return", "1", ";", "}'" ]

[ "(rp,", "2n)", "(xp,", "n)(yp,", "n)" ]

[ "'static", "void", "mpn_mulshort_n", "(", "mp_ptr", "rp", ",", "mp_srcptr", "xp", ",", "mp_srcptr", "yp", ",", "mp_size_t", "n", ")", "{", "mp_size_t", "m", ";", "mp_limb_t", "t", ";", "mp_ptr", "rpn2", ";", "ASSERT", "(", "n", ">=", "1", ")", ";", "ASSERT_MPN", "(", "xp", ",", "n", ")", ";", "ASSERT_MPN", "(", "yp", ",", "n", ")", ";", "ASSERT", "(", "!", "MPN_OVERLAP_P", "(", "rp", ",", "2", "*", "n", ",", "xp", ",", "n", ")", ")", ";", "ASSERT", "(", "!", "MPN_OVERLAP_P", "(", "rp", ",", "2", "*", "n", ",", "yp", ",", "n", ")", ")", ";", "if", "(", "BELOW_THRESHOLD", "(", "n", ",", "MULHIGH_BASECASE_THRESHOLD", ")", ")", "{", "mpn_mul_basecase", "(", "rp", ",", "xp", ",", "n", ",", "yp", ",", "n", ")", ";", "return", ";", "}", "if", "(", "BELOW_THRESHOLD", "(", "n", ",", "MULHIGH_DC_THRESHOLD", ")", ")", "{", "mpn_mulshort_n_basecase", "(", "rp", ",", "xp", ",", "yp", ",", "n", ")", ";", "return", ";", "}", "/*", "choose", "optimal", "m", "s.t.", "n", "+", "2", "<=", "2m,", "m", "<", "n", "*/", "ASSERT", "(", "n", ">=", "4", ")", ";", "m", "=", "87", "*", "n", "/", "128", ";", "if", "(", "2", "*", "m", "<", "n", "+", "2", ")", "m", "=", "(", "n", "+", "1", ")", "/", "2", "+", "1", ";", "if", "(", "m", ">=", "n", ")", "m", "=", "n", "-", "1", ";", "ASSERT", "(", "n", "+", "2", "<=", "2", "*", "m", ")", ";", "ASSERT", "(", "m", "<", "n", ")", ";", "rpn2", "=", "rp", "+", "n", "-", "2", ";", "mpn_mul_n", "(", "rp", "+", "n", "-", "m", "+", "n", "-", "m", ",", "xp", "+", "n", "-", "m", ",", "yp", "+", "n", "-", "m", ",", "m", ")", ";", "mpn_mulshort_n", "(", "rp", ",", "xp", ",", "yp", "+", "m", ",", "n", "-", "m", ")", ";", "ASSERT_NOCARRY", "(", "mpn_add", "(", "rpn2", ",", "rpn2", ",", "n", "+", "2", ",", "rpn2", "-", "m", ",", "n", "-", "m", "+", "2", ")", ")", ";", "mpn_mulshort_n", "(", "rp", ",", "xp", "+", "m", ",", "yp", ",", "n", "-", "m", ")", ";", "ASSERT_NOCARRY", "(", "mpn_add", "(", "rpn2", ",", "rpn2", ",", "n", "+", "2", ",", "rpn2", "-", "m", ",", "n", "-", "m", "+", "2", ")", ")", ";", "umul_ppmm", "(", "rp", "[", "1", "]", ",", "t", ",", "xp", "[", "m", "-", "1", "]", ",", "yp", "[", "n", "-", "m", "-", "1", "]", "<<", "GMP_NAIL_BITS", ")", ";", "rp", "[", "0", "]", "=", "t", ">>", "GMP_NAIL_BITS", ";", "ASSERT_NOCARRY", "(", "mpn_add", "(", "rpn2", ",", "rpn2", ",", "n", "+", "2", ",", "rp", ",", "2", ")", ")", ";", "umul_ppmm", "(", "rp", "[", "1", "]", ",", "t", ",", "xp", "[", "n", "-", "m", "-", "1", "]", ",", "yp", "[", "m", "-", "1", "]", "<<", "GMP_NAIL_BITS", ")", ";", "rp", "[", "0", "]", "=", "t", ">>", "GMP_NAIL_BITS", ";", "ASSERT_NOCARRY", "(", "mpn_add", "(", "rpn2", ",", "rpn2", ",", "n", "+", "2", ",", "rp", ",", "2", ")", ")", ";", "return", ";", "}'" ]

[ "yy_get_previous_state", "get", "the", "state", "just", "before", "the", "EOB", "char", "was", "reached" ]

[ "'static", "yy_state_type", "yy_get_previous_state", "(", "yyscan_t", "yyscanner", ")", "{", "yy_state_type", "yy_current_state", ";", "char", "*", "yy_cp", ";", "struct", "yyguts_t", "*", "yyg", "=", "(", "struct", "yyguts_t", "*", ")", "yyscanner", ";", "yy_current_state", "=", "yy_start_state_list", "[", "yyg", "->", "yy_start", "]", ";", "for", "(", "yy_cp", "=", "yyg", "->", "yytext_ptr", "+", "YY_MORE_ADJ", ";", "yy_cp", "<", "yyg", "->", "yy_c_buf_p", ";", "++", "yy_cp", ")", "{", "yy_current_state", "+=", "yy_current_state", "[", "(", "*", "yy_cp", "?", "YY_SC_TO_UI", "(", "*", "yy_cp", ")", ":", "256", ")", "]", ".", "yy_nxt", ";", "if", "(", "yy_current_state", "[", "-", "1", "]", ".", "yy_nxt", ")", "{", "yyg", "->", "yy_last_accepting_state", "=", "yy_current_state", ";", "yyg", "->", "yy_last_accepting_cpos", "=", "yy_cp", ";", "}", "}", "return", "yy_current_state", ";", "}'" ]

[ "Append", "a", "string", "SRC", "to", "an", "options", "array", "DST" ]

[ "'void", "append_option", "(", "options_t", "*", "dst", ",", "const", "char", "*", "src", ")", "{", "if", "(", "dst", "->", "alloc", "==", "dst", "->", "num", ")", "{", "size_t", "a", "=", "(", "dst", "->", "num", "+", "2", ")", "*", "2", ";", "void", "*", "o", "=", "xmalloc", "(", "sizeof", "(", "*", "dst", "->", "options", ")", "*", "a", ")", ";", "memcpy", "(", "o", ",", "dst", "->", "options", ",", "sizeof", "(", "*", "dst", "->", "options", ")", "*", "dst", "->", "num", ")", ";", "free", "(", "dst", "->", "options", ")", ";", "dst", "->", "options", "=", "o", ";", "dst", "->", "alloc", "=", "a", ";", "}", "dst", "->", "options", "[", "dst", "->", "num", "]", "=", "src", ";", "dst", "->", "num", "++", ";", "}'" ]

[ "open", "a", "file", "or", "fail" ]

[ "'FILE", "*", "xfopen", "(", "const", "char", "*", "path", ",", "const", "char", "*", "mode", ")", "{", "FILE", "*", "ret", "=", "fopen", "(", "path", ",", "mode", ")", ";", "if", "(", "!", "ret", ")", "fatal_perror", "(", "\"Unable", "to", "open", "\\'%s\\'\"", ",", "path", ")", ";", "return", "ret", ";", "}'" ]

[ "Append", "an", "options", "array", "SRC", "to", "another", "options", "array", "DST" ]

[ "'void", "append_options", "(", "options_t", "*", "dst", ",", "const", "options_t", "*", "src", ")", "{", "if", "(", "dst", "->", "alloc", "<", "dst", "->", "num", "+", "src", "->", "num", ")", "{", "size_t", "a", "=", "(", "dst", "->", "num", "+", "src", "->", "num", "+", "2", ")", "*", "2", ";", "void", "*", "o", "=", "xmalloc", "(", "sizeof", "(", "*", "dst", "->", "options", ")", "*", "a", ")", ";", "memcpy", "(", "o", ",", "dst", "->", "options", ",", "sizeof", "(", "*", "dst", "->", "options", ")", "*", "dst", "->", "num", ")", ";", "free", "(", "dst", "->", "options", ")", ";", "dst", "->", "options", "=", "o", ";", "dst", "->", "alloc", "=", "a", ";", "}", "memcpy", "(", "&", "dst", "->", "options", "[", "dst", "->", "num", "]", ",", "&", "src", "->", "options", "[", "0", "]", ",", "sizeof", "(", "*", "dst", "->", "options", ")", "*", "src", "->", "num", ")", ";", "dst", "->", "num", "+=", "src", "->", "num", ";", "}'" ]

[ "Split", "and", "append", "a", "string", "SRC", "to", "an", "options", "array", "DST" ]

[ "\"void", "append_option_str", "(", "options_t", "*", "dst", ",", "const", "char", "*", "src", ",", "const", "char", "*", "delim", ")", "{", "char", "*", "tok_src", "=", "xstrdup", "(", "src", ")", ";", "char", "*", "tok", "=", "strtok", "(", "tok_src", ",", "delim", ")", ";", "while", "(", "tok", ")", "{", "append_option", "(", "dst", ",", "tok", ")", ";", "tok", "=", "strtok", "(", "NULL", ",", "delim", ")", ";", "}", "/*", "don't", "free", "tok_src", "since", "options_t", "now", "points", "to", "it", "*/", "}\"" ]

[ "Function", "to", "wait", "for", "EOC" ]

[ "'inline", "static", "bool", "wait_for_eoc", "(", "unsigned", "timeout", ")", "{", "return", "cin_wait", "(", "timeout", ")", "==", "PROTO_EOC", ";", "}'" ]

[ "Corespecific", "functionality", "for", "elf_loader_map_phdrs()" ]

[ "\"static", "modload_flags_t", "privload_map_flags", "(", "modload_flags_t", "init_flags", ")", "{", "/*", "XXX:", "Keep", "this", "condition", "matching", "the", "check", "in", "privload_unmap_file()", "*", "(minus", "MODLOAD_NOT_PRIVLIB", "since", "non-privlibs", "don't", "reach", "our", "unmap).", "*/", "if", "(", "INTERNAL_OPTION", "(", "separate_private_bss", ")", "&&", "!", "TEST", "(", "MODLOAD_NOT_PRIVLIB", ",", "init_flags", ")", ")", "{", "/*", "place", "an", "extra", "no-access", "page", "after", ".bss", "*/", "/*", "XXX:", "update", "privload_early_inject", "call", "to", "init_emulated_brk", "if", "this", "changes", "*/", "/*", "XXX:", "should", "we", "avoid", "this", "for", "-early_inject's", "map", "of", "the", "app", "and", "ld.so?", "*/", "return", "init_flags", "|", "MODLOAD_SEPARATE_BSS", ";", "}", "return", "init_flags", ";", "}\"" ]

[ "If", "runpath,", "then", "DT_RUNPATH", "is", "searched;", "else,", "DT_RPATH" ]

[ "'static", "bool", "privload_search_rpath", "(", "privmod_t", "*", "mod", ",", "bool", "runpath", ",", "const", "char", "*", "name", ",", "char", "*", "filename", "OUT", "/*", "buffer", "size", "is", "MAXIMUM_PATH", "*/", ")", "{", "#", "ifdef", "LINUX", "os_privmod_data_t", "*", "opd", ";", "ELF_DYNAMIC_ENTRY_TYPE", "*", "dyn", ";", "ASSERT", "(", "mod", "!=", "NULL", "&&", "\"can\\'t", "look", "for", "rpath", "without", "a", "dependent", "module\"", ")", ";", "ASSERT_OWN_RECURSIVE_LOCK", "(", "true", ",", "&", "privload_lock", ")", ";", "/*", "get", "the", "loading", "module\\'s", "dir", "for", "RPATH_ORIGIN", "*/", "opd", "=", "(", "os_privmod_data_t", "*", ")", "mod", "->", "os_privmod_data", ";", "/*", "i#460:", "if", "DT_RUNPATH", "exists", "we", "must", "ignore", "ignore", "DT_RPATH", "and", "*", "search", "DT_RUNPATH", "after", "LD_LIBRARY_PATH.", "*/", "if", "(", "!", "runpath", "&&", "opd", "->", "os_data", ".", "has_runpath", ")", "return", "false", ";", "const", "char", "*", "moddir_end", "=", "strrchr", "(", "mod", "->", "path", ",", "\\'/\\'", ")", ";", "size_t", "moddir_len", "=", "(", "moddir_end", "==", "NULL", "?", "strlen", "(", "mod", "->", "path", ")", ":", "moddir_end", "-", "mod", "->", "path", ")", ";", "const", "char", "*", "strtab", ";", "ASSERT", "(", "opd", "!=", "NULL", ")", ";", "dyn", "=", "(", "ELF_DYNAMIC_ENTRY_TYPE", "*", ")", "opd", "->", "dyn", ";", "strtab", "=", "(", "char", "*", ")", "opd", "->", "os_data", ".", "dynstr", ";", "bool", "lib_found", "=", "false", ";", "/*", "support", "$ORIGIN", "expansion", "to", "lib\\'s", "current", "directory", "*/", "while", "(", "dyn", "->", "d_tag", "!=", "DT_NULL", ")", "{", "if", "(", "dyn", "->", "d_tag", "==", "(", "runpath", "?", "DT_RUNPATH", ":", "DT_RPATH", ")", ")", "{", "/*", "DT_RPATH", "and", "DT_RUNPATH", "are", "each", "a", "colon-separated", "list", "of", "paths", "*/", "const", "char", "*", "list", "=", "strtab", "+", "dyn", "->", "d_un", ".", "d_val", ";", "const", "char", "*", "sep", ",", "<type", "ref=\"prev\">", "*", "origin", ";", "size_t", "len", ";", "while", "(", "*", "list", "!=", "\\'\\\\0\\'", ")", "{", "/*", "really", "we", "want", "strchrnul()", "*/", "sep", "=", "strchr", "(", "list", ",", "\\':\\'", ")", ";", "if", "(", "sep", "==", "NULL", ")", "len", "=", "strlen", "(", "list", ")", ";", "else", "len", "=", "sep", "-", "list", ";", "/*", "support", "$ORIGIN", "expansion", "to", "lib\\'s", "current", "directory", "*/", "origin", "=", "strstr", "(", "list", ",", "RPATH_ORIGIN", ")", ";", "char", "path", "[", "MAXIMUM_PATH", "]", ";", "if", "(", "origin", "!=", "NULL", "&&", "origin", "<", "list", "+", "len", ")", "{", "size_t", "pre_len", "=", "origin", "-", "list", ";", "snprintf", "(", "path", ",", "BUFFER_SIZE_ELEMENTS", "(", "path", ")", ",", "\"%.*s%.*s%.*s\"", ",", "pre_len", ",", "list", ",", "moddir_len", ",", "mod", "->", "path", ",", "/*", "the", "\\'/\\'", "should", "already", "be", "here", "*/", "len", "-", "strlen", "(", "RPATH_ORIGIN", ")", "-", "pre_len", ",", "origin", "+", "strlen", "(", "RPATH_ORIGIN", ")", ")", ";", "NULL_TERMINATE_BUFFER", "(", "path", ")", ";", "}", "else", "{", "snprintf", "(", "path", ",", "BUFFER_SIZE_ELEMENTS", "(", "path", ")", ",", "\"%.*s\"", ",", "len", ",", "list", ")", ";", "NULL_TERMINATE_BUFFER", "(", "path", ")", ";", "}", "#", "ifdef", "CLIENT_INTERFACE", "if", "(", "mod", "->", "is_client", ")", "{", "/*", "We", "are", "adding", "a", "client\\'s", "lib", "rpath", "to", "the", "general", "search", "path.", "This", "*", "is", "not", "bullet", "proof", "compliant", "with", "what", "the", "loader", "should", "really", "*", "do.", "The", "real", "problem", "is", "that", "the", "loader", "is", "walking", "library", "*", "dependencies", "depth-first,", "while", "it", "should", "really", "search", "*", "breadth-first", "(xref", "i#3850).", "This", "can", "lead", "to", "libraries", "being", "*", "unlocatable,", "if", "the", "original", "client", "library", "had", "the", "proper", "rpath", "of", "*", "the", "library,", "but", "a", "dependency", "later", "in", "the", "chain", "did", "not.", "In", "order", "*", "to", "avoid", "this,", "we", "consider", "adding", "the", "rpath", "here", "relatively", "safe.", "*", "It", "only", "affects", "dependent", "libraries", "of", "the", "same", "name", "in", "different", "*", "locations.", "We", "are", "only", "doing", "this", "for", "client", "libraries,", "so", "we", "are", "*", "not", "at", "risk", "to", "search", "for", "the", "wrong", "system", "libraries.", "*/", "if", "(", "!", "privload_search_path_exists", "(", "path", ",", "strlen", "(", "path", ")", ")", ")", "{", "snprintf", "(", "search_paths", "[", "search_paths_idx", "]", ",", "BUFFER_SIZE_ELEMENTS", "(", "search_paths", "[", "search_paths_idx", "]", ")", ",", "\"%.*s\"", ",", "strlen", "(", "path", ")", ",", "path", ")", ";", "NULL_TERMINATE_BUFFER", "(", "search_paths", "[", "search_paths_idx", "]", ")", ";", "LOG", "(", "GLOBAL", ",", "LOG_LOADER", ",", "1", ",", "\"%s:", "added", "search", "dir", "\\\\\"%s\\\\\"\\\"", ",", "__FUNCTION__", ",", "search_paths", "[", "search_paths_idx", "]", ")", ";", "search_paths_idx", "++", ";", "}", "}", "#", "endif", "if", "(", "!", "lib_found", ")", "{", "snprintf", "(", "filename", ",", "MAXIMUM_PATH", ",", "\"%s/%s\"", ",", "path", ",", "name", ")", ";", "filename", "[", "MAXIMUM_PATH", "-", "1", "]", "=", "0", ";", "LOG", "(", "GLOBAL", ",", "LOG_LOADER", ",", "2", ",", "\"%s:", "looking", "for", "%s\\\"", ",", "__FUNCTION__", ",", "filename", ")", ";", "if", "(", "os_file_exists", "(", "filename", ",", "false", "<comment_type=\"block\"", "format=\"doxygen\">", "/*!is_dir*/", ")", "&&", "module_file_has_module_header", "(", "filename", ")", ")", "{", "#", "ifdef", "CLIENT_INTERFACE", "lib_found", "=", "true", ";", "#", "else", "return", "true", ";", "#", "endif", "}", "}", "list", "+=", "len", ";", "if", "(", "sep", "!=", "NULL", ")", "list", "+=", "1", ";", "}", "}", "++", "dyn", ";", "}", "return", "lib_found", ";", "#", "else", "/*", "XXX", "i#1285:", "implement", "MacOS", "private", "loader", "*/", "#", "endif", "return", "false", ";", "}'" ]

[ "os", "specific", "loader", "initialization", "prologue", "before", "finalizing", "the", "load" ]

[ "'void", "os_loader_init_prologue", "(", "void", ")", "{", "#", "ifndef", "STATIC_LIBRARY", "privmod_t", "*", "mod", ";", "#", "endif", "ASSERT_OWN_RECURSIVE_LOCK", "(", "true", ",", "&", "privload_lock", ")", ";", "privload_init_search_paths", "()", ";", "#", "ifndef", "STATIC_LIBRARY", "/*", "insert", "libdynamorio.so", "*/", "mod", "=", "privload_insert", "(", "NULL", ",", "get_dynamorio_dll_start", "()", ",", "get_dynamorio_dll_end", "()", "-", "get_dynamorio_dll_start", "()", ",", "get_shared_lib_name", "(", "get_dynamorio_dll_start", "()", ")", ",", "get_dynamorio_library_path", "()", ")", ";", "ASSERT", "(", "mod", "!=", "NULL", ")", ";", "/*", "If", "DR", "was", "loaded", "by", "system", "ld.so,", "then", ".dynamic", "*was*", "relocated", "(i#1589)", "*/", "privload_create_os_privmod_data", "(", "mod", ",", "!", "DYNAMO_OPTION", "(", "early_inject", ")", ")", ";", "libdr_opd", "=", "(", "os_privmod_data_t", "*", ")", "mod", "->", "os_privmod_data", ";", "DODEBUG", "(", "{", "if", "(DYNAMO_OPTION(early_inject))", "{", "/*", "We\\'ve", "already", "filled", "the", "gap", "in", "dynamorio_lib_gap_empty().", "We", "just", "*", "verify", "here", "now", "that", "we", "have", "segment", "info.", "*/", "int", "i;", "for", "(i", "=", "0", ";", "i", "<", "libdr_opd->os_data.num_segments", "-", "1", ";", "i++)", "{", "size_t", "sz", "=", "libdr_opd->os_data.segments[i", "+", "1", "].start", "-", "libdr_opd->os_data.segments[i].end;", "if", "(sz", ">", "0", ")", "{", "dr_mem_info_t", "info;", "bool", "ok", "=", "query_memory_ex_from_os(libdr_opd->os_data.segments[i].end,", "&info);", "ASSERT(ok);", "ASSERT(info.base_pc", "==", "libdr_opd->os_data.segments[i].end", "&&", "info.size", "==", "sz", "&&", "(info.type", "==", "DR_MEMTYPE_FREE", "||", "/*", "If", "we", "reloaded", "DR,", "our", "own", "loader", "filled", "it", "in.", "*/", "info.prot", "==", "DR_MEMPROT_NONE));", "}", "}", "}", "}", ")", ";", "mod", "->", "externally_loaded", "=", "true", ";", "#", "if", "defined", "(", "LINUX", ")", "/*i#1285*/", "&&", "(", "defined", "(", "INTERNAL", ")", "||", "defined", "(", "CLIENT_INTERFACE", ")", ")", "if", "(", "DYNAMO_OPTION", "(", "early_inject", ")", ")", "{", "/*", "libdynamorio", "isn\\'t", "visible", "to", "gdb", "so", "add", "to", "the", "cmd", "list", "*/", "byte", "*", "dr_base", "=", "get_dynamorio_dll_start", "()", ",", "<type", "ref=\"prev\">", "*", "pref_base", ";", "elf_loader_t", "dr_ld", ";", "IF_DEBUG", "(", "bool", "success", "=", ")", "elf_loader_read_headers", "(", "&", "dr_ld", ",", "get_dynamorio_library_path", "()", ")", ";", "ASSERT", "(", "success", ")", ";", "module_walk_program_headers", "(", "dr_base", ",", "get_dynamorio_dll_end", "()", "-", "dr_base", ",", "false", ",", "false", ",", "(", "byte", "*", "*", ")", "&", "pref_base", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", ";", "dr_ld", ".", "load_delta", "=", "dr_base", "-", "pref_base", ";", "privload_add_gdb_cmd", "(", "&", "dr_ld", ",", "get_dynamorio_library_path", "()", ",", "false", "<comment_type=\"block\"", "format=\"doxygen\">", "/*!reach*/", ")", ";", "elf_loader_destroy", "(", "&", "dr_ld", ")", ";", "}", "#", "endif", "#", "endif", "}'" ]

[ "These", "are", "called", "before", "loader_init", "for", "the", "primary", "thread", "for", "UNIX" ]

[ "'void", "os_loader_thread_init_prologue", "(", "dcontext_t", "*", "dcontext", ")", "{", "/*", "do", "nothing", "*/", "}'" ]

[ "Entry", "point", "for", "ptrace", "injection" ]

[ "'static", "void", "takeover_ptrace", "(", "ptrace_stack_args_t", "*", "args", ")", "{", "static", "char", "home_var", "[", "MAXIMUM_PATH", "+", "6", "/*HOME=path\\\\0*/", "]", ";", "static", "char", "*", "fake_envp", "[]", "=", "{", "home_var", ",", "NULL", "}", ";", "/*", "When", "we", "come", "in", "via", "ptrace,", "we", "have", "no", "idea", "where", "the", "environment", "*", "pointer", "is.", "We", "could", "use", "/proc/self/environ", "to", "read", "it", "or", "go", "searching", "*", "near", "the", "stack", "base.", "However,", "both", "are", "fragile", "and", "we", "don\\'t", "really", "need", "*", "the", "environment", "for", "anything", "except", "for", "option", "passing.", "In", "the", "initial", "*", "ptraced", "process,", "we", "can", "assume", "our", "options", "are", "in", "a", "config", "file", "and", "not", "*", "the", "environment,", "so", "we", "just", "set", "an", "environment", "with", "HOME.", "*/", "snprintf", "(", "home_var", ",", "BUFFER_SIZE_ELEMENTS", "(", "home_var", ")", ",", "\"HOME=%s\"", ",", "args", "->", "home_dir", ")", ";", "NULL_TERMINATE_BUFFER", "(", "home_var", ")", ";", "dynamorio_set_envp", "(", "fake_envp", ")", ";", "dynamorio_app_init", "()", ";", "/*", "FIXME", "i#37:", "takeover", "other", "threads", "*/", "/*", "We", "need", "to", "wait", "until", "dr_inject_process_run()", "is", "called", "to", "finish", "*", "takeover,", "and", "this", "is", "an", "easy", "way", "to", "stop", "and", "return", "control", "to", "the", "*", "injector.", "*/", "dynamorio_syscall", "(", "SYS_kill", ",", "2", ",", "get_process_id", "()", ",", "SIGTRAP", ")", ";", "dynamo_start", "(", "&", "args", "->", "mc", ")", ";", "}'" ]

[ "Deallocate", "some", "range", "of", "memory", "and", "mark", "the", "pages", "as", "free" ]

[ "'int", "cgc_deallocate", "(", "void", "*", "addr", ",", "cgc_size_t", "length", ")", "{", "const", "int", "ret", "=", "munmap", "(", "addr", ",", "length", ")", ";", "if", "(", "ret", "<", "0", ")", "{", "return", "errno", ";", "}", "return", "0", ";", "}'" ]

[ "Transmits", "data", "from", "one", "CGC", "process", "to", "another" ]

[ "'int", "cgc_transmit", "(", "int", "fd", ",", "const", "void", "*", "buf", ",", "cgc_size_t", "count", ",", "cgc_size_t", "*", "tx_bytes", ")", "{", "const", "cgc_ssize_t", "ret", "=", "write", "(", "fd", ",", "buf", ",", "count", ")", ";", "if", "(", "ret", "<", "0", ")", "{", "return", "errno", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "tx_bytes", "!=", "NULL", ")", "{", "*", "tx_bytes", "=", "ret", ";", "}", "return", "0", ";", "}'" ]

[ "Marshal", "an", "OS", "fd", "set", "into", "a", "CGC", "fd", "set" ]

[ "'static", "void", "cgc_copy_os_fd_set", "(", "const", "fd_set", "*", "os_fds", ",", "cgc_fd_set", "*", "cgc_fds", ")", "{", "for", "(", "unsigned", "fd", "=", "0", ";", "fd", "<", "MIN", "(", "NFDBITS", ",", "CGC__NFDBITS", ")", ";", "++", "fd", ")", "{", "if", "(", "FD_ISSET", "(", "fd", ",", "os_fds", ")", ")", "{", "CGC_FD_SET", "(", "fd", ",", "cgc_fds", ")", ";", "}", "}", "}'" ]

[ "Marshal", "a", "CGC", "fd", "set", "into", "an", "OS", "fd", "set" ]

[ "\"static", "int", "cgc_copy_cgc_fd_set", "(", "const", "cgc_fd_set", "*", "cgc_fds", ",", "fd_set", "*", "os_fds", ",", "int", "*", "num_fds", ")", "{", "for", "(", "unsigned", "fd", "=", "0", ";", "fd", "<", "CGC__NFDBITS", ";", "++", "fd", ")", "{", "if", "(", "CGC_FD_ISSET", "(", "fd", ",", "cgc_fds", ")", ")", "{", "//", "Shouldn't", "be", "using", "an", "fd", "greater", "than", "the", "allowed", "values", "if", "(", "fd", ">=", "EXPECTED_MAX_FDS", ")", "{", "return", "CGC_EBADF", ";", "}", "if", "(", "fd", ">", "NFDBITS", ")", "{", "continue;", "/*", "OS", "set", "size", "is", "too", "small.", "*/", "}", "FD_SET", "(", "fd", ",", "os_fds", ")", ";", "++", "*", "num_fds", ";", "}", "}", "return", "0", ";", "}\"" ]

[ "Function", "for", "notifying", "request", "observers" ]

[ "'static", "ret_code_t", "sdh_request_observer_notify", "(", "nrf_sdh_req_evt_t", "req", ")", "{", "nrf_section_iter_t", "iter", ";", "NRF_LOG_DEBUG", "(", "\"State", "request:", "0x%08X\"", ",", "req", ")", ";", "for", "(", "nrf_section_iter_init", "(", "&", "iter", ",", "&", "sdh_req_observers", ")", ";", "nrf_section_iter_get", "(", "&", "iter", ")", "!=", "NULL", ";", "nrf_section_iter_next", "(", "&", "iter", ")", ")", "{", "nrf_sdh_req_observer_t", "*", "p_observer", ";", "nrf_sdh_req_evt_handler_t", "handler", ";", "p_observer", "=", "(", "nrf_sdh_req_observer_t", "*", ")", "nrf_section_iter_get", "(", "&", "iter", ")", ";", "handler", "=", "p_observer", "->", "handler", ";", "if", "(", "handler", "(", "req", ",", "p_observer", "->", "p_context", ")", ")", "{", "NRF_LOG_DEBUG", "(", "\"Notify", "observer", "0x%08X", "=>", "ready\"", ",", "p_observer", ")", ";", "}", "else", "{", "//", "Process", "is", "stopped.", "NRF_LOG_DEBUG", "(", "\"Notify", "observer", "0x%08X", "=>", "blocking\"", ",", "p_observer", ")", ";", "return", "NRF_ERROR_BUSY", ";", "}", "}", "return", "NRF_SUCCESS", ";", "}'" ]

[ "Function", "for", "polling", "SoftDevice", "events" ]

[ "'static", "void", "appsh_events_poll", "(", "void", "*", "p_event_data", ",", "uint16_t", "event_size", ")", "{", "UNUSED_PARAMETER", "(", "p_event_data", ")", ";", "UNUSED_PARAMETER", "(", "event_size", ")", ";", "nrf_sdh_evts_poll", "()", ";", "}'" ]

[ "Function", "for", "stage", "request", "observers" ]

[ "'static", "void", "sdh_state_observer_notify", "(", "nrf_sdh_state_evt_t", "evt", ")", "{", "nrf_section_iter_t", "iter", ";", "NRF_LOG_DEBUG", "(", "\"State", "change:", "0x%08X\"", ",", "evt", ")", ";", "for", "(", "nrf_section_iter_init", "(", "&", "iter", ",", "&", "sdh_state_observers", ")", ";", "nrf_section_iter_get", "(", "&", "iter", ")", "!=", "NULL", ";", "nrf_section_iter_next", "(", "&", "iter", ")", ")", "{", "nrf_sdh_state_observer_t", "*", "p_observer", ";", "nrf_sdh_state_evt_handler_t", "handler", ";", "p_observer", "=", "(", "nrf_sdh_state_observer_t", "*", ")", "nrf_section_iter_get", "(", "&", "iter", ")", ";", "handler", "=", "p_observer", "->", "handler", ";", "handler", "(", "evt", ",", "p_observer", "->", "p_context", ")", ";", "}", "}'" ]

[ "Configures", "the", "analog", "watchdog", "3", "guarded", "single", "channel" ]

[ "'void", "ADC_AnalogWatchdog3SingleChannelConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "ADC_Channel", ")", "{", "uint32_t", "tmpreg", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_CHANNEL", "(", "ADC_Channel", ")", ")", ";", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg", "=", "ADCx", "->", "AWD3CR", ";", "/*", "Clear", "the", "Analog", "watchdog", "channel", "select", "bits", "*/", "tmpreg", "&=", "~", "(", "uint32_t", ")", "ADC_AWD3CR_AWD3CH", ";", "/*", "Set", "the", "Analog", "watchdog", "channel", "*/", "tmpreg", "|=", "(", "uint32_t", ")", "1", "<<", "(", "ADC_Channel", ")", ";", "/*", "Store", "the", "new", "register", "value", "*/", "ADCx", "->", "AWD3CR", "|=", "tmpreg", ";", "}'" ]

[ "Configures", "the", "analog", "watchdog", "2", "guarded", "single", "channel" ]

[ "'void", "ADC_AnalogWatchdog2SingleChannelConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "ADC_Channel", ")", "{", "uint32_t", "tmpreg", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_CHANNEL", "(", "ADC_Channel", ")", ")", ";", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg", "=", "ADCx", "->", "AWD2CR", ";", "/*", "Clear", "the", "Analog", "watchdog", "channel", "select", "bits", "*/", "tmpreg", "&=", "~", "(", "uint32_t", ")", "ADC_AWD2CR_AWD2CH", ";", "/*", "Set", "the", "Analog", "watchdog", "channel", "*/", "tmpreg", "|=", "(", "uint32_t", ")", "1", "<<", "(", "ADC_Channel", ")", ";", "/*", "Store", "the", "new", "register", "value", "*/", "ADCx", "->", "AWD2CR", "|=", "tmpreg", ";", "}'" ]

[ "Clears", "the", "ADCx's", "interrupt", "pending", "bits" ]

[ "'void", "ADC_ClearITPendingBit", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint32_t", "ADC_IT", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_IT", "(", "ADC_IT", ")", ")", ";", "/*", "Clear", "the", "selected", "ADC", "interrupt", "pending", "bit", "*/", "ADCx", "->", "ISR", "=", "(", "uint32_t", ")", "ADC_IT", ";", "}'" ]

[ "Returns", "the", "last", "ADC1,", "ADC2,", "ADC3", "and", "ADC4", "regular", "conversions", "results" ]

[ "'uint32_t", "ADC_GetDualModeConversionValue", "(", "ADC_TypeDef", "*", "ADCx", ")", "{", "uint32_t", "tmpreg1", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "if", "(", "(", "ADCx", "==", "ADC1", ")", "||", "(", "ADCx", "==", "ADC2", ")", ")", "{", "/*", "Get", "the", "dual", "mode", "conversion", "value", "*/", "tmpreg1", "=", "ADC1_2", "->", "CDR", ";", "}", "else", "{", "/*", "Get", "the", "dual", "mode", "conversion", "value", "*/", "tmpreg1", "=", "ADC3_4", "->", "CDR", ";", "}", "/*", "Return", "the", "dual", "mode", "conversion", "value", "*/", "return", "(", "uint32_t", ")", "tmpreg1", ";", "}'" ]

[ "Checks", "whether", "the", "specified", "ADC", "flag", "is", "set", "or", "not" ]

[ "'FlagStatus", "ADC_GetCommonFlagStatus", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint32_t", "ADC_FLAG", ")", "{", "uint32_t", "tmpreg1", "=", "0", ";", "FlagStatus", "bitstatus", "=", "RESET", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_GET_COMMONFLAG", "(", "ADC_FLAG", ")", ")", ";", "if", "(", "(", "ADCx", "==", "ADC1", ")", "||", "(", "ADCx", "==", "ADC2", ")", ")", "{", "tmpreg1", "=", "ADC1_2", "->", "CSR", ";", "}", "else", "{", "tmpreg1", "=", "ADC3_4", "->", "CSR", ";", "}", "/*", "Check", "the", "status", "of", "the", "specified", "ADC", "flag", "*/", "if", "(", "(", "tmpreg1", "&", "ADC_FLAG", ")", "!=", "(", "uint32_t", ")", "RESET", ")", "{", "/*", "ADC_FLAG", "is", "set", "*/", "bitstatus", "=", "SET", ";", "}", "else", "{", "/*", "ADC_FLAG", "is", "reset", "*/", "bitstatus", "=", "RESET", ";", "}", "/*", "Return", "the", "ADC_FLAG", "status", "*/", "return", "bitstatus", ";", "}'" ]

[ "Initialization", "and", "Configuration", "functions" ]

[ "'void", "ADC_DeInit", "(", "ADC_TypeDef", "*", "ADCx", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "if", "(", "(", "ADCx", "==", "ADC1", ")", "||", "(", "ADCx", "==", "ADC2", ")", ")", "{", "/*", "Enable", "ADC1/ADC2", "reset", "state", "*/", "RCC_AHBPeriphResetCmd", "(", "RCC_AHBPeriph_ADC12", ",", "ENABLE", ")", ";", "/*", "Release", "ADC1/ADC2", "from", "reset", "state", "*/", "RCC_AHBPeriphResetCmd", "(", "RCC_AHBPeriph_ADC12", ",", "DISABLE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "ADCx", "==", "ADC3", ")", "||", "(", "ADCx", "==", "ADC4", ")", ")", "{", "/*", "Enable", "ADC3/ADC4", "reset", "state", "*/", "RCC_AHBPeriphResetCmd", "(", "RCC_AHBPeriph_ADC34", ",", "ENABLE", ")", ";", "/*", "Release", "ADC3/ADC4", "from", "reset", "state", "*/", "RCC_AHBPeriphResetCmd", "(", "RCC_AHBPeriph_ADC34", ",", "DISABLE", ")", ";", "}", "}'" ]

[ "Regular", "Channels", "Configuration", "functions" ]

[ "'void", "ADC_RegularChannelConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "ADC_Channel", ",", "uint8_t", "Rank", ",", "uint8_t", "ADC_SampleTime", ")", "{", "uint32_t", "tmpreg1", "=", "0", ",", "<type", "ref=\"prev\"/>", "tmpreg2", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_CHANNEL", "(", "ADC_Channel", ")", ")", ";", "assert_param", "(", "IS_ADC_SAMPLE_TIME", "(", "ADC_SampleTime", ")", ")", ";", "/*", "Regular", "sequence", "configuration", "*/", "/*", "For", "Rank", "1", "to", "4", "*/", "if", "(", "Rank", "<", "5", ")", "{", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg1", "=", "ADCx", "->", "SQR1", ";", "/*", "Calculate", "the", "mask", "to", "clear", "*/", "tmpreg2", "=", "0x1F", "<<", "(", "6", "*", "(", "Rank", ")", ")", ";", "/*", "Clear", "the", "old", "SQx", "bits", "for", "the", "selected", "rank", "*/", "tmpreg1", "&=", "~", "tmpreg2", ";", "/*", "Calculate", "the", "mask", "to", "set", "*/", "tmpreg2", "=", "(", "uint32_t", ")", "(", "ADC_Channel", ")", "<<", "(", "6", "*", "(", "Rank", ")", ")", ";", "/*", "Set", "the", "SQx", "bits", "for", "the", "selected", "rank", "*/", "tmpreg1", "|=", "tmpreg2", ";", "/*", "Store", "the", "new", "register", "value", "*/", "ADCx", "->", "SQR1", "=", "tmpreg1", ";", "}", "/*", "For", "Rank", "5", "to", "9", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "Rank", "<", "10", ")", "{", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg1", "=", "ADCx", "->", "SQR2", ";", "/*", "Calculate", "the", "mask", "to", "clear", "*/", "tmpreg2", "=", "ADC_SQR2_SQ5", "<<", "(", "6", "*", "(", "Rank", "-", "5", ")", ")", ";", "/*", "Clear", "the", "old", "SQx", "bits", "for", "the", "selected", "rank", "*/", "tmpreg1", "&=", "~", "tmpreg2", ";", "/*", "Calculate", "the", "mask", "to", "set", "*/", "tmpreg2", "=", "(", "uint32_t", ")", "(", "ADC_Channel", ")", "<<", "(", "6", "*", "(", "Rank", "-", "5", ")", ")", ";", "/*", "Set", "the", "SQx", "bits", "for", "the", "selected", "rank", "*/", "tmpreg1", "|=", "tmpreg2", ";", "/*", "Store", "the", "new", "register", "value", "*/", "ADCx", "->", "SQR2", "=", "tmpreg1", ";", "}", "/*", "For", "Rank", "10", "to", "14", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "Rank", "<", "15", ")", "{", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg1", "=", "ADCx", "->", "SQR3", ";", "/*", "Calculate", "the", "mask", "to", "clear", "*/", "tmpreg2", "=", "ADC_SQR3_SQ10", "<<", "(", "6", "*", "(", "Rank", "-", "10", ")", ")", ";", "/*", "Clear", "the", "old", "SQx", "bits", "for", "the", "selected", "rank", "*/", "tmpreg1", "&=", "~", "tmpreg2", ";", "/*", "Calculate", "the", "mask", "to", "set", "*/", "tmpreg2", "=", "(", "uint32_t", ")", "(", "ADC_Channel", ")", "<<", "(", "6", "*", "(", "Rank", "-", "10", ")", ")", ";", "/*", "Set", "the", "SQx", "bits", "for", "the", "selected", "rank", "*/", "tmpreg1", "|=", "tmpreg2", ";", "/*", "Store", "the", "new", "register", "value", "*/", "ADCx", "->", "SQR3", "=", "tmpreg1", ";", "}", "else", "{", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg1", "=", "ADCx", "->", "SQR4", ";", "/*", "Calculate", "the", "mask", "to", "clear", "*/", "tmpreg2", "=", "ADC_SQR3_SQ15", "<<", "(", "6", "*", "(", "Rank", "-", "15", ")", ")", ";", "/*", "Clear", "the", "old", "SQx", "bits", "for", "the", "selected", "rank", "*/", "tmpreg1", "&=", "~", "tmpreg2", ";", "/*", "Calculate", "the", "mask", "to", "set", "*/", "tmpreg2", "=", "(", "uint32_t", ")", "(", "ADC_Channel", ")", "<<", "(", "6", "*", "(", "Rank", "-", "15", ")", ")", ";", "/*", "Set", "the", "SQx", "bits", "for", "the", "selected", "rank", "*/", "tmpreg1", "|=", "tmpreg2", ";", "/*", "Store", "the", "new", "register", "value", "*/", "ADCx", "->", "SQR4", "=", "tmpreg1", ";", "}", "/*", "Channel", "sampling", "configuration", "*/", "/*", "if", "ADC_Channel_10", "...", "ADC_Channel_18", "is", "selected", "*/", "if", "(", "ADC_Channel", ">", "ADC_Channel_9", ")", "{", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg1", "=", "ADCx", "->", "SMPR2", ";", "/*", "Calculate", "the", "mask", "to", "clear", "*/", "tmpreg2", "=", "ADC_SMPR2_SMP10", "<<", "(", "3", "*", "(", "ADC_Channel", "-", "10", ")", ")", ";", "/*", "Clear", "the", "old", "channel", "sample", "time", "*/", "ADCx", "->", "SMPR2", "&=", "~", "tmpreg2", ";", "/*", "Calculate", "the", "mask", "to", "set", "*/", "ADCx", "->", "SMPR2", "|=", "(", "uint32_t", ")", "ADC_SampleTime", "<<", "(", "3", "*", "(", "ADC_Channel", "-", "10", ")", ")", ";", "}", "else", "/*", "ADC_Channel", "include", "in", "ADC_Channel_[0..9]", "*/", "{", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg1", "=", "ADCx", "->", "SMPR1", ";", "/*", "Calculate", "the", "mask", "to", "clear", "*/", "tmpreg2", "=", "ADC_SMPR1_SMP1", "<<", "(", "3", "*", "(", "ADC_Channel", "-", "1", ")", ")", ";", "/*", "Clear", "the", "old", "channel", "sample", "time", "*/", "ADCx", "->", "SMPR1", "&=", "~", "tmpreg2", ";", "/*", "Calculate", "the", "mask", "to", "set", "*/", "ADCx", "->", "SMPR1", "|=", "(", "uint32_t", ")", "ADC_SampleTime", "<<", "(", "3", "*", "(", "ADC_Channel", ")", ")", ";", "}", "}'" ]

[ "Clears", "the", "ADCx's", "pending", "flags" ]

[ "'void", "ADC_ClearFlag", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint32_t", "ADC_FLAG", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_CLEAR_FLAG", "(", "ADC_FLAG", ")", ")", ";", "/*", "Clear", "the", "selected", "ADC", "flags", "*/", "ADCx", "->", "ISR", "=", "(", "uint32_t", ")", "ADC_FLAG", ";", "}'" ]

[ "Stops", "the", "selected", "ADC", "ongoing", "injected", "conversion" ]

[ "'void", "ADC_StopInjectedConversion", "(", "ADC_TypeDef", "*", "ADCx", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "/*", "Set", "the", "JADSTP", "bit", "*/", "ADCx", "->", "CR", "|=", "ADC_CR_JADSTP", ";", "}'" ]

[ "Configures", "the", "discontinuous", "mode", "for", "the", "selected", "ADC", "regular" ]

[ "'void", "ADC_DiscModeChannelCountConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "Number", ")", "{", "uint32_t", "tmpreg1", "=", "0", ";", "uint32_t", "tmpreg2", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_REGULAR_DISC_NUMBER", "(", "Number", ")", ")", ";", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg1", "=", "ADCx", "->", "CFGR", ";", "/*", "Clear", "the", "old", "discontinuous", "mode", "channel", "count", "*/", "tmpreg1", "&=", "~", "(", "uint32_t", ")", "(", "ADC_CFGR_DISCNUM", ")", ";", "/*", "Set", "the", "discontinuous", "mode", "channel", "count", "*/", "tmpreg2", "=", "Number", "-", "1", ";", "tmpreg1", "|=", "tmpreg2", "<<", "17", ";", "/*", "Store", "the", "new", "register", "value", "*/", "ADCx", "->", "CFGR", "=", "tmpreg1", ";", "}'" ]

[ "Initializes", "the", "ADCx", "peripheral", "according", "to", "the", "specified", "parameters" ]

[ "'void", "ADC_Init", "(", "ADC_TypeDef", "*", "ADCx", ",", "ADC_InitTypeDef", "*", "ADC_InitStruct", ")", "{", "uint32_t", "tmpreg1", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_CONVMODE", "(", "ADC_InitStruct", "->", "ADC_ContinuousConvMode", ")", ")", ";", "assert_param", "(", "IS_ADC_RESOLUTION", "(", "ADC_InitStruct", "->", "ADC_Resolution", ")", ")", ";", "assert_param", "(", "IS_ADC_EXT_TRIG", "(", "ADC_InitStruct", "->", "ADC_ExternalTrigConvEvent", ")", ")", ";", "assert_param", "(", "IS_EXTERNALTRIG_EDGE", "(", "ADC_InitStruct", "->", "ADC_ExternalTrigEventEdge", ")", ")", ";", "assert_param", "(", "IS_ADC_DATA_ALIGN", "(", "ADC_InitStruct", "->", "ADC_DataAlign", ")", ")", ";", "assert_param", "(", "IS_ADC_OVRUNMODE", "(", "ADC_InitStruct", "->", "ADC_OverrunMode", ")", ")", ";", "assert_param", "(", "IS_ADC_AUTOINJECMODE", "(", "ADC_InitStruct", "->", "ADC_AutoInjMode", ")", ")", ";", "assert_param", "(", "IS_ADC_REGULAR_LENGTH", "(", "ADC_InitStruct", "->", "ADC_NbrOfRegChannel", ")", ")", ";", "/*----------------------------", "ADCx", "CFGR", "Configuration", "-----------------*/", "/*", "Get", "the", "ADCx", "CFGR", "value", "*/", "tmpreg1", "=", "ADCx", "->", "CFGR", ";", "/*", "Clear", "SCAN", "bit", "*/", "tmpreg1", "&=", "CFGR_CLEAR_Mask", ";", "/*", "Configure", "ADCx:", "scan", "conversion", "mode", "*/", "/*", "Set", "SCAN", "bit", "according", "to", "ADC_ScanConvMode", "value", "*/", "tmpreg1", "|=", "(", "uint32_t", ")", "ADC_InitStruct", "->", "ADC_ContinuousConvMode", "|", "ADC_InitStruct", "->", "ADC_Resolution", "|", "ADC_InitStruct", "->", "ADC_ExternalTrigConvEvent", "|", "ADC_InitStruct", "->", "ADC_ExternalTrigEventEdge", "|", "ADC_InitStruct", "->", "ADC_DataAlign", "|", "ADC_InitStruct", "->", "ADC_OverrunMode", "|", "ADC_InitStruct", "->", "ADC_AutoInjMode", ";", "/*", "Write", "to", "ADCx", "CFGR", "*/", "ADCx", "->", "CFGR", "=", "tmpreg1", ";", "/*----------------------------", "ADCx", "SQR1", "Configuration", "-----------------*/", "/*", "Get", "the", "ADCx", "SQR1", "value", "*/", "tmpreg1", "=", "ADCx", "->", "SQR1", ";", "/*", "Clear", "L", "bits", "*/", "tmpreg1", "&=", "~", "(", "uint32_t", ")", "(", "ADC_SQR1_L", ")", ";", "/*", "Configure", "ADCx:", "regular", "channel", "sequence", "length", "*/", "/*", "Set", "L", "bits", "according", "to", "ADC_NbrOfRegChannel", "value", "*/", "tmpreg1", "|=", "(", "uint32_t", ")", "(", "ADC_InitStruct", "->", "ADC_NbrOfRegChannel", "-", "1", ")", ";", "/*", "Write", "to", "ADCx", "SQR1", "*/", "ADCx", "->", "SQR1", "=", "tmpreg1", ";", "}'" ]

[ "Initializes", "the", "ADCs", "peripherals", "according", "to", "the", "specified", "parameters" ]

[ "'void", "ADC_CommonInit", "(", "ADC_TypeDef", "*", "ADCx", ",", "ADC_CommonInitTypeDef", "*", "ADC_CommonInitStruct", ")", "{", "uint32_t", "tmpreg1", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_MODE", "(", "ADC_CommonInitStruct", "->", "ADC_Mode", ")", ")", ";", "assert_param", "(", "IS_ADC_CLOCKMODE", "(", "ADC_CommonInitStruct", "->", "ADC_Clock", ")", ")", ";", "assert_param", "(", "IS_ADC_DMA_MODE", "(", "ADC_CommonInitStruct", "->", "ADC_DMAMode", ")", ")", ";", "assert_param", "(", "IS_ADC_DMA_ACCESS_MODE", "(", "ADC_CommonInitStruct", "->", "ADC_DMAAccessMode", ")", ")", ";", "assert_param", "(", "IS_ADC_TWOSAMPLING_DELAY", "(", "ADC_CommonInitStruct", "->", "ADC_TwoSamplingDelay", ")", ")", ";", "if", "(", "(", "ADCx", "==", "ADC1", ")", "||", "(", "ADCx", "==", "ADC2", ")", ")", "{", "/*", "Get", "the", "ADC", "CCR", "value", "*/", "tmpreg1", "=", "ADC1_2", "->", "CCR", ";", "/*", "Clear", "MULTI,", "DELAY,", "DMA", "and", "ADCPRE", "bits", "*/", "tmpreg1", "&=", "CCR_CLEAR_MASK", ";", "}", "else", "{", "/*", "Get", "the", "ADC", "CCR", "value", "*/", "tmpreg1", "=", "ADC3_4", "->", "CCR", ";", "/*", "Clear", "MULTI,", "DELAY,", "DMA", "and", "ADCPRE", "bits", "*/", "tmpreg1", "&=", "CCR_CLEAR_MASK", ";", "}", "/*----------------------------", "ADC", "CCR", "Configuration", "-----------------*/", "/*", "Configure", "ADCx:", "Multi", "mode,", "Delay", "between", "two", "sampling", "time,", "ADC", "clock,", "DMA", "mode", "and", "DMA", "access", "mode", "for", "dual", "mode", "*/", "/*", "Set", "MULTI", "bits", "according", "to", "ADC_Mode", "value", "*/", "/*", "Set", "CKMODE", "bits", "according", "to", "ADC_Clock", "value", "*/", "/*", "Set", "MDMA", "bits", "according", "to", "ADC_DMAAccessMode", "value", "*/", "/*", "Set", "DMACFG", "bits", "according", "to", "ADC_DMAMode", "value", "*/", "/*", "Set", "DELAY", "bits", "according", "to", "ADC_TwoSamplingDelay", "value", "*/", "tmpreg1", "|=", "(", "uint32_t", ")", "(", "ADC_CommonInitStruct", "->", "ADC_Mode", "|", "ADC_CommonInitStruct", "->", "ADC_Clock", "|", "ADC_CommonInitStruct", "->", "ADC_DMAAccessMode", "|", "(", "uint32_t", ")", "(", "ADC_CommonInitStruct", "->", "ADC_DMAMode", "<<", "12", ")", "|", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "ADC_CommonInitStruct", "->", "ADC_TwoSamplingDelay", "<<", "8", ")", ")", ";", "if", "(", "(", "ADCx", "==", "ADC1", ")", "||", "(", "ADCx", "==", "ADC2", ")", ")", "{", "/*", "Write", "to", "ADC", "CCR", "*/", "ADC1_2", "->", "CCR", "=", "tmpreg1", ";", "}", "else", "{", "/*", "Write", "to", "ADC", "CCR", "*/", "ADC3_4", "->", "CCR", "=", "tmpreg1", ";", "}", "}'" ]

[ "Set", "the", "ADC", "channels", "conversion", "value", "offset1" ]

[ "'void", "ADC_SetChannelOffset1", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "ADC_Channel", ",", "uint16_t", "Offset", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_CHANNEL", "(", "ADC_Channel", ")", ")", ";", "assert_param", "(", "IS_ADC_OFFSET", "(", "Offset", ")", ")", ";", "/*", "Select", "the", "Channel", "*/", "ADCx", "->", "OFR1", "&=", "~", "(", "uint32_t", ")", "ADC_OFR1_OFFSET1_CH", ";", "ADCx", "->", "OFR1", "|=", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "ADC_Channel", "<<", "26", ")", ";", "/*", "Set", "the", "data", "offset", "*/", "ADCx", "->", "OFR1", "&=", "~", "(", "uint32_t", ")", "ADC_OFR1_OFFSET1", ";", "ADCx", "->", "OFR1", "|=", "(", "uint32_t", ")", "Offset", ";", "}'" ]

[ "Enables", "or", "disables", "the", "specified", "ADC", "Voltage", "Regulator" ]

[ "'void", "ADC_VoltageRegulatorCmd", "(", "ADC_TypeDef", "*", "ADCx", ",", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "/*", "set", "the", "intermediate", "state", "before", "moving", "the", "ADC", "voltage", "regulator", "from", "enable", "state", "to", "disable", "state", "or", "from", "disable", "state", "to", "enable", "state", "*/", "ADCx", "->", "CR", "&=", "~", "(", "ADC_CR_ADVREGEN", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "/*", "Set", "the", "ADVREGEN", "bit", "0", "*/", "ADCx", "->", "CR", "|=", "ADC_CR_ADVREGEN_0", ";", "}", "else", "{", "/*", "Set", "the", "ADVREGEN", "bit", "1", "*/", "ADCx", "->", "CR", "|=", "ADC_CR_ADVREGEN_1", ";", "}", "}'" ]

[ "Sets", "the", "ADCx", "calibration", "register" ]

[ "'void", "ADC_SetCalibrationValue", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint32_t", "ADC_Calibration", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "/*", "Set", "the", "ADC", "calibration", "register", "value", "*/", "ADCx", "->", "CALFACT", "=", "ADC_Calibration", ";", "}'" ]

[ "Injected", "channels", "Configuration", "functions" ]

[ "'void", "ADC_InjectedChannelSampleTimeConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "ADC_InjectedChannel", ",", "uint8_t", "ADC_SampleTime", ")", "{", "uint32_t", "tmpreg1", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_INJECTED_CHANNEL", "(", "ADC_InjectedChannel", ")", ")", ";", "assert_param", "(", "IS_ADC_SAMPLE_TIME", "(", "ADC_SampleTime", ")", ")", ";", "/*", "Channel", "sampling", "configuration", "*/", "/*", "if", "ADC_InjectedChannel_10", "...", "ADC_InjectedChannel_18", "is", "selected", "*/", "if", "(", "ADC_InjectedChannel", ">", "ADC_InjectedChannel_9", ")", "{", "/*", "Calculate", "the", "mask", "to", "clear", "*/", "tmpreg1", "=", "ADC_SMPR2_SMP10", "<<", "(", "3", "*", "(", "ADC_InjectedChannel", "-", "10", ")", ")", ";", "/*", "Clear", "the", "old", "channel", "sample", "time", "*/", "ADCx", "->", "SMPR2", "&=", "~", "tmpreg1", ";", "/*", "Calculate", "the", "mask", "to", "set", "*/", "ADCx", "->", "SMPR2", "|=", "(", "uint32_t", ")", "ADC_SampleTime", "<<", "(", "3", "*", "(", "ADC_InjectedChannel", "-", "10", ")", ")", ";", "}", "else", "/*", "ADC_InjectedChannel", "include", "in", "ADC_InjectedChannel_[0..9]", "*/", "{", "/*", "Calculate", "the", "mask", "to", "clear", "*/", "tmpreg1", "=", "ADC_SMPR1_SMP1", "<<", "(", "3", "*", "(", "ADC_InjectedChannel", "-", "1", ")", ")", ";", "/*", "Clear", "the", "old", "channel", "sample", "time", "*/", "ADCx", "->", "SMPR1", "&=", "~", "tmpreg1", ";", "/*", "Calculate", "the", "mask", "to", "set", "*/", "ADCx", "->", "SMPR1", "|=", "(", "uint32_t", ")", "ADC_SampleTime", "<<", "(", "3", "*", "(", "ADC_InjectedChannel", ")", ")", ";", "}", "}'" ]

[ "Configures", "the", "high", "and", "low", "thresholds", "of", "the", "analog", "watchdog1" ]

[ "'void", "ADC_AnalogWatchdog1ThresholdsConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint16_t", "HighThreshold", ",", "uint16_t", "LowThreshold", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_THRESHOLD", "(", "HighThreshold", ")", ")", ";", "assert_param", "(", "IS_ADC_THRESHOLD", "(", "LowThreshold", ")", ")", ";", "/*", "Set", "the", "ADCx", "high", "threshold", "*/", "ADCx", "->", "TR1", "&=", "~", "(", "uint32_t", ")", "ADC_TR1_HT1", ";", "ADCx", "->", "TR1", "|=", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "HighThreshold", "<<", "16", ")", ";", "/*", "Set", "the", "ADCx", "low", "threshold", "*/", "ADCx", "->", "TR1", "&=", "~", "(", "uint32_t", ")", "ADC_TR1_LT1", ";", "ADCx", "->", "TR1", "|=", "LowThreshold", ";", "}'" ]

[ "Fills", "each", "ADC_InitStruct", "member", "with", "its", "default", "value" ]

[ "'void", "ADC_StructInit", "(", "ADC_InitTypeDef", "*", "ADC_InitStruct", ")", "{", "/*", "Reset", "ADC", "init", "structure", "parameters", "values", "*/", "ADC_InitStruct", "->", "ADC_ContinuousConvMode", "=", "DISABLE", ";", "ADC_InitStruct", "->", "ADC_Resolution", "=", "ADC_Resolution_12b", ";", "ADC_InitStruct", "->", "ADC_ExternalTrigConvEvent", "=", "ADC_ExternalTrigConvEvent_0", ";", "ADC_InitStruct", "->", "ADC_ExternalTrigEventEdge", "=", "ADC_ExternalTrigEventEdge_None", ";", "ADC_InitStruct", "->", "ADC_DataAlign", "=", "ADC_DataAlign_Right", ";", "ADC_InitStruct", "->", "ADC_OverrunMode", "=", "DISABLE", ";", "ADC_InitStruct", "->", "ADC_AutoInjMode", "=", "DISABLE", ";", "ADC_InitStruct", "->", "ADC_NbrOfRegChannel", "=", "1", ";", "}'" ]

[ "Enables", "or", "disables", "the", "Vrefint", "channel" ]

[ "'void", "ADC_VrefintCmd", "(", "ADC_TypeDef", "*", "ADCx", ",", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "(", "ADCx", "==", "ADC1", ")", "||", "(", "ADCx", "==", "ADC2", ")", ")", "{", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "/*", "Enable", "the", "Vrefint", "channel*/", "ADC1_2", "->", "CCR", "|=", "ADC12_CCR_VREFEN", ";", "}", "else", "{", "/*", "Disable", "the", "Vrefint", "channel*/", "ADC1_2", "->", "CCR", "&=", "~", "(", "uint32_t", ")", "ADC12_CCR_VREFEN", ";", "}", "}", "else", "{", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "/*", "Enable", "the", "Vrefint", "channel*/", "ADC3_4", "->", "CCR", "|=", "ADC34_CCR_VREFEN", ";", "}", "else", "{", "/*", "Disable", "the", "Vrefint", "channel*/", "ADC3_4", "->", "CCR", "&=", "~", "(", "uint32_t", ")", "ADC34_CCR_VREFEN", ";", "}", "}", "}'" ]

[ "Enables", "or", "disables", "the", "selected", "ADC", "start", "of", "the", "injected" ]

[ "'void", "ADC_StartInjectedConversion", "(", "ADC_TypeDef", "*", "ADCx", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "/*", "Enable", "the", "selected", "ADC", "conversion", "for", "injected", "group", "on", "external", "event", "and", "start", "the", "selected", "ADC", "injected", "conversion", "*/", "ADCx", "->", "CR", "|=", "ADC_CR_JADSTART", ";", "}'" ]

[ "External", "Trigger", "Enable", "and", "Polarity", "Selection", "for", "regular", "channels" ]

[ "'void", "ADC_ExternalTriggerConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint16_t", "ADC_ExternalTrigConvEvent", ",", "uint16_t", "ADC_ExternalTrigEventEdge", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_EXT_TRIG", "(", "ADC_ExternalTrigConvEvent", ")", ")", ";", "assert_param", "(", "IS_EXTERNALTRIG_EDGE", "(", "ADC_ExternalTrigEventEdge", ")", ")", ";", "/*", "Disable", "the", "selected", "ADC", "conversion", "on", "external", "event", "*/", "ADCx", "->", "CFGR", "&=", "~", "(", "ADC_CFGR_EXTEN", "|", "ADC_CFGR_EXTSEL", ")", ";", "ADCx", "->", "CFGR", "|=", "(", "uint32_t", ")", "(", "ADC_ExternalTrigEventEdge", "|", "ADC_ExternalTrigConvEvent", ")", ";", "}'" ]

[ "Sets", "the", "ADC", "regular", "channel", "sequence", "lenght" ]

[ "'void", "ADC_RegularChannelSequencerLengthConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "SequencerLength", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "/*", "Configure", "the", "ADC", "sequence", "lenght", "*/", "ADCx", "->", "SQR1", "&=", "~", "(", "uint32_t", ")", "ADC_SQR1_L", ";", "ADCx", "->", "SQR1", "|=", "(", "uint32_t", ")", "(", "SequencerLength", "-", "1", ")", ";", "}'" ]

[ "Enables", "or", "disables", "the", "Offset1" ]

[ "'void", "ADC_ChannelOffset1Cmd", "(", "ADC_TypeDef", "*", "ADCx", ",", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "/*", "Set", "the", "OFFSET1_EN", "bit", "*/", "ADCx", "->", "OFR1", "|=", "ADC_OFR1_OFFSET1_EN", ";", "}", "else", "{", "/*", "Reset", "the", "OFFSET1_EN", "bit", "*/", "ADCx", "->", "OFR1", "&=", "~", "(", "ADC_OFR1_OFFSET1_EN", ")", ";", "}", "}'" ]

[ "Clears", "the", "ADCx's", "pending", "flags" ]

[ "'void", "ADC_ClearCommonFlag", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint32_t", "ADC_FLAG", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_CLEAR_COMMONFLAG", "(", "ADC_FLAG", ")", ")", ";", "if", "(", "(", "ADCx", "==", "ADC1", ")", "||", "(", "ADCx", "==", "ADC2", ")", ")", "{", "/*", "Clear", "the", "selected", "ADC", "flags", "*/", "ADC1_2", "->", "CSR", "|=", "(", "uint32_t", ")", "ADC_FLAG", ";", "}", "else", "{", "/*", "Clear", "the", "selected", "ADC", "flags", "*/", "ADC3_4", "->", "CSR", "|=", "(", "uint32_t", ")", "ADC_FLAG", ";", "}", "}'" ]

[ "Configures", "the", "high", "and", "low", "thresholds", "of", "the", "analog", "watchdog2" ]

[ "'void", "ADC_AnalogWatchdog2ThresholdsConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "HighThreshold", ",", "uint8_t", "LowThreshold", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "/*", "Set", "the", "ADCx", "high", "threshold", "*/", "ADCx", "->", "TR2", "&=", "~", "(", "uint32_t", ")", "ADC_TR2_HT2", ";", "ADCx", "->", "TR2", "|=", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "HighThreshold", "<<", "16", ")", ";", "/*", "Set", "the", "ADCx", "low", "threshold", "*/", "ADCx", "->", "TR2", "&=", "~", "(", "uint32_t", ")", "ADC_TR2_LT2", ";", "ADCx", "->", "TR2", "|=", "LowThreshold", ";", "}'" ]

[ "Configures", "the", "analog", "watchdog", "2", "guarded", "single", "channel" ]

[ "'void", "ADC_AnalogWatchdog1SingleChannelConfig", "(", "ADC_TypeDef", "*", "ADCx", ",", "uint8_t", "ADC_Channel", ")", "{", "uint32_t", "tmpreg", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_CHANNEL", "(", "ADC_Channel", ")", ")", ";", "/*", "Get", "the", "old", "register", "value", "*/", "tmpreg", "=", "ADCx", "->", "CFGR", ";", "/*", "Clear", "the", "Analog", "watchdog", "channel", "select", "bits", "*/", "tmpreg", "&=", "~", "(", "uint32_t", ")", "ADC_CFGR_AWD1CH", ";", "/*", "Set", "the", "Analog", "watchdog", "channel", "*/", "tmpreg", "|=", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "ADC_Channel", "<<", "26", ")", ";", "/*", "Store", "the", "new", "register", "value", "*/", "ADCx", "->", "CFGR", "=", "tmpreg", ";", "}'" ]

[ "Returns", "the", "ADCx", "calibration", "value" ]

[ "'uint32_t", "ADC_GetCalibrationValue", "(", "ADC_TypeDef", "*", "ADCx", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "/*", "Return", "the", "selected", "ADC", "calibration", "value", "*/", "return", "(", "uint32_t", ")", "ADCx", "->", "CALFACT", ";", "}'" ]

[ "Initializes", "the", "ADCx", "peripheral", "according", "to", "the", "specified", "parameters" ]

[ "'void", "ADC_InjectedInit", "(", "ADC_TypeDef", "*", "ADCx", ",", "ADC_InjectedInitTypeDef", "*", "ADC_InjectedInitStruct", ")", "{", "uint32_t", "tmpreg1", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_ADC_ALL_PERIPH", "(", "ADCx", ")", ")", ";", "assert_param", "(", "IS_ADC_EXT_INJEC_TRIG", "(", "ADC_InjectedInitStruct", "->", "ADC_ExternalTrigInjecConvEvent", ")", ")", ";", "assert_param", "(", "IS_EXTERNALTRIGINJ_EDGE", "(", "ADC_InjectedInitStruct", "->", "ADC_ExternalTrigInjecEventEdge", ")", ")", ";", "assert_param", "(", "IS_ADC_INJECTED_LENGTH", "(", "ADC_InjectedInitStruct", "->", "ADC_NbrOfInjecChannel", ")", ")", ";", "assert_param", "(", "IS_ADC_INJECTED_CHANNEL", "(", "ADC_InjectedInitStruct", "->", "ADC_InjecSequence1", ")", ")", ";", "assert_param", "(", "IS_ADC_INJECTED_CHANNEL", "(", "ADC_InjectedInitStruct", "->", "ADC_InjecSequence2", ")", ")", ";", "assert_param", "(", "IS_ADC_INJECTED_CHANNEL", "(", "ADC_InjectedInitStruct", "->", "ADC_InjecSequence3", ")", ")", ";", "assert_param", "(", "IS_ADC_INJECTED_CHANNEL", "(", "ADC_InjectedInitStruct", "->", "ADC_InjecSequence4", ")", ")", ";", "/*----------------------------", "ADCx", "JSQR", "Configuration", "-----------------*/", "/*", "Get", "the", "ADCx", "JSQR", "value", "*/", "tmpreg1", "=", "ADCx", "->", "JSQR", ";", "/*", "Clear", "L", "bits", "*/", "tmpreg1", "&=", "JSQR_CLEAR_Mask", ";", "/*", "Configure", "ADCx:", "Injected", "channel", "sequence", "length,", "external", "trigger,", "external", "trigger", "edge", "and", "sequences", "*/", "tmpreg1", "=", "(", "uint32_t", ")", "(", "(", "ADC_InjectedInitStruct", "->", "ADC_NbrOfInjecChannel", "-", "(", "uint8_t", ")", "1", ")", "|", "ADC_InjectedInitStruct", "->", "ADC_ExternalTrigInjecConvEvent", "|", "ADC_InjectedInitStruct", "->", "ADC_ExternalTrigInjecEventEdge", "|", "(", "uint32_t", ")", "(", "(", "ADC_InjectedInitStruct", "->", "ADC_InjecSequence1", ")", "<<", "8", ")", "|", "(", "uint32_t", ")", "(", "(", "ADC_InjectedInitStruct", "->", "ADC_InjecSequence2", ")", "<<", "14", ")", "|", "(", "uint32_t", ")", "(", "(", "ADC_InjectedInitStruct", "->", "ADC_InjecSequence3", ")", "<<", "20", ")", "|", "(", "uint32_t", ")", "(", "(", "ADC_InjectedInitStruct", "->", "ADC_InjecSequence4", ")", "<<", "26", ")", ")", ";", "/*", "Write", "to", "ADCx", "SQR1", "*/", "ADCx", "->", "JSQR", "=", "tmpreg1", ";", "}'" ]

[ "Specify", "the", "ciphers", "to", "be", "used", "by", "the", "SSL" ]

[ "'int", "SSL_set_cipher_list", "(", "SSL", "*", "s", ",", "const", "char", "*", "str", ")", "{", "STACK_OF", "(", "SSL_CIPHER", ")", "*", "sk", ";", "sk", "=", "ssl_create_cipher_list", "(", "s", "->", "ctx", "->", "method", ",", "&", "s", "->", "cipher_list", ",", "&", "s", "->", "internal", "->", "cipher_list_by_id", ",", "str", ")", ";", "/*", "see", "comment", "in", "SSL_CTX_set_cipher_list", "*/", "if", "(", "sk", "==", "NULL", ")", "return", "(", "0", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "sk_SSL_CIPHER_num", "(", "sk", ")", "==", "0", ")", "{", "SSLerror", "(", "s", ",", "SSL_R_NO_CIPHER_MATCH", ")", ";", "return", "(", "0", ")", ";", "}", "return", "(", "1", ")", ";", "}'" ]

[ "works", "well", "for", "SSLv2,", "not", "so", "good", "for", "SSLv3" ]

[ "'char", "*", "SSL_get_shared_ciphers", "(", "const", "SSL", "*", "s", ",", "char", "*", "buf", ",", "int", "len", ")", "{", "char", "*", "end", ";", "STACK_OF", "(", "SSL_CIPHER", ")", "*", "sk", ";", "SSL_CIPHER", "*", "c", ";", "size_t", "curlen", "=", "0", ";", "int", "i", ";", "if", "(", "s", "->", "session", "==", "NULL", "||", "s", "->", "session", "->", "ciphers", "==", "NULL", "||", "len", "<", "2", ")", "return", "(", "NULL", ")", ";", "sk", "=", "s", "->", "session", "->", "ciphers", ";", "if", "(", "sk_SSL_CIPHER_num", "(", "sk", ")", "==", "0", ")", "return", "(", "NULL", ")", ";", "buf", "[", "0", "]", "=", "\\'\\\\0\\'", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sk_SSL_CIPHER_num", "(", "sk", ")", ";", "i", "++", ")", "{", "c", "=", "sk_SSL_CIPHER_value", "(", "sk", ",", "i", ")", ";", "end", "=", "buf", "+", "curlen", ";", "if", "(", "strlcat", "(", "buf", ",", "c", "->", "name", ",", "len", ")", ">=", "len", "||", "(", "curlen", "=", "strlcat", "(", "buf", ",", "\":\"", ",", "len", ")", ")", ">=", "len", ")", "{", "/*", "remove", "truncated", "cipher", "from", "list", "*/", "*", "end", "=", "\\'\\\\0\\'", ";", "break;", "}", "}", "/*", "remove", "trailing", "colon", "*/", "if", "(", "(", "end", "=", "strrchr", "(", "buf", ",", "\\':\\'", ")", ")", "!=", "NULL", ")", "*", "end", "=", "\\'\\\\0\\'", ";", "return", "(", "buf", ")", ";", "}'" ]

[ "See", "if", "this", "handshake", "is", "using", "an", "ECC", "cipher", "suite" ]

[ "'int", "ssl_using_ecc_cipher", "(", "SSL", "*", "s", ")", "{", "unsigned", "long", "alg_a", ",", "<type", "ref=\"prev\"/>", "alg_k", ";", "alg_a", "=", "S3I", "(", "s", ")", "->", "hs", ".", "new_cipher", "->", "algorithm_auth", ";", "alg_k", "=", "S3I", "(", "s", ")", "->", "hs", ".", "new_cipher", "->", "algorithm_mkey", ";", "return", "SSI", "(", "s", ")", "->", "tlsext_ecpointformatlist", "!=", "NULL", "&&", "SSI", "(", "s", ")", "->", "tlsext_ecpointformatlist_length", ">", "0", "&&", "(", "(", "alg_k", "&", "SSL_kECDHE", ")", "||", "(", "alg_a", "&", "SSL_aECDSA", ")", ")", ";", "}'" ]

[ "Fix", "this", "so", "it", "checks", "all", "the", "valid", "key", "cert", "options" ]

[ "'int", "SSL_CTX_check_private_key", "(", "const", "SSL_CTX", "*", "ctx", ")", "{", "if", "(", "(", "ctx", "==", "NULL", ")", "||", "(", "ctx", "->", "internal", "->", "cert", "==", "NULL", ")", "||", "(", "ctx", "->", "internal", "->", "cert", "->", "key", "->", "x509", "==", "NULL", ")", ")", "{", "SSLerrorx", "(", "SSL_R_NO_CERTIFICATE_ASSIGNED", ")", ";", "return", "(", "0", ")", ";", "}", "if", "(", "ctx", "->", "internal", "->", "cert", "->", "key", "->", "privatekey", "==", "NULL", ")", "{", "SSLerrorx", "(", "SSL_R_NO_PRIVATE_KEY_ASSIGNED", ")", ";", "return", "(", "0", ")", ";", "}", "return", "(", "X509_check_private_key", "(", "ctx", "->", "internal", "->", "cert", "->", "key", "->", "x509", ",", "ctx", "->", "internal", "->", "cert", "->", "key", "->", "privatekey", ")", ")", ";", "}'" ]

[ "Specify", "the", "ciphers", "to", "be", "used", "by", "default", "by", "the", "SSL_CTX" ]

[ "'int", "SSL_CTX_set_cipher_list", "(", "SSL_CTX", "*", "ctx", ",", "const", "char", "*", "str", ")", "{", "STACK_OF", "(", "SSL_CIPHER", ")", "*", "sk", ";", "sk", "=", "ssl_create_cipher_list", "(", "ctx", "->", "method", ",", "&", "ctx", "->", "cipher_list", ",", "&", "ctx", "->", "internal", "->", "cipher_list_by_id", ",", "str", ")", ";", "/*", "*", "ssl_create_cipher_list", "may", "return", "an", "empty", "stack", "if", "it", "*", "was", "unable", "to", "find", "a", "cipher", "matching", "the", "given", "rule", "string", "*", "(for", "example", "if", "the", "rule", "string", "specifies", "a", "cipher", "which", "*", "has", "been", "disabled).", "This", "is", "not", "an", "error", "as", "far", "as", "*", "ssl_create_cipher_list", "is", "concerned,", "and", "hence", "*", "ctx->cipher_list", "and", "ctx->internal->cipher_list_by_id", "has", "been", "*", "updated.", "*/", "if", "(", "sk", "==", "NULL", ")", "return", "(", "0", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "sk_SSL_CIPHER_num", "(", "sk", ")", "==", "0", ")", "{", "SSLerrorx", "(", "SSL_R_NO_CIPHER_MATCH", ")", ";", "return", "(", "0", ")", ";", "}", "return", "(", "1", ")", ";", "}'" ]

[ "return", "length", "of", "latest", "Finished", "message", "we", "sent,", "copy", "to", "'buf'" ]

[ "'size_t", "SSL_get_finished", "(", "const", "SSL", "*", "s", ",", "void", "*", "buf", ",", "size_t", "count", ")", "{", "size_t", "ret", ";", "ret", "=", "S3I", "(", "s", ")", "->", "tmp", ".", "finish_md_len", ";", "if", "(", "count", ">", "ret", ")", "count", "=", "ret", ";", "memcpy", "(", "buf", ",", "S3I", "(", "s", ")", "->", "tmp", ".", "finish_md", ",", "count", ")", ";", "return", "(", "ret", ")", ";", "}'" ]

[ "Used", "to", "change", "an", "SSL_CTXs", "default", "SSL", "method", "type" ]

[ "'int", "SSL_CTX_set_ssl_version", "(", "SSL_CTX", "*", "ctx", ",", "const", "SSL_METHOD", "*", "meth", ")", "{", "STACK_OF", "(", "SSL_CIPHER", ")", "*", "sk", ";", "ctx", "->", "method", "=", "meth", ";", "sk", "=", "ssl_create_cipher_list", "(", "ctx", "->", "method", ",", "&", "(", "ctx", "->", "cipher_list", ")", ",", "&", "(", "ctx", "->", "internal", "->", "cipher_list_by_id", ")", ",", "SSL_DEFAULT_CIPHER_LIST", ")", ";", "if", "(", "(", "sk", "==", "NULL", ")", "||", "(", "sk_SSL_CIPHER_num", "(", "sk", ")", "<=", "0", ")", ")", "{", "SSLerrorx", "(", "SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS", ")", ";", "return", "(", "0", ")", ";", "}", "return", "(", "1", ")", ";", "}'" ]

[ "This", "handles", "alignment", "issues", "and", "endianess" ]

[ "'void", "gt2MemCopy64", "(", "char", "*", "out", ",", "char", "const", "*", "in", ")", "{", "#", "ifdef", "_GT2_ENDIAN_CONVERT", "out", "[", "0", "]", "=", "in", "[", "7", "]", ";", "out", "[", "1", "]", "=", "in", "[", "6", "]", ";", "out", "[", "2", "]", "=", "in", "[", "5", "]", ";", "out", "[", "3", "]", "=", "in", "[", "4", "]", ";", "out", "[", "4", "]", "=", "in", "[", "3", "]", ";", "out", "[", "5", "]", "=", "in", "[", "2", "]", ";", "out", "[", "6", "]", "=", "in", "[", "1", "]", ";", "out", "[", "7", "]", "=", "in", "[", "0", "]", ";", "#", "else", "//", "straight", "copy", "memcpy", "(", "out", ",", "in", ",", "8", ")", ";", "#", "endif", "}'" ]

[ "This", "handles", "alignment", "issues", "and", "endianess" ]

[ "'void", "gt2MemCopy32", "(", "char", "*", "out", ",", "char", "const", "*", "in", ")", "{", "#", "ifdef", "_GT2_ENDIAN_CONVERT", "out", "[", "0", "]", "=", "in", "[", "3", "]", ";", "out", "[", "1", "]", "=", "in", "[", "2", "]", ";", "out", "[", "2", "]", "=", "in", "[", "1", "]", ";", "out", "[", "3", "]", "=", "in", "[", "0", "]", ";", "#", "else", "//", "straight", "copy", "*", "out", "=", "*", "in", ";", "out", "[", "1", "]", "=", "in", "[", "1", "]", ";", "out", "[", "2", "]", "=", "in", "[", "2", "]", ";", "out", "[", "3", "]", "=", "in", "[", "3", "]", ";", "#", "endif", "}'" ]

[ "{{{", "Bzip2", "stream", "openers" ]

[ "'PHP_BZ2_API", "php_stream", "*", "_php_stream_bz2open_from_BZFILE", "(", "BZFILE", "*", "bz", ",", "const", "char", "*", "mode", ",", "php_stream", "*", "innerstream", "STREAMS_DC", ")", "{", "struct", "php_bz2_stream_data_t", "*", "self", ";", "self", "=", "emalloc", "(", "sizeof", "(", "*", "self", ")", ")", ";", "self", "->", "stream", "=", "innerstream", ";", "if", "(", "innerstream", ")", "{", "GC_REFCOUNT", "(", "innerstream", "->", "res", ")", "++", ";", "}", "self", "->", "bz_file", "=", "bz", ";", "return", "php_stream_alloc_rel", "(", "&", "php_stream_bz2io_ops", ",", "self", ",", "0", ",", "mode", ")", ";", "}'" ]

[ "{{{", "BZip2", "stream", "implementation" ]

[ "'static", "size_t", "php_bz2iop_read", "(", "php_stream", "*", "stream", ",", "char", "*", "buf", ",", "size_t", "count", ")", "{", "struct", "php_bz2_stream_data_t", "*", "self", "=", "(", "struct", "php_bz2_stream_data_t", "*", ")", "stream", "->", "abstract", ";", "size_t", "ret", "=", "0", ";", "do", "{", "int", "just_read", ";", "size_t", "remain", "=", "count", "-", "ret", ";", "int", "to_read", "=", "(", "int", ")", "(", "remain", "<=", "INT_MAX", "?", "remain", ":", "INT_MAX", ")", ";", "just_read", "=", "BZ2_bzread", "(", "self", "->", "bz_file", ",", "buf", ",", "to_read", ")", ";", "if", "(", "just_read", "<", "1", ")", "{", "/*", "it", "is", "not", "safe", "to", "keep", "reading", "after", "an", "error,", "see", "#72613", "*/", "stream", "->", "eof", "=", "1", ";", "if", "(", "just_read", "<", "0", ")", "{", "return", "-", "1", ";", "}", "break;", "}", "ret", "+=", "just_read", ";", "}", "while", "(", "ret", "<", "count", ")", ";", "return", "ret", ";", "}'" ]

[ "Context:", "BH", "in", "IOThread" ]

[ "'static", "void", "aio_wait_bh", "(", "void", "*", "opaque", ")", "{", "AioWaitBHData", "*", "data", "=", "opaque", ";", "data", "->", "cb", "(", "data", "->", "opaque", ")", ";", "data", "->", "done", "=", "true", ";", "aio_wait_kick", "()", ";", "}'" ]

[ "use", "error", "locator", "and", "syndromes", "to", "find", "the", "error", "evaluator", "polynomial" ]

[ "'void", "reed_solomon_find_error_evaluator", "(", "field_t", "field", ",", "polynomial_t", "locator", ",", "polynomial_t", "syndromes", ",", "polynomial_t", "error_evaluator", ")", "{", "//", "the", "error", "evaluator,", "omega(x),", "is", "S(x)*Lamba(x)", "mod", "x^(2t)", "//", "where", "S(x)", "is", "a", "polynomial", "constructed", "from", "the", "syndromes", "//", "S(1)", "+", "S(2)*x", "+", "...", "+", "S(2t)*x(2t", "-", "1)", "//", "and", "Lambda(x)", "is", "the", "error", "locator", "//", "the", "modulo", "is", "implicit", "here", "--", "we", "have", "limited", "the", "max", "length", "of", "error_evaluator,", "//", "which", "polynomial_mul", "will", "interpret", "to", "mean", "that", "it", "should", "not", "compute", "//", "powers", "larger", "than", "that,", "which", "is", "the", "same", "as", "performing", "mod", "x^(2t)", "polynomial_mul", "(", "field", ",", "locator", ",", "syndromes", ",", "error_evaluator", ")", ";", "}'" ]

[ "Kill", "any", "debug", "uses", "outside", "LOOP", "of", "SSA", "names", "defined", "in", "STMT" ]

[ "'static", "void", "vect_loop_kill_debug_uses", "(", "struct", "loop", "*", "loop", ",", "gimple", "stmt", ")", "{", "ssa_op_iter", "op_iter", ";", "imm_use_iterator", "imm_iter", ";", "def_operand_p", "def_p", ";", "gimple", "ustmt", ";", "FOR_EACH_PHI_OR_STMT_DEF", "(", "def_p", ",", "stmt", ",", "op_iter", ",", "SSA_OP_DEF", ")", "{", "FOR_EACH_IMM_USE_STMT", "(", "ustmt", ",", "imm_iter", ",", "DEF_FROM_PTR", "(def_p)", ")", "{", "basic_block", "bb", ";", "if", "(", "!", "is_gimple_debug", "(", "ustmt", ")", ")", "continue;", "bb", "=", "gimple_bb", "(", "ustmt", ")", ";", "if", "(", "!", "flow_bb_inside_loop_p", "(", "loop", ",", "bb", ")", ")", "{", "if", "(", "gimple_debug_bind_p", "(", "ustmt", ")", ")", "{", "if", "(", "dump_enabled_p", "()", ")", "dump_printf_loc", "(", "MSG_NOTE", ",", "vect_location", ",", "\"killing", "debug", "use\"", ")", ";", "gimple_debug_bind_reset_value", "(", "ustmt", ")", ";", "update_stmt", "(", "ustmt", ")", ";", "}", "else", "gcc_unreachable", "()", ";", "}", "}", "}", "}'" ]

[ "Calculate", "the", "cost", "of", "one", "scalar", "iteration", "of", "the", "loop" ]

[ "'int", "vect_get_single_scalar_iteration_cost", "(", "loop_vec_info", "loop_vinfo", ")", "{", "struct", "loop", "*", "loop", "=", "LOOP_VINFO_LOOP", "(", "loop_vinfo", ")", ";", "basic_block", "*", "bbs", "=", "LOOP_VINFO_BBS", "(", "loop_vinfo", ")", ";", "int", "nbbs", "=", "loop", "->", "num_nodes", ",", "<type", "ref=\"prev\"/>", "factor", ",", "<type", "ref=\"prev\"/>", "scalar_single_iter_cost", "=", "0", ";", "int", "innerloop_iters", ",", "<type", "ref=\"prev\"/>", "i", ",", "<type", "ref=\"prev\"/>", "stmt_cost", ";", "/*", "Count", "statements", "in", "scalar", "loop.", "Using", "this", "as", "scalar", "cost", "for", "a", "single", "iteration", "for", "now.", "TODO:", "Add", "outer", "loop", "support.", "TODO:", "Consider", "assigning", "different", "costs", "to", "different", "scalar", "statements.", "*/", "/*", "FORNOW.", "*/", "innerloop_iters", "=", "1", ";", "if", "(", "loop", "->", "inner", ")", "innerloop_iters", "=", "50", ";", "/*", "FIXME", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "nbbs", ";", "i", "++", ")", "{", "gimple_stmt_iterator", "si", ";", "basic_block", "bb", "=", "bbs", "[", "i", "]", ";", "if", "(", "bb", "->", "loop_father", "==", "loop", "->", "inner", ")", "factor", "=", "innerloop_iters", ";", "else", "factor", "=", "1", ";", "for", "(", "si", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "si", ")", ";", "gsi_next", "(", "&", "si", ")", ")", "{", "gimple", "stmt", "=", "gsi_stmt", "(", "si", ")", ";", "stmt_vec_info", "stmt_info", "=", "vinfo_for_stmt", "(", "stmt", ")", ";", "if", "(", "!", "is_gimple_assign", "(", "stmt", ")", "&&", "!", "is_gimple_call", "(", "stmt", ")", ")", "continue;", "/*", "Skip", "stmts", "that", "are", "not", "vectorized", "inside", "the", "loop.", "*/", "if", "(", "stmt_info", "&&", "!", "STMT_VINFO_RELEVANT_P", "(", "stmt_info", ")", "&&", "(", "!", "STMT_VINFO_LIVE_P", "(", "stmt_info", ")", "||", "!", "VECTORIZABLE_CYCLE_DEF", "(", "STMT_VINFO_DEF_TYPE", "(", "stmt_info", ")", ")", ")", "&&", "!", "STMT_VINFO_IN_PATTERN_P", "(", "stmt_info", ")", ")", "continue;", "if", "(", "STMT_VINFO_DATA_REF", "(", "vinfo_for_stmt", "(", "stmt", ")", ")", ")", "{", "if", "(", "DR_IS_READ", "(", "STMT_VINFO_DATA_REF", "(", "vinfo_for_stmt", "(", "stmt", ")", ")", ")", ")", "stmt_cost", "=", "vect_get_stmt_cost", "(", "scalar_load", ")", ";", "else", "stmt_cost", "=", "vect_get_stmt_cost", "(", "scalar_store", ")", ";", "}", "else", "stmt_cost", "=", "vect_get_stmt_cost", "(", "scalar_stmt", ")", ";", "scalar_single_iter_cost", "+=", "stmt_cost", "*", "factor", ";", "}", "}", "return", "scalar_single_iter_cost", ";", "}'" ]

[ "Calculate", "cost", "of", "peeling", "the", "loop", "PEEL_ITERS_PROLOGUE", "times" ]

[ "'int", "vect_get_known_peeling_cost", "(", "loop_vec_info", "loop_vinfo", ",", "int", "peel_iters_prologue", ",", "int", "*", "peel_iters_epilogue", ",", "int", "scalar_single_iter_cost", ",", "stmt_vector_for_cost", "*", "prologue_cost_vec", ",", "stmt_vector_for_cost", "*", "epilogue_cost_vec", ")", "{", "int", "retval", "=", "0", ";", "int", "vf", "=", "LOOP_VINFO_VECT_FACTOR", "(", "loop_vinfo", ")", ";", "if", "(", "!", "LOOP_VINFO_NITERS_KNOWN_P", "(", "loop_vinfo", ")", ")", "{", "*", "peel_iters_epilogue", "=", "vf", "/", "2", ";", "if", "(", "dump_enabled_p", "()", ")", "dump_printf_loc", "(", "MSG_NOTE", ",", "vect_location", ",", "\"cost", "model:", "epilogue", "peel", "iters", "set", "to", "vf/2", "\"", "\"because", "loop", "iterations", "are", "unknown", ".\"", ")", ";", "/*", "If", "peeled", "iterations", "are", "known", "but", "number", "of", "scalar", "loop", "iterations", "are", "unknown,", "count", "a", "taken", "branch", "per", "peeled", "loop.", "*/", "retval", "=", "record_stmt_cost", "(", "prologue_cost_vec", ",", "2", ",", "cond_branch_taken", ",", "NULL", ",", "0", ",", "vect_prologue", ")", ";", "}", "else", "{", "int", "niters", "=", "LOOP_VINFO_INT_NITERS", "(", "loop_vinfo", ")", ";", "peel_iters_prologue", "=", "niters", "<", "peel_iters_prologue", "?", "niters", ":", "peel_iters_prologue", ";", "*", "peel_iters_epilogue", "=", "(", "niters", "-", "peel_iters_prologue", ")", "%", "vf", ";", "/*", "If", "we", "need", "to", "peel", "for", "gaps,", "but", "no", "peeling", "is", "required,", "we", "have", "to", "peel", "VF", "iterations.", "*/", "if", "(", "LOOP_VINFO_PEELING_FOR_GAPS", "(", "loop_vinfo", ")", "&&", "!", "*", "peel_iters_epilogue", ")", "*", "peel_iters_epilogue", "=", "vf", ";", "}", "if", "(", "peel_iters_prologue", ")", "retval", "+=", "record_stmt_cost", "(", "prologue_cost_vec", ",", "peel_iters_prologue", "*", "scalar_single_iter_cost", ",", "scalar_stmt", ",", "NULL", ",", "0", ",", "vect_prologue", ")", ";", "if", "(", "*", "peel_iters_epilogue", ")", "retval", "+=", "record_stmt_cost", "(", "epilogue_cost_vec", ",", "*", "peel_iters_epilogue", "*", "scalar_single_iter_cost", ",", "scalar_stmt", ",", "NULL", ",", "0", ",", "vect_epilogue", ")", ";", "return", "retval", ";", "}'" ]

[ "LA", "isnt", "set", "here", "for", "some", "reason" ]

[ "'static", "void", "SetDefaultOptions", "(", "void", ")", "{", "gSaveBlock2Ptr", "->", "optionsTextSpeed", "=", "OPTIONS_TEXT_SPEED_MID", ";", "gSaveBlock2Ptr", "->", "optionsWindowFrameType", "=", "0", ";", "gSaveBlock2Ptr", "->", "optionsSound", "=", "OPTIONS_SOUND_MONO", ";", "gSaveBlock2Ptr", "->", "optionsBattleStyle", "=", "OPTIONS_BATTLE_STYLE_SHIFT", ";", "gSaveBlock2Ptr", "->", "optionsBattleSceneOff", "=", "FALSE", ";", "gSaveBlock2Ptr", "->", "regionMapZoom", "=", "FALSE", ";", "}'" ]

[ "Emit", "parent", "reference", "with", "deduplication" ]

[ "'static", "TRef", "snap_pref", "(", "jit_State", "*", "J", ",", "GCtrace", "*", "T", ",", "SnapEntry", "*", "map", ",", "MSize", "nmax", ",", "BloomFilter", "seen", ",", "IRRef", "ref", ")", "{", "IRIns", "*", "ir", "=", "&", "T", "->", "ir", "[", "ref", "]", ";", "TRef", "tr", ";", "if", "(", "irref_isk", "(", "ref", ")", ")", "tr", "=", "snap_replay_const", "(", "J", ",", "ir", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "regsp_used", "(", "ir", "->", "prev", ")", ")", "tr", "=", "0", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "bloomtest", "(", "seen", ",", "ref", ")", "||", "(", "tr", "=", "snap_dedup", "(", "J", ",", "map", ",", "nmax", ",", "ref", ")", ")", "==", "0", ")", "tr", "=", "emitir", "(", "IRT", "(", "IR_PVAL", ",", "irt_type", "(", "ir", "->", "t", ")", ")", ",", "ref", "-", "REF_BIAS", ",", "0", ")", ";", "return", "tr", ";", "}'" ]

[ "Replay", "snapshot", "state", "to", "setup", "side", "trace" ]

[ "'void", "lj_snap_replay", "(", "jit_State", "*", "J", ",", "GCtrace", "*", "T", ")", "{", "SnapShot", "*", "snap", "=", "&", "T", "->", "snap", "[", "J", "->", "exitno", "]", ";", "SnapEntry", "*", "map", "=", "&", "T", "->", "snapmap", "[", "snap", "->", "mapofs", "]", ";", "MSize", "n", ",", "<type", "ref=\"prev\"/>", "nent", "=", "snap", "->", "nent", ";", "BloomFilter", "seen", "=", "0", ";", "int", "pass23", "=", "0", ";", "J", "->", "framedepth", "=", "0", ";", "/*", "Emit", "IR", "for", "slots", "inherited", "from", "parent", "snapshot.", "*/", "for", "(", "n", "=", "0", ";", "n", "<", "nent", ";", "n", "++", ")", "{", "SnapEntry", "sn", "=", "map", "[", "n", "]", ";", "BCReg", "s", "=", "snap_slot", "(", "sn", ")", ";", "IRRef", "ref", "=", "snap_ref", "(", "sn", ")", ";", "IRIns", "*", "ir", "=", "&", "T", "->", "ir", "[", "ref", "]", ";", "TRef", "tr", ";", "/*", "The", "bloom", "filter", "avoids", "O(nent^2)", "overhead", "for", "de-duping", "slots.", "*/", "if", "(", "bloomtest", "(", "seen", ",", "ref", ")", "&&", "(", "tr", "=", "snap_dedup", "(", "J", ",", "map", ",", "n", ",", "ref", ")", ")", "!=", "0", ")", "goto", "setslot", ";", "bloomset", "(", "seen", ",", "ref", ")", ";", "if", "(", "irref_isk", "(", "ref", ")", ")", "{", "/*", "See", "special", "treatment", "of", "LJ_FR2", "slot", "1", "in", "snapshot_slots()", "above.", "*/", "if", "(", "LJ_FR2", "&&", "(", "sn", "==", "SNAP", "(", "1", ",", "SNAP_FRAME", "|", "SNAP_NORESTORE", ",", "REF_NIL", ")", ")", ")", "tr", "=", "0", ";", "else", "tr", "=", "snap_replay_const", "(", "J", ",", "ir", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "regsp_used", "(", "ir", "->", "prev", ")", ")", "{", "pass23", "=", "1", ";", "lua_assert", "(", "s", "!=", "0", ")", ";", "tr", "=", "s", ";", "}", "else", "{", "IRType", "t", "=", "irt_type", "(", "ir", "->", "t", ")", ";", "uint32_t", "mode", "=", "IRSLOAD_INHERIT", "|", "IRSLOAD_PARENT", ";", "if", "(", "LJ_SOFTFP32", "&&", "(", "sn", "&", "SNAP_SOFTFPNUM", ")", ")", "t", "=", "IRT_NUM", ";", "if", "(", "ir", "->", "o", "==", "IR_SLOAD", ")", "mode", "|=", "(", "ir", "->", "op2", "&", "IRSLOAD_READONLY", ")", ";", "tr", "=", "emitir_raw", "(", "IRT", "(", "IR_SLOAD", ",", "t", ")", ",", "s", ",", "mode", ")", ";", "}", "setslot", ":", "J", "->", "slot", "[", "s", "]", "=", "tr", "|", "(", "sn", "&", "(", "SNAP_CONT", "|", "SNAP_FRAME", ")", ")", ";", "/*", "Same", "as", "TREF_*", "flags.", "*/", "J", "->", "framedepth", "+=", "(", "(", "sn", "&", "(", "SNAP_CONT", "|", "SNAP_FRAME", ")", ")", "&&", "(", "s", "!=", "LJ_FR2", ")", ")", ";", "if", "(", "(", "sn", "&", "SNAP_FRAME", ")", ")", "J", "->", "baseslot", "=", "s", "+", "1", ";", "}", "if", "(", "pass23", ")", "{", "IRIns", "*", "irlast", "=", "&", "T", "->", "ir", "[", "snap", "->", "ref", "]", ";", "pass23", "=", "0", ";", "/*", "Emit", "dependent", "PVALs.", "*/", "for", "(", "n", "=", "0", ";", "n", "<", "nent", ";", "n", "++", ")", "{", "SnapEntry", "sn", "=", "map", "[", "n", "]", ";", "IRRef", "refp", "=", "snap_ref", "(", "sn", ")", ";", "IRIns", "*", "ir", "=", "&", "T", "->", "ir", "[", "refp", "]", ";", "if", "(", "regsp_reg", "(", "ir", "->", "r", ")", "==", "RID_SUNK", ")", "{", "if", "(", "J", "->", "slot", "[", "snap_slot", "(", "sn", ")", "]", "!=", "snap_slot", "(", "sn", ")", ")", "continue;", "pass23", "=", "1", ";", "lua_assert", "(", "ir", "->", "o", "==", "IR_TNEW", "||", "ir", "->", "o", "==", "IR_TDUP", "||", "ir", "->", "o", "==", "IR_CNEW", "||", "ir", "->", "o", "==", "IR_CNEWI", ")", ";", "if", "(", "ir", "->", "op1", ">=", "T", "->", "nk", ")", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "ir", "->", "op1", ")", ";", "if", "(", "ir", "->", "op2", ">=", "T", "->", "nk", ")", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "ir", "->", "op2", ")", ";", "if", "(", "LJ_HASFFI", "&&", "ir", "->", "o", "==", "IR_CNEWI", ")", "{", "if", "(", "LJ_32", "&&", "refp", "+", "1", "<", "T", "->", "nins", "&&", "(", "ir", "+", "1", ")", "->", "o", "==", "IR_HIOP", ")", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "(", "ir", "+", "1", ")", "->", "op2", ")", ";", "}", "else", "{", "IRIns", "*", "irs", ";", "for", "(", "irs", "=", "ir", "+", "1", ";", "irs", "<", "irlast", ";", "irs", "++", ")", "if", "(", "irs", "->", "r", "==", "RID_SINK", "&&", "snap_sunk_store", "(", "T", ",", "ir", ",", "irs", ")", ")", "{", "if", "(", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "irs", "->", "op2", ")", "==", "0", ")", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "T", "->", "ir", "[", "irs", "->", "op2", "]", ".", "op1", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "(", "LJ_SOFTFP32", "||", "(", "LJ_32", "&&", "LJ_HASFFI", ")", ")", "&&", "irs", "+", "1", "<", "irlast", "&&", "(", "irs", "+", "1", ")", "->", "o", "==", "IR_HIOP", ")", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "(", "irs", "+", "1", ")", "->", "op2", ")", ";", "}", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "irref_isk", "(", "refp", ")", "&&", "!", "regsp_used", "(", "ir", "->", "prev", ")", ")", "{", "lua_assert", "(", "ir", "->", "o", "==", "IR_CONV", "&&", "ir", "->", "op2", "==", "IRCONV_NUM_INT", ")", ";", "J", "->", "slot", "[", "snap_slot", "(", "sn", ")", "]", "=", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "ir", "->", "op1", ")", ";", "}", "}", "/*", "Replay", "sunk", "instructions.", "*/", "for", "(", "n", "=", "0", ";", "pass23", "&&", "n", "<", "nent", ";", "n", "++", ")", "{", "SnapEntry", "sn", "=", "map", "[", "n", "]", ";", "IRRef", "refp", "=", "snap_ref", "(", "sn", ")", ";", "IRIns", "*", "ir", "=", "&", "T", "->", "ir", "[", "refp", "]", ";", "if", "(", "regsp_reg", "(", "ir", "->", "r", ")", "==", "RID_SUNK", ")", "{", "TRef", "op1", ",", "<type", "ref=\"prev\"/>", "op2", ";", "if", "(", "J", "->", "slot", "[", "snap_slot", "(", "sn", ")", "]", "!=", "snap_slot", "(", "sn", ")", ")", "{", "/*", "De-dup", "allocs.", "*/", "J", "->", "slot", "[", "snap_slot", "(", "sn", ")", "]", "=", "J", "->", "slot", "[", "J", "->", "slot", "[", "snap_slot", "(", "sn", ")", "]", "]", ";", "continue;", "}", "op1", "=", "ir", "->", "op1", ";", "if", "(", "op1", ">=", "T", "->", "nk", ")", "op1", "=", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "op1", ")", ";", "op2", "=", "ir", "->", "op2", ";", "if", "(", "op2", ">=", "T", "->", "nk", ")", "op2", "=", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "op2", ")", ";", "if", "(", "LJ_HASFFI", "&&", "ir", "->", "o", "==", "IR_CNEWI", ")", "{", "if", "(", "LJ_32", "&&", "refp", "+", "1", "<", "T", "->", "nins", "&&", "(", "ir", "+", "1", ")", "->", "o", "==", "IR_HIOP", ")", "{", "lj_needsplit", "(", "J", ")", ";", "/*", "Emit", "joining", "HIOP.", "*/", "op2", "=", "emitir_raw", "(", "IRT", "(", "IR_HIOP", ",", "IRT_I64", ")", ",", "op2", ",", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "(", "ir", "+", "1", ")", "->", "op2", ")", ")", ";", "}", "J", "->", "slot", "[", "snap_slot", "(", "sn", ")", "]", "=", "emitir", "(", "ir", "->", "ot", "&", "~", "(", "IRT_MARK", "|", "IRT_ISPHI", ")", ",", "op1", ",", "op2", ")", ";", "}", "else", "{", "IRIns", "*", "irs", ";", "TRef", "tr", "=", "emitir", "(", "ir", "->", "ot", ",", "op1", ",", "op2", ")", ";", "J", "->", "slot", "[", "snap_slot", "(", "sn", ")", "]", "=", "tr", ";", "for", "(", "irs", "=", "ir", "+", "1", ";", "irs", "<", "irlast", ";", "irs", "++", ")", "if", "(", "irs", "->", "r", "==", "RID_SINK", "&&", "snap_sunk_store", "(", "T", ",", "ir", ",", "irs", ")", ")", "{", "IRIns", "*", "irr", "=", "&", "T", "->", "ir", "[", "irs", "->", "op1", "]", ";", "TRef", "val", ",", "<type", "ref=\"prev\"/>", "key", "=", "irr", "->", "op2", ",", "<type", "ref=\"prev\"/>", "tmp", "=", "tr", ";", "if", "(", "irr", "->", "o", "!=", "IR_FREF", ")", "{", "IRIns", "*", "irk", "=", "&", "T", "->", "ir", "[", "key", "]", ";", "if", "(", "irr", "->", "o", "==", "IR_HREFK", ")", "key", "=", "lj_ir_kslot", "(", "J", ",", "snap_replay_const", "(", "J", ",", "&", "T", "->", "ir", "[", "irk", "->", "op1", "]", ")", ",", "irk", "->", "op2", ")", ";", "else", "key", "=", "snap_replay_const", "(", "J", ",", "irk", ")", ";", "if", "(", "irr", "->", "o", "==", "IR_HREFK", "||", "irr", "->", "o", "==", "IR_AREF", ")", "{", "IRIns", "*", "irf", "=", "&", "T", "->", "ir", "[", "irr", "->", "op1", "]", ";", "tmp", "=", "emitir", "(", "irf", "->", "ot", ",", "tmp", ",", "irf", "->", "op2", ")", ";", "}", "}", "tmp", "=", "emitir", "(", "irr", "->", "ot", ",", "tmp", ",", "key", ")", ";", "val", "=", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "irs", "->", "op2", ")", ";", "if", "(", "val", "==", "0", ")", "{", "IRIns", "*", "irc", "=", "&", "T", "->", "ir", "[", "irs", "->", "op2", "]", ";", "lua_assert", "(", "irc", "->", "o", "==", "IR_CONV", "&&", "irc", "->", "op2", "==", "IRCONV_NUM_INT", ")", ";", "val", "=", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "irc", "->", "op1", ")", ";", "val", "=", "emitir", "(", "IRTN", "(", "IR_CONV", ")", ",", "val", ",", "IRCONV_NUM_INT", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "LJ_SOFTFP32", "||", "(", "LJ_32", "&&", "LJ_HASFFI", ")", ")", "&&", "irs", "+", "1", "<", "irlast", "&&", "(", "irs", "+", "1", ")", "->", "o", "==", "IR_HIOP", ")", "{", "IRType", "t", "=", "IRT_I64", ";", "if", "(", "LJ_SOFTFP32", "&&", "irt_type", "(", "(", "irs", "+", "1", ")", "->", "t", ")", "==", "IRT_SOFTFP", ")", "t", "=", "IRT_NUM", ";", "lj_needsplit", "(", "J", ")", ";", "if", "(", "irref_isk", "(", "irs", "->", "op2", ")", "&&", "irref_isk", "(", "(", "irs", "+", "1", ")", "->", "op2", ")", ")", "{", "uint64_t", "k", "=", "(", "uint32_t", ")", "T", "->", "ir", "[", "irs", "->", "op2", "]", ".", "i", "+", "(", "(", "uint64_t", ")", "T", "->", "ir", "[", "(", "irs", "+", "1", ")", "->", "op2", "]", ".", "i", "<<", "32", ")", ";", "val", "=", "lj_ir_k64", "(", "J", ",", "t", "==", "IRT_I64", "?", "IR_KINT64", ":", "IR_KNUM", ",", "k", ")", ";", "}", "else", "{", "val", "=", "emitir_raw", "(", "IRT", "(", "IR_HIOP", ",", "t", ")", ",", "val", ",", "snap_pref", "(", "J", ",", "T", ",", "map", ",", "nent", ",", "seen", ",", "(", "irs", "+", "1", ")", "->", "op2", ")", ")", ";", "}", "tmp", "=", "emitir", "(", "IRT", "(", "irs", "->", "o", ",", "t", ")", ",", "tmp", ",", "val", ")", ";", "continue;", "}", "tmp", "=", "emitir", "(", "irs", "->", "ot", ",", "tmp", ",", "val", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "LJ_HASFFI", "&&", "irs", "->", "o", "==", "IR_XBAR", "&&", "ir", "->", "o", "==", "IR_CNEW", ")", "{", "emitir", "(", "IRT", "(", "IR_XBAR", ",", "IRT_NIL", ")", ",", "0", ",", "0", ")", ";", "}", "}", "}", "}", "}", "J", "->", "base", "=", "J", "->", "slot", "+", "J", "->", "baseslot", ";", "J", "->", "maxslot", "=", "snap", "->", "nslots", "-", "J", "->", "baseslot", ";", "lj_snap_add", "(", "J", ")", ";", "if", "(", "pass23", ")", "/*", "Need", "explicit", "GC", "step", "_after_", "initial", "snapshot.", "*/", "emitir_raw", "(", "IRTG", "(", "IR_GCSTEP", ",", "IRT_NIL", ")", ",", "0", ",", "0", ")", ";", "}'" ]

[ "Process", "matching", "renames", "to", "find", "the", "original", "RegSP" ]

[ "'static", "RegSP", "snap_renameref", "(", "GCtrace", "*", "T", ",", "SnapNo", "lim", ",", "IRRef", "ref", ",", "RegSP", "rs", ")", "{", "IRIns", "*", "ir", ";", "for", "(", "ir", "=", "&", "T", "->", "ir", "[", "T", "->", "nins", "-", "1", "]", ";", "ir", "->", "o", "==", "IR_RENAME", ";", "ir", "--", ")", "if", "(", "ir", "->", "op1", "==", "ref", "&&", "ir", "->", "op2", "<=", "lim", ")", "rs", "=", "ir", "->", "prev", ";", "return", "rs", ";", "}'" ]

[ "Restore", "raw", "data", "from", "the", "trace", "exit", "state" ]

[ "'static", "void", "snap_restoredata", "(", "GCtrace", "*", "T", ",", "ExitState", "*", "ex", ",", "SnapNo", "snapno", ",", "BloomFilter", "rfilt", ",", "IRRef", "ref", ",", "void", "*", "dst", ",", "CTSize", "sz", ")", "{", "IRIns", "*", "ir", "=", "&", "T", "->", "ir", "[", "ref", "]", ";", "RegSP", "rs", "=", "ir", "->", "prev", ";", "int32_t", "*", "src", ";", "uint64_t", "tmp", ";", "if", "(", "irref_isk", "(", "ref", ")", ")", "{", "if", "(", "ir_isk64", "(", "ir", ")", ")", "{", "src", "=", "(", "int32_t", "*", ")", "&", "ir", "[", "1", "]", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "sz", "==", "8", ")", "{", "tmp", "=", "(", "uint64_t", ")", "(", "uint32_t", ")", "ir", "->", "i", ";", "src", "=", "(", "int32_t", "*", ")", "&", "tmp", ";", "}", "else", "{", "src", "=", "&", "ir", "->", "i", ";", "}", "}", "else", "{", "if", "(", "LJ_UNLIKELY", "(", "bloomtest", "(", "rfilt", ",", "ref", ")", ")", ")", "rs", "=", "snap_renameref", "(", "T", ",", "snapno", ",", "ref", ",", "rs", ")", ";", "if", "(", "ra_hasspill", "(", "regsp_spill", "(", "rs", ")", ")", ")", "{", "src", "=", "&", "ex", "->", "spill", "[", "regsp_spill", "(", "rs", ")", "]", ";", "if", "(", "sz", "==", "8", "&&", "!", "irt_is64", "(", "ir", "->", "t", ")", ")", "{", "tmp", "=", "(", "uint64_t", ")", "(", "uint32_t", ")", "*", "src", ";", "src", "=", "(", "int32_t", "*", ")", "&", "tmp", ";", "}", "}", "else", "{", "Reg", "r", "=", "regsp_reg", "(", "rs", ")", ";", "if", "(", "ra_noreg", "(", "r", ")", ")", "{", "/*", "Note:", "this", "assumes", "CNEWI", "is", "never", "used", "for", "SOFTFP", "split", "numbers.", "*/", "lua_assert", "(", "sz", "==", "8", "&&", "ir", "->", "o", "==", "IR_CONV", "&&", "ir", "->", "op2", "==", "IRCONV_NUM_INT", ")", ";", "snap_restoredata", "(", "T", ",", "ex", ",", "snapno", ",", "rfilt", ",", "ir", "->", "op1", ",", "dst", ",", "4", ")", ";", "*", "(", "lua_Number", "*", ")", "dst", "=", "(", "lua_Number", ")", "*", "(", "int32_t", "*", ")", "dst", ";", "return", ";", "}", "src", "=", "(", "int32_t", "*", ")", "&", "ex", "->", "gpr", "[", "r", "-", "RID_MIN_GPR", "]", ";", "#", "if", "!", "LJ_SOFTFP", "if", "(", "r", ">=", "RID_MAX_GPR", ")", "{", "src", "=", "(", "int32_t", "*", ")", "&", "ex", "->", "fpr", "[", "r", "-", "RID_MIN_FPR", "]", ";", "#", "if", "LJ_TARGET_PPC", "if", "(", "sz", "==", "4", ")", "{", "/*", "PPC", "FPRs", "are", "always", "doubles.", "*/", "*", "(", "float", "*", ")", "dst", "=", "(", "float", ")", "*", "(", "double", "*", ")", "src", ";", "return", ";", "}", "#", "else", "if", "(", "LJ_BE", "&&", "sz", "==", "4", ")", "src", "++", ";", "#", "endif", "}", "<if", "type=\"elseif\">", "else", "#", "endif", "if", "(", "LJ_64", "&&", "LJ_BE", "&&", "sz", "==", "4", ")", "src", "++", ";", "}", "}", "lua_assert", "(", "sz", "==", "1", "||", "sz", "==", "2", "||", "sz", "==", "4", "||", "sz", "==", "8", ")", ";", "if", "(", "sz", "==", "4", ")", "*", "(", "int32_t", "*", ")", "dst", "=", "*", "src", ";", "<if", "type=\"elseif\">", "else", "if", "(", "sz", "==", "8", ")", "*", "(", "int64_t", "*", ")", "dst", "=", "*", "(", "int64_t", "*", ")", "src", ";", "<if", "type=\"elseif\">", "else", "if", "(", "sz", "==", "1", ")", "*", "(", "int8_t", "*", ")", "dst", "=", "(", "int8_t", ")", "*", "src", ";", "else", "*", "(", "int16_t", "*", ")", "dst", "=", "(", "int16_t", ")", "*", "src", ";", "}'" ]

[ "Copy", "RegSP", "from", "parent", "snapshot", "to", "the", "parent", "links", "of", "the", "IR" ]

[ "'IRIns", "*", "lj_snap_regspmap", "(", "GCtrace", "*", "T", ",", "SnapNo", "snapno", ",", "IRIns", "*", "ir", ")", "{", "SnapShot", "*", "snap", "=", "&", "T", "->", "snap", "[", "snapno", "]", ";", "SnapEntry", "*", "map", "=", "&", "T", "->", "snapmap", "[", "snap", "->", "mapofs", "]", ";", "BloomFilter", "rfilt", "=", "snap_renamefilter", "(", "T", ",", "snapno", ")", ";", "MSize", "n", "=", "0", ";", "IRRef", "ref", "=", "0", ";", "for", "(", ";", ";", "ir", "++", ")", "{", "uint32_t", "rs", ";", "if", "(", "ir", "->", "o", "==", "IR_SLOAD", ")", "{", "if", "(", "!", "(", "ir", "->", "op2", "&", "IRSLOAD_PARENT", ")", ")", "break;", "for", "(", ";", ";", "n", "++", ")", "{", "lua_assert", "(", "n", "<", "snap", "->", "nent", ")", ";", "if", "(", "snap_slot", "(", "map", "[", "n", "]", ")", "==", "ir", "->", "op1", ")", "{", "ref", "=", "snap_ref", "(", "map", "[", "n", "++", "]", ")", ";", "break;", "}", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "LJ_SOFTFP32", "&&", "ir", "->", "o", "==", "IR_HIOP", ")", "{", "ref", "++", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "ir", "->", "o", "==", "IR_PVAL", ")", "{", "ref", "=", "ir", "->", "op1", "+", "REF_BIAS", ";", "}", "else", "{", "break;", "}", "rs", "=", "T", "->", "ir", "[", "ref", "]", ".", "prev", ";", "if", "(", "bloomtest", "(", "rfilt", ",", "ref", ")", ")", "rs", "=", "snap_renameref", "(", "T", ",", "snapno", ",", "ref", ",", "rs", ")", ";", "ir", "->", "prev", "=", "(", "uint16_t", ")", "rs", ";", "lua_assert", "(", "regsp_used", "(", "rs", ")", ")", ";", "}", "return", "ir", ";", "}'" ]

[ "Restore", "a", "value", "from", "the", "trace", "exit", "state" ]

[ "'static", "void", "snap_restoreval", "(", "jit_State", "*", "J", ",", "GCtrace", "*", "T", ",", "ExitState", "*", "ex", ",", "SnapNo", "snapno", ",", "BloomFilter", "rfilt", ",", "IRRef", "ref", ",", "TValue", "*", "o", ")", "{", "IRIns", "*", "ir", "=", "&", "T", "->", "ir", "[", "ref", "]", ";", "IRType1", "t", "=", "ir", "->", "t", ";", "RegSP", "rs", "=", "ir", "->", "prev", ";", "if", "(", "irref_isk", "(", "ref", ")", ")", "{", "/*", "Restore", "constant", "slot.", "*/", "lj_ir_kvalue", "(", "J", "->", "L", ",", "o", ",", "ir", ")", ";", "return", ";", "}", "if", "(", "LJ_UNLIKELY", "(", "bloomtest", "(", "rfilt", ",", "ref", ")", ")", ")", "rs", "=", "snap_renameref", "(", "T", ",", "snapno", ",", "ref", ",", "rs", ")", ";", "if", "(", "ra_hasspill", "(", "regsp_spill", "(", "rs", ")", ")", ")", "{", "/*", "Restore", "from", "spill", "slot.", "*/", "int32_t", "*", "sps", "=", "&", "ex", "->", "spill", "[", "regsp_spill", "(", "rs", ")", "]", ";", "if", "(", "irt_isinteger", "(", "t", ")", ")", "{", "setintV", "(", "o", ",", "*", "sps", ")", ";", "#", "if", "!", "LJ_SOFTFP32", "}", "<if", "type=\"elseif\">", "else", "if", "(", "irt_isnum", "(", "t", ")", ")", "{", "o", "->", "u64", "=", "*", "(", "uint64_t", "*", ")", "sps", ";", "#", "endif", "#", "if", "LJ_64", "&&", "!", "LJ_GC64", "}", "<if", "type=\"elseif\">", "else", "if", "(", "irt_islightud", "(", "t", ")", ")", "{", "/*", "64", "bit", "lightuserdata", "which", "may", "escape", "already", "has", "the", "tag", "bits.", "*/", "o", "->", "u64", "=", "*", "(", "uint64_t", "*", ")", "sps", ";", "#", "endif", "}", "else", "{", "lua_assert", "(", "!", "irt_ispri", "(", "t", ")", ")", ";", "/*", "PRI", "refs", "never", "have", "a", "spill", "slot.", "*/", "setgcV", "(", "J", "->", "L", ",", "o", ",", "(", "GCobj", "*", ")", "(", "uintptr_t", ")", "*", "(", "GCSize", "*", ")", "sps", ",", "irt_toitype", "(", "t", ")", ")", ";", "}", "}", "else", "{", "/*", "Restore", "from", "register.", "*/", "Reg", "r", "=", "regsp_reg", "(", "rs", ")", ";", "if", "(", "ra_noreg", "(", "r", ")", ")", "{", "lua_assert", "(", "ir", "->", "o", "==", "IR_CONV", "&&", "ir", "->", "op2", "==", "IRCONV_NUM_INT", ")", ";", "snap_restoreval", "(", "J", ",", "T", ",", "ex", ",", "snapno", ",", "rfilt", ",", "ir", "->", "op1", ",", "o", ")", ";", "if", "(", "LJ_DUALNUM", ")", "setnumV", "(", "o", ",", "(", "lua_Number", ")", "intV", "(", "o", ")", ")", ";", "return", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "irt_isinteger", "(", "t", ")", ")", "{", "setintV", "(", "o", ",", "(", "int32_t", ")", "ex", "->", "gpr", "[", "r", "-", "RID_MIN_GPR", "]", ")", ";", "#", "if", "!", "LJ_SOFTFP", "}", "<if", "type=\"elseif\">", "else", "if", "(", "irt_isnum", "(", "t", ")", ")", "{", "setnumV", "(", "o", ",", "ex", "->", "fpr", "[", "r", "-", "RID_MIN_FPR", "]", ")", ";", "#", "elif", "LJ_64", "/*", "&&", "LJ_SOFTFP", "*/", "}", "<if", "type=\"elseif\">", "else", "if", "(", "irt_isnum", "(", "t", ")", ")", "{", "o", "->", "u64", "=", "ex", "->", "gpr", "[", "r", "-", "RID_MIN_GPR", "]", ";", "#", "endif", "#", "if", "LJ_64", "&&", "!", "LJ_GC64", "}", "<if", "type=\"elseif\">", "else", "if", "(", "irt_is64", "(", "t", ")", ")", "{", "/*", "64", "bit", "values", "that", "already", "have", "the", "tag", "bits.", "*/", "o", "->", "u64", "=", "ex", "->", "gpr", "[", "r", "-", "RID_MIN_GPR", "]", ";", "#", "endif", "}", "<if", "type=\"elseif\">", "else", "if", "(", "irt_ispri", "(", "t", ")", ")", "{", "setpriV", "(", "o", ",", "irt_toitype", "(", "t", ")", ")", ";", "}", "else", "{", "setgcV", "(", "J", "->", "L", ",", "o", ",", "(", "GCobj", "*", ")", "ex", "->", "gpr", "[", "r", "-", "RID_MIN_GPR", "]", ",", "irt_toitype", "(", "t", ")", ")", ";", "}", "}", "}'" ]

[ "Add", "or", "merge", "a", "snapshot" ]

[ "'void", "lj_snap_add", "(", "jit_State", "*", "J", ")", "{", "MSize", "nsnap", "=", "J", "->", "cur", ".", "nsnap", ";", "MSize", "nsnapmap", "=", "J", "->", "cur", ".", "nsnapmap", ";", "/*", "Merge", "if", "no", "ins.", "inbetween", "or", "if", "requested", "and", "no", "guard", "inbetween.", "*/", "if", "(", "(", "nsnap", ">", "0", "&&", "J", "->", "cur", ".", "snap", "[", "nsnap", "-", "1", "]", ".", "ref", "==", "J", "->", "cur", ".", "nins", ")", "||", "(", "J", "->", "mergesnap", "&&", "!", "irt_isguard", "(", "J", "->", "guardemit", ")", ")", ")", "{", "if", "(", "nsnap", "==", "1", ")", "{", "/*", "But", "preserve", "snap", "#0", "PC.", "*/", "emitir_raw", "(", "IRT", "(", "IR_NOP", ",", "IRT_NIL", ")", ",", "0", ",", "0", ")", ";", "goto", "nomerge", ";", "}", "nsnapmap", "=", "J", "->", "cur", ".", "snap", "[", "--", "nsnap", "]", ".", "mapofs", ";", "}", "else", "{", "nomerge", ":", "lj_snap_grow_buf", "(", "J", ",", "nsnap", "+", "1", ")", ";", "J", "->", "cur", ".", "nsnap", "=", "(", "uint16_t", ")", "(", "nsnap", "+", "1", ")", ";", "}", "J", "->", "mergesnap", "=", "0", ";", "J", "->", "guardemit", ".", "irt", "=", "0", ";", "snapshot_stack", "(", "J", ",", "&", "J", "->", "cur", ".", "snap", "[", "nsnap", "]", ",", "nsnapmap", ")", ";", "}'" ]

[ "Restore", "interpreter", "state", "from", "exit", "state", "with", "the", "help", "of", "a", "snapshot" ]

[ "'const", "BCIns", "*", "lj_snap_restore", "(", "jit_State", "*", "J", ",", "void", "*", "exptr", ")", "{", "ExitState", "*", "ex", "=", "(", "ExitState", "*", ")", "exptr", ";", "SnapNo", "snapno", "=", "J", "->", "exitno", ";", "/*", "For", "now,", "snapno", "==", "exitno.", "*/", "GCtrace", "*", "T", "=", "traceref", "(", "J", ",", "J", "->", "parent", ")", ";", "SnapShot", "*", "snap", "=", "&", "T", "->", "snap", "[", "snapno", "]", ";", "MSize", "n", ",", "<type", "ref=\"prev\"/>", "nent", "=", "snap", "->", "nent", ";", "SnapEntry", "*", "map", "=", "&", "T", "->", "snapmap", "[", "snap", "->", "mapofs", "]", ";", "#", "if", "!", "LJ_FR2", "||", "defined", "(", "LUA_USE_ASSERT", ")", "SnapEntry", "*", "flinks", "=", "&", "T", "->", "snapmap", "[", "snap_nextofs", "(", "T", ",", "snap", ")", "-", "1", "-", "LJ_FR2", "]", ";", "#", "endif", "#", "if", "!", "LJ_FR2", "ptrdiff_t", "ftsz0", ";", "#", "endif", "TValue", "*", "frame", ";", "BloomFilter", "rfilt", "=", "snap_renamefilter", "(", "T", ",", "snapno", ")", ";", "const", "BCIns", "*", "pc", "=", "snap_pc", "(", "&", "map", "[", "nent", "]", ")", ";", "lua_State", "*", "L", "=", "J", "->", "L", ";", "/*", "Set", "interpreter", "PC", "to", "the", "next", "PC", "to", "get", "correct", "error", "messages.", "*/", "setcframe_pc", "(", "cframe_raw", "(", "L", "->", "cframe", ")", ",", "pc", "+", "1", ")", ";", "/*", "Make", "sure", "the", "stack", "is", "big", "enough", "for", "the", "slots", "from", "the", "snapshot.", "*/", "if", "(", "LJ_UNLIKELY", "(", "L", "->", "base", "+", "snap", "->", "topslot", ">=", "tvref", "(", "L", "->", "maxstack", ")", ")", ")", "{", "L", "->", "top", "=", "curr_topL", "(", "L", ")", ";", "lj_state_growstack", "(", "L", ",", "snap", "->", "topslot", "-", "curr_proto", "(", "L", ")", "->", "framesize", ")", ";", "}", "/*", "Fill", "stack", "slots", "with", "data", "from", "the", "registers", "and", "spill", "slots.", "*/", "frame", "=", "L", "->", "base", "-", "1", "-", "LJ_FR2", ";", "#", "if", "!", "LJ_FR2", "ftsz0", "=", "frame_ftsz", "(", "frame", ")", ";", "/*", "Preserve", "link", "to", "previous", "frame", "in", "slot", "#0.", "*/", "#", "endif", "for", "(", "n", "=", "0", ";", "n", "<", "nent", ";", "n", "++", ")", "{", "SnapEntry", "sn", "=", "map", "[", "n", "]", ";", "if", "(", "!", "(", "sn", "&", "SNAP_NORESTORE", ")", ")", "{", "TValue", "*", "o", "=", "&", "frame", "[", "snap_slot", "(", "sn", ")", "]", ";", "IRRef", "ref", "=", "snap_ref", "(", "sn", ")", ";", "IRIns", "*", "ir", "=", "&", "T", "->", "ir", "[", "ref", "]", ";", "if", "(", "ir", "->", "r", "==", "RID_SUNK", ")", "{", "MSize", "j", ";", "for", "(", "j", "=", "0", ";", "j", "<", "n", ";", "j", "++", ")", "if", "(", "snap_ref", "(", "map", "[", "j", "]", ")", "==", "ref", ")", "{", "/*", "De-duplicate", "sunk", "allocations.", "*/", "copyTV", "(", "L", ",", "o", ",", "&", "frame", "[", "snap_slot", "(", "map", "[", "j", "]", ")", "]", ")", ";", "goto", "dupslot", ";", "}", "snap_unsink", "(", "J", ",", "T", ",", "ex", ",", "snapno", ",", "rfilt", ",", "ir", ",", "o", ")", ";", "dupslot", ":", "continue;", "}", "snap_restoreval", "(", "J", ",", "T", ",", "ex", ",", "snapno", ",", "rfilt", ",", "ref", ",", "o", ")", ";", "if", "(", "LJ_SOFTFP32", "&&", "(", "sn", "&", "SNAP_SOFTFPNUM", ")", "&&", "tvisint", "(", "o", ")", ")", "{", "TValue", "tmp", ";", "snap_restoreval", "(", "J", ",", "T", ",", "ex", ",", "snapno", ",", "rfilt", ",", "ref", "+", "1", ",", "&", "tmp", ")", ";", "o", "->", "u32", ".", "hi", "=", "tmp", ".", "u32", ".", "lo", ";", "#", "if", "!", "LJ_FR2", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "sn", "&", "(", "SNAP_CONT", "|", "SNAP_FRAME", ")", ")", ")", "{", "/*", "Overwrite", "tag", "with", "frame", "link.", "*/", "setframe_ftsz", "(", "o", ",", "snap_slot", "(", "sn", ")", "!=", "0", "?", "(", "int32_t", ")", "*", "flinks", "--", ":", "ftsz0", ")", ";", "L", "->", "base", "=", "o", "+", "1", ";", "#", "endif", "}", "}", "}", "#", "if", "LJ_FR2", "L", "->", "base", "+=", "(", "map", "[", "nent", "+", "LJ_BE", "]", "&", "0xff", ")", ";", "#", "endif", "lua_assert", "(", "map", "+", "nent", "==", "flinks", ")", ";", "/*", "Compute", "current", "stack", "top.", "*/", "switch", "(", "bc_op", "(", "*", "pc", ")", ")", "{", "default:", "if", "(", "bc_op", "(", "*", "pc", ")", "<", "BC_FUNCF", ")", "{", "L", "->", "top", "=", "curr_topL", "(", "L", ")", ";", "break;", "}", "/*", "fallthrough", "*/", "case", "BC_CALLM", ":", "case", "BC_CALLMT", ":", "case", "BC_RETM", ":", "case", "BC_TSETM", ":", "L", "->", "top", "=", "frame", "+", "snap", "->", "nslots", ";", "break;", "}", "return", "pc", ";", "}'" ]

[ "Check", "whether", "a", "sunk", "store", "corresponds", "to", "an", "allocation" ]

[ "'static", "int", "snap_sunk_store2", "(", "GCtrace", "*", "T", ",", "IRIns", "*", "ira", ",", "IRIns", "*", "irs", ")", "{", "if", "(", "irs", "->", "o", "==", "IR_ASTORE", "||", "irs", "->", "o", "==", "IR_HSTORE", "||", "irs", "->", "o", "==", "IR_FSTORE", "||", "irs", "->", "o", "==", "IR_XSTORE", ")", "{", "IRIns", "*", "irk", "=", "&", "T", "->", "ir", "[", "irs", "->", "op1", "]", ";", "if", "(", "irk", "->", "o", "==", "IR_AREF", "||", "irk", "->", "o", "==", "IR_HREFK", ")", "irk", "=", "&", "T", "->", "ir", "[", "irk", "->", "op1", "]", ";", "return", "(", "&", "T", "->", "ir", "[", "irk", "->", "op1", "]", "==", "ira", ")", ";", "}", "return", "0", ";", "}'" ]

[ "Find", "unused", "slots", "with", "reachingdefinitions", "bytecode", "dataflow", "analysis" ]

[ "'static", "BCReg", "snap_usedef", "(", "jit_State", "*", "J", ",", "uint8_t", "*", "udf", ",", "const", "BCIns", "*", "pc", ",", "BCReg", "maxslot", ")", "{", "BCReg", "s", ";", "GCobj", "*", "o", ";", "if", "(", "maxslot", "==", "0", ")", "return", "0", ";", "#", "ifdef", "LUAJIT_USE_VALGRIND", "/*", "Avoid", "errors", "for", "harmless", "reads", "beyond", "maxslot.", "*/", "memset", "(", "udf", ",", "1", ",", "SNAP_USEDEF_SLOTS", ")", ";", "#", "else", "memset", "(", "udf", ",", "1", ",", "maxslot", ")", ";", "#", "endif", "/*", "Treat", "open", "upvalues", "as", "used.", "*/", "o", "=", "gcref", "(", "J", "->", "L", "->", "openupval", ")", ";", "while", "(", "o", ")", "{", "if", "(", "uvval", "(", "gco2uv", "(", "o", ")", ")", "<", "J", "->", "L", "->", "base", ")", "break;", "udf", "[", "uvval", "(", "gco2uv", "(", "o", ")", ")", "-", "J", "->", "L", "->", "base", "]", "=", "0", ";", "o", "=", "gcref", "(", "o", "->", "gch", ".", "nextgc", ")", ";", "}", "#", "define", "USE_SLOT", "(", "s", ")", "udf[(s)]", "&=", "~1", "#", "define", "DEF_SLOT", "(", "s", ")", "udf[(s)]", "*=", "3", "/*", "Scan", "through", "following", "bytecode", "and", "check", "for", "uses/defs.", "*/", "lua_assert", "(", "pc", ">=", "proto_bc", "(", "J", "->", "pt", ")", "&&", "pc", "<", "proto_bc", "(", "J", "->", "pt", ")", "+", "J", "->", "pt", "->", "sizebc", ")", ";", "for", "(", ";", ";", ")", "{", "BCIns", "ins", "=", "*", "pc", "++", ";", "BCOp", "op", "=", "bc_op", "(", "ins", ")", ";", "switch", "(", "bcmode_b", "(", "op", ")", ")", "{", "case", "BCMvar", ":", "USE_SLOT", "(", "bc_b", "(", "ins", ")", ")", ";", "break;", "default:", "break;", "}", "switch", "(", "bcmode_c", "(", "op", ")", ")", "{", "case", "BCMvar", ":", "USE_SLOT", "(", "bc_c", "(", "ins", ")", ")", ";", "break;", "case", "BCMrbase", ":", "lua_assert", "(", "op", "==", "BC_CAT", ")", ";", "for", "(", "s", "=", "bc_b", "(", "ins", ")", ";", "s", "<=", "bc_c", "(", "ins", ")", ";", "s", "++", ")", "USE_SLOT", "(", "s", ")", ";", "for", "(", ";", "s", "<", "maxslot", ";", "s", "++", ")", "DEF_SLOT", "(", "s", ")", ";", "break;", "case", "BCMjump", ":", "handle_jump", ":", "{", "BCReg", "minslot", "=", "bc_a", "(", "ins", ")", ";", "if", "(", "op", ">=", "BC_FORI", "&&", "op", "<=", "BC_JFORL", ")", "minslot", "+=", "FORL_EXT", ";", "<if", "type=\"elseif\">", "else", "if", "(", "op", ">=", "BC_ITERL", "&&", "op", "<=", "BC_JITERL", ")", "minslot", "+=", "bc_b", "(", "pc", "[", "-", "2", "]", ")", "-", "1", ";", "<if", "type=\"elseif\">", "else", "if", "(", "op", "==", "BC_UCLO", ")", "{", "pc", "+=", "bc_j", "(", "ins", ")", ";", "break;", "}", "for", "(", "s", "=", "minslot", ";", "s", "<", "maxslot", ";", "s", "++", ")", "DEF_SLOT", "(", "s", ")", ";", "return", "minslot", "<", "maxslot", "?", "minslot", ":", "maxslot", ";", "}", "case", "BCMlit", ":", "if", "(", "op", "==", "BC_JFORL", "||", "op", "==", "BC_JITERL", "||", "op", "==", "BC_JLOOP", ")", "{", "goto", "handle_jump", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "bc_isret", "(", "op", ")", ")", "{", "BCReg", "top", "=", "op", "==", "BC_RETM", "?", "maxslot", ":", "(", "bc_a", "(", "ins", ")", "+", "bc_d", "(", "ins", ")", "-", "1", ")", ";", "for", "(", "s", "=", "0", ";", "s", "<", "bc_a", "(", "ins", ")", ";", "s", "++", ")", "DEF_SLOT", "(", "s", ")", ";", "for", "(", ";", "s", "<", "top", ";", "s", "++", ")", "USE_SLOT", "(", "s", ")", ";", "for", "(", ";", "s", "<", "maxslot", ";", "s", "++", ")", "DEF_SLOT", "(", "s", ")", ";", "return", "0", ";", "}", "break;", "case", "BCMfunc", ":", "return", "maxslot", ";", "/*", "NYI:", "will", "abort,", "anyway.", "*/", "default:", "break;", "}", "switch", "(", "bcmode_a", "(", "op", ")", ")", "{", "case", "BCMvar", ":", "USE_SLOT", "(", "bc_a", "(", "ins", ")", ")", ";", "break;", "case", "BCMdst", ":", "if", "(", "!", "(", "op", "==", "BC_ISTC", "||", "op", "==", "BC_ISFC", ")", ")", "DEF_SLOT", "(", "bc_a", "(", "ins", ")", ")", ";", "break;", "case", "BCMbase", ":", "if", "(", "op", ">=", "BC_CALLM", "&&", "op", "<=", "BC_VARG", ")", "{", "BCReg", "top", "=", "(", "op", "==", "BC_CALLM", "||", "op", "==", "BC_CALLMT", "||", "bc_c", "(", "ins", ")", "==", "0", ")", "?", "maxslot", ":", "(", "bc_a", "(", "ins", ")", "+", "bc_c", "(", "ins", ")", "+", "LJ_FR2", ")", ";", "if", "(", "LJ_FR2", ")", "DEF_SLOT", "(", "bc_a", "(", "ins", ")", "+", "1", ")", ";", "s", "=", "bc_a", "(", "ins", ")", "-", "(", "(", "op", "==", "BC_ITERC", "||", "op", "==", "BC_ITERN", ")", "?", "3", ":", "0", ")", ";", "for", "(", ";", "s", "<", "top", ";", "s", "++", ")", "USE_SLOT", "(", "s", ")", ";", "for", "(", ";", "s", "<", "maxslot", ";", "s", "++", ")", "DEF_SLOT", "(", "s", ")", ";", "if", "(", "op", "==", "BC_CALLT", "||", "op", "==", "BC_CALLMT", ")", "{", "for", "(", "s", "=", "0", ";", "s", "<", "bc_a", "(", "ins", ")", ";", "s", "++", ")", "DEF_SLOT", "(", "s", ")", ";", "return", "0", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "op", "==", "BC_KNIL", ")", "{", "for", "(", "s", "=", "bc_a", "(", "ins", ")", ";", "s", "<=", "bc_d", "(", "ins", ")", ";", "s", "++", ")", "DEF_SLOT", "(", "s", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "op", "==", "BC_TSETM", ")", "{", "for", "(", "s", "=", "bc_a", "(", "ins", ")", "-", "1", ";", "s", "<", "maxslot", ";", "s", "++", ")", "USE_SLOT", "(", "s", ")", ";", "}", "break;", "default:", "break;", "}", "lua_assert", "(", "pc", ">=", "proto_bc", "(", "J", "->", "pt", ")", "&&", "pc", "<", "proto_bc", "(", "J", "->", "pt", ")", "+", "J", "->", "pt", "->", "sizebc", ")", ";", "}", "#", "undef", "USE_SLOT", "#", "undef", "DEF_SLOT", "return", "0", ";", "/*", "unreachable", "*/", "}'" ]

[ "Encrypt", "Decrypt", "content", "key", "in", "PWRI", "recipient", "info" ]

[ "'int", "cms_RecipientInfo_pwri_crypt", "(", "CMS_ContentInfo", "*", "cms", ",", "CMS_RecipientInfo", "*", "ri", ",", "int", "en_de", ")", "{", "CMS_EncryptedContentInfo", "*", "ec", ";", "CMS_PasswordRecipientInfo", "*", "pwri", ";", "int", "r", "=", "0", ";", "X509_ALGOR", "*", "algtmp", ",", "<type", "ref=\"prev\">", "*", "kekalg", "=", "NULL", ";", "EVP_CIPHER_CTX", "*", "kekctx", "=", "NULL", ";", "const", "EVP_CIPHER", "*", "kekcipher", ";", "unsigned", "char", "*", "key", "=", "NULL", ";", "size_t", "keylen", ";", "ec", "=", "cms", "->", "d", ".", "envelopedData", "->", "encryptedContentInfo", ";", "pwri", "=", "ri", "->", "d", ".", "pwri", ";", "if", "(", "!", "pwri", "->", "pass", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "CMS_R_NO_PASSWORD", ")", ";", "return", "0", ";", "}", "algtmp", "=", "pwri", "->", "keyEncryptionAlgorithm", ";", "if", "(", "!", "algtmp", "||", "OBJ_obj2nid", "(", "algtmp", "->", "algorithm", ")", "!=", "NID_id_alg_PWRI_KEK", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM", ")", ";", "return", "0", ";", "}", "kekalg", "=", "ASN1_TYPE_unpack_sequence", "(", "ASN1_ITEM_rptr", "(", "X509_ALGOR", ")", ",", "algtmp", "->", "parameter", ")", ";", "if", "(", "kekalg", "==", "NULL", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER", ")", ";", "return", "0", ";", "}", "kekcipher", "=", "EVP_get_cipherbyobj", "(", "kekalg", "->", "algorithm", ")", ";", "if", "(", "!", "kekcipher", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "CMS_R_UNKNOWN_CIPHER", ")", ";", "return", "0", ";", "}", "kekctx", "=", "EVP_CIPHER_CTX_new", "()", ";", "if", "(", "kekctx", "==", "NULL", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "return", "0", ";", "}", "/*", "Fixup", "cipher", "based", "on", "AlgorithmIdentifier", "to", "set", "IV", "etc", "*/", "if", "(", "!", "EVP_CipherInit_ex", "(", "kekctx", ",", "kekcipher", ",", "NULL", ",", "NULL", ",", "NULL", ",", "en_de", ")", ")", "goto", "err", ";", "EVP_CIPHER_CTX_set_padding", "(", "kekctx", ",", "0", ")", ";", "if", "(", "EVP_CIPHER_asn1_to_param", "(", "kekctx", ",", "kekalg", "->", "parameter", ")", "<=", "0", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR", ")", ";", "goto", "err", ";", "}", "algtmp", "=", "pwri", "->", "keyDerivationAlgorithm", ";", "/*", "Finish", "password", "based", "key", "derivation", "to", "setup", "key", "in", "\"ctx\"", "*/", "if", "(", "EVP_PBE_CipherInit", "(", "algtmp", "->", "algorithm", ",", "(", "char", "*", ")", "pwri", "->", "pass", ",", "pwri", "->", "passlen", ",", "algtmp", "->", "parameter", ",", "kekctx", ",", "en_de", ")", "<", "0", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "ERR_R_EVP_LIB", ")", ";", "goto", "err", ";", "}", "/*", "Finally", "wrap/unwrap", "the", "key", "*/", "if", "(", "en_de", ")", "{", "if", "(", "!", "kek_wrap_key", "(", "NULL", ",", "&", "keylen", ",", "ec", "->", "key", ",", "ec", "->", "keylen", ",", "kekctx", ")", ")", "goto", "err", ";", "key", "=", "OPENSSL_malloc", "(", "keylen", ")", ";", "if", "(", "key", "==", "NULL", ")", "goto", "err", ";", "if", "(", "!", "kek_wrap_key", "(", "key", ",", "&", "keylen", ",", "ec", "->", "key", ",", "ec", "->", "keylen", ",", "kekctx", ")", ")", "goto", "err", ";", "pwri", "->", "encryptedKey", "->", "data", "=", "key", ";", "pwri", "->", "encryptedKey", "->", "length", "=", "keylen", ";", "}", "else", "{", "key", "=", "OPENSSL_malloc", "(", "pwri", "->", "encryptedKey", "->", "length", ")", ";", "if", "(", "key", "==", "NULL", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "goto", "err", ";", "}", "if", "(", "!", "kek_unwrap_key", "(", "key", ",", "&", "keylen", ",", "pwri", "->", "encryptedKey", "->", "data", ",", "pwri", "->", "encryptedKey", "->", "length", ",", "kekctx", ")", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT", ",", "CMS_R_UNWRAP_FAILURE", ")", ";", "goto", "err", ";", "}", "OPENSSL_clear_free", "(", "ec", "->", "key", ",", "ec", "->", "keylen", ")", ";", "ec", "->", "key", "=", "key", ";", "ec", "->", "keylen", "=", "keylen", ";", "}", "r", "=", "1", ";", "err", ":", "EVP_CIPHER_CTX_free", "(", "kekctx", ")", ";", "if", "(", "!", "r", ")", "OPENSSL_free", "(", "key", ")", ";", "X509_ALGOR_free", "(", "kekalg", ")", ";", "return", "r", ";", "}'" ]

[ "Functions", "for", "both", "dumpkeys", "and", "loadkeys" ]

[ "'void", "lk_list_charsets", "(", "FILE", "*", "f", ")", "{", "size_t", "lth", ";", "int", "ct", ";", "unsigned", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "const", "char", "*", "mm", "[]", "=", "{", "\"iso-8859-\"", ",", "\"koi8-\"", "}", ";", "for", "(", "j", "=", "0", ";", "j", "<", "sizeof", "(", "mm", ")", "/", "sizeof", "(", "mm", "[", "0", "]", ")", ";", "j", "++", ")", "{", "if", "(", "j", ")", "fprintf", "(", "f", ",", "\",\"", ")", ";", "fprintf", "(", "f", ",", "\"%s{\"", ",", "mm", "[", "j", "]", ")", ";", "ct", "=", "0", ";", "lth", "=", "strlen", "(", "mm", "[", "j", "]", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "charsets_size", ";", "i", "++", ")", "{", "if", "(", "!", "strncmp", "(", "charsets", "[", "i", "]", ".", "charset", ",", "mm", "[", "j", "]", ",", "lth", ")", ")", "{", "if", "(", "ct", "++", ")", "fprintf", "(", "f", ",", "\",\"", ")", ";", "fprintf", "(", "f", ",", "\"%s\"", ",", "charsets", "[", "i", "]", ".", "charset", "+", "lth", ")", ";", "}", "}", "fprintf", "(", "f", ",", "\"}\"", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "charsets_size", ";", "i", "++", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "sizeof", "(", "mm", ")", "/", "sizeof", "(", "mm", "[", "0", "]", ")", ";", "j", "++", ")", "{", "lth", "=", "strlen", "(", "mm", "[", "j", "]", ")", ";", "if", "(", "!", "strncmp", "(", "charsets", "[", "i", "]", ".", "charset", ",", "mm", "[", "j", "]", ",", "lth", ")", ")", "goto", "nxti", ";", "}", "fprintf", "(", "f", ",", "\",%s\"", ",", "charsets", "[", "i", "]", ".", "charset", ")", ";", "nxti", ":", ";", "}", "fprintf", "(", "f", ",", "\"\\\"", ")", ";", "}'" ]