Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "tree", "rs6000_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_gpr", ",", "f_fpr", ",", "f_res", ",", "f_ovf", ",", "f_sav", ",", "record", ",", "type_decl", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_V4", ")", "return", "build_pointer_type", "(", "char_type_node", ")", ";", "record", "=", "(", "*", "lang_hooks", ".", "types", ".", "make_type", ")", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_gpr", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"gpr\"", ")", ",", "unsigned_char_type_node", ")", ";", "f_fpr", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"fpr\"", ")", ",", "unsigned_char_type_node", ")", ";", "f_res", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"reserved\"", ")", ",", "short_unsigned_type_node", ")", ";", "f_ovf", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"overflow_arg_area\"", ")", ",", "ptr_type_node", ")", ";", "f_sav", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"reg_save_area\"", ")", ",", "ptr_type_node", ")", ";", "va_list_gpr_counter_field", "=", "f_gpr", ";", "va_list_fpr_counter_field", "=", "f_fpr", ";", "DECL_FIELD_CONTEXT", "(", "f_gpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_fpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_res", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ovf", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_sav", ")", "=", "record", ";", "TYPE_STUB_DECL", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_gpr", ";", "DECL_CHAIN", "(", "f_gpr", ")", "=", "f_fpr", ";", "DECL_CHAIN", "(", "f_fpr", ")", "=", "f_res", ";", "DECL_CHAIN", "(", "f_res", ")", "=", "f_ovf", ";", "DECL_CHAIN", "(", "f_ovf", ")", "=", "f_sav", ";", "layout_type", "(", "record", ")", ";", "return", "build_array_type", "(", "record", ",", "build_index_type", "(", "size_zero_node", ")", ")", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", "." ]

[ "powerpcspe", "\"__va_list_tag\"", "\"gpr\"", "\"fpr\"", "\"reserved\"", "\"overflow_arg_area\"", "\"reg_save_area\"" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "SPIRV" ]

[]

[ "<s>", "virtual", "bool", "isReg", "(", ")", "const", "LLVM_OVERRIDE", "{", "return", "Kind", "==", "KindReg", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "SystemZ" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "{", "return", "Kind", "==", "k_Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "ARM" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "TM", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_440", "||", "Directive", "==", "PPC", "::", "DIR_A2", "||", "Directive", "==", "PPC", "::", "DIR_E500mc", "||", "Directive", "==", "PPC", "::", "DIR_E5500", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "TM", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "TM", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500" ]

[]

[ "<s>", "StringRef", "const", "TPCMCInstrInfo", "::", "getName", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "return", "MCII", ".", "getName", "(", "MCI", ".", "getOpcode", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Assembly Printer\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "AMDGPU", "\"AMDGPU Assembly Printer\"" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_xcoff_visibility", "(", "tree", "decl", ")", "{", "static", "const", "char", "*", "const", "visibility_types", "[", "]", "=", "{", "\"\"", ",", "\",protected\"", ",", "\",hidden\"", ",", "\",internal\"", "}", ";", "enum", "symbol_visibility", "vis", "=", "DECL_VISIBILITY", "(", "decl", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "cgraph_node", "::", "get", "(", "decl", ")", "&&", "cgraph_node", "::", "get", "(", "decl", ")", "->", "instrumentation_clone", "&&", "cgraph_node", "::", "get", "(", "decl", ")", "->", "instrumented_version", ")", "vis", "=", "DECL_VISIBILITY", "(", "cgraph_node", "::", "get", "(", "decl", ")", "->", "instrumented_version", "->", "decl", ")", ";", "return", "visibility_types", "[", "vis", "]", ";", "}", "</s>" ]

[ "Helper", "function", "to", "calculate", "visibility", "of", "a", "DECL", "and", "return", "the", "value", "as", "a", "const", "string", "." ]

[ "powerpcspe", "\"\"", "\",protected\"", "\",hidden\"", "\",internal\"" ]

[]

[ "<s>", "bool", "HexagonSplitDoubleRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Splitting double registers in function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "UUSetMap", "P2Rs", ";", "LoopRegMap", "IRM", ";", "collectIndRegs", "(", "IRM", ")", ";", "partitionRegisters", "(", "P2Rs", ")", ";", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Register partitioning: (partition #0 is fixed)\\n\"", ";", "for", "(", "UUSetMap", "::", "iterator", "I", "=", "P2Rs", ".", "begin", "(", ")", ",", "E", "=", "P2Rs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "dbgs", "(", ")", "<<", "'#'", "<<", "I", "->", "first", "<<", "\" -> \"", ";", "dump_partition", "(", "dbgs", "(", ")", ",", "I", "->", "second", ",", "*", "TRI", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "}", ")", ";", "bool", "Changed", "=", "false", ";", "int", "Limit", "=", "MaxHSDR", ";", "for", "(", "UUSetMap", "::", "iterator", "I", "=", "P2Rs", ".", "begin", "(", ")", ",", "E", "=", "P2Rs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "first", "==", "0", ")", "continue", ";", "if", "(", "Limit", ">=", "0", "&&", "Counter", ">=", "Limit", ")", "break", ";", "USet", "&", "Part", "=", "I", "->", "second", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Calculating profit for partition #\"", "<<", "I", "->", "first", "<<", "'\\n'", ")", ";", "if", "(", "!", "isProfitable", "(", "Part", ",", "IRM", ")", ")", "continue", ";", "Counter", "++", ";", "Changed", "|=", "splitPartition", "(", "Part", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "Hexagon", "Hexagon", "\"Splitting double registers in function: \"", "Hexagon", "\"Register partitioning: (partition #0 is fixed)\\n\"", "\" -> \"", "0", "0", "\"Calculating profit for partition #\"" ]

[]

[ "<s>", "static", "void", "frv_add_insn_to_packet", "(", "rtx", "insn", ")", "{", "struct", "frv_packet_group", "*", "packet_group", ";", "packet_group", "=", "&", "frv_packet", ".", "groups", "[", "frv_unit_groups", "[", "frv_insn_unit", "(", "insn", ")", "]", "]", ";", "packet_group", "->", "insns", "[", "packet_group", "->", "num_insns", "++", "]", "=", "insn", ";", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "++", "]", "=", "insn", ";", "frv_registers_update", "(", "PATTERN", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Add", "instruction", "INSN", "to", "the", "current", "packet", "." ]

[ "frv" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "dag", ";", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "DAG", "->", "TII", ")", ";", "TRI", "=", "static_cast", "<", "const", "R600RegisterInfo", "*", ">", "(", "DAG", "->", "TRI", ")", ";", "MRI", "=", "&", "DAG", "->", "MRI", ";", "CurInstKind", "=", "IDOther", ";", "CurEmitted", "=", "0", ";", "OccupedSlotsMask", "=", "15", ";", "InstKindLimit", "[", "IDAlu", "]", "=", "TII", "->", "getMaxAlusPerClause", "(", ")", ";", "InstKindLimit", "[", "IDOther", "]", "=", "32", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "DAG", "->", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "InstKindLimit", "[", "IDFetch", "]", "=", "ST", ".", "getTexVTXClauseSize", "(", ")", ";", "AluInstCount", "=", "0", ";", "FetchInstCount", "=", "0", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "R600", "0", "15", "32", "0", "0" ]

[]

[ "<s>", "bool", "AArch64AdvSIMDScalar", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64AdvSIMDScalar *****\\n\"", ")", ";", "if", "(", "skipFunction", "(", "*", "mf", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "mf", ".", "getRegInfo", "(", ")", ";", "TII", "=", "mf", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "mf", ".", "begin", "(", ")", ",", "E", "=", "mf", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "processMachineBasicBlock", "(", "&", "*", "I", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "AArch64", "AArch64", "\"***** AArch64AdvSIMDScalar *****\\n\"" ]

[]

[ "<s>", "const", "char", "*", "avr_out_round", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xop", "[", "0", "]", ")", ";", "machine_mode", "imode", "=", "int_mode_for_mode", "(", "mode", ")", ";", "int", "fbit", "=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ";", "double_int", "i_add", "=", "double_int_zero", ".", "set_bit", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ")", ";", "wide_int", "wi_add", "=", "wi", "::", "set_bit_in_zero", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ",", "GET_MODE_PRECISION", "(", "imode", ")", ")", ";", "int", "len_add", "=", "0", ",", "*", "plen_add", "=", "plen", "?", "&", "len_add", ":", "NULL", ";", "int", "len_and", "=", "0", ",", "*", "plen_and", "=", "plen", "?", "&", "len_and", ":", "NULL", ";", "rtx", "xadd", "=", "const_fixed_from_double_int", "(", "i_add", ",", "mode", ")", ";", "rtx", "xpattern", ",", "xsrc", ",", "op", "[", "4", "]", ";", "xsrc", "=", "SIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", "?", "gen_rtx_SS_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ":", "gen_rtx_US_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "xop", "[", "0", "]", ",", "xsrc", ")", ";", "op", "[", "0", "]", "=", "xop", "[", "0", "]", ";", "op", "[", "1", "]", "=", "xop", "[", "1", "]", ";", "op", "[", "2", "]", "=", "xadd", ";", "avr_out_plus", "(", "xpattern", ",", "op", ",", "plen_add", ",", "NULL", ",", "false", ")", ";", "avr_asm_len", "(", "\"rjmp 1f\"", "CR_TAB", "\"0:\"", ",", "NULL", ",", "plen_add", ",", "1", ")", ";", "rtx", "xreg", "=", "simplify_gen_subreg", "(", "imode", ",", "xop", "[", "0", "]", ",", "mode", ",", "0", ")", ";", "rtx", "xmask", "=", "immed_wide_int_const", "(", "-", "wi_add", "-", "wi_add", ",", "imode", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "xreg", ",", "gen_rtx_AND", "(", "imode", ",", "xreg", ",", "xmask", ")", ")", ";", "op", "[", "0", "]", "=", "xreg", ";", "op", "[", "1", "]", "=", "xreg", ";", "op", "[", "2", "]", "=", "xmask", ";", "op", "[", "3", "]", "=", "gen_rtx_SCRATCH", "(", "QImode", ")", ";", "avr_out_bitop", "(", "xpattern", ",", "op", ",", "plen_and", ")", ";", "avr_asm_len", "(", "\"1:\"", ",", "NULL", ",", "plen", ",", "0", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "len_add", "+", "len_and", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "fixed-point", "rounding", ".", "XOP", "[", "0", "]", "=", "XOP", "[", "1", "]", "is", "the", "operand", "to", "round", ".", "XOP", "[", "2", "]", "is", "the", "rounding", "point", ",", "a", "CONST_INT", ".", "The", "function", "prints", "the", "instruction", "sequence", "if", "PLEN", "=", "NULL", "and", "computes", "the", "length", "in", "words", "of", "the", "sequence", "if", "PLEN", "!", "=", "NULL", ".", "Most", "of", "this", "function", "deals", "with", "preparing", "operands", "for", "calls", "to", "`", "avr_out_plus", "'", "and", "`", "avr_out_bitop", "'", "." ]

[ "avr", "0", "1", "2", "1", "2", "0", "0", "4", "1", "1", "0", "0", "0", "1", "1", "2", "\"rjmp 1f\"", "\"0:\"", "1", "0", "0", "0", "1", "2", "3", "\"1:\"", "0", "\"\"" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "return", "runLowerConstExpr", "(", "M", ")", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "SPIRV" ]

[]

[ "<s>", "static", "rtx", "aarch64_move_pointer", "(", "rtx", "pointer", ",", "int", "amount", ")", "{", "rtx", "next", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "pointer", ",", "0", ")", ",", "amount", ")", ";", "return", "adjust_automodify_address", "(", "pointer", ",", "GET_MODE", "(", "pointer", ")", ",", "next", ",", "amount", ")", ";", "}", "</s>" ]

[ "Return", "a", "new", "RTX", "holding", "the", "result", "of", "moving", "POINTER", "forward", "by", "AMOUNT", "bytes", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "unsigned", "AMDGPURegisterBankInfo", "::", "copyCost", "(", "const", "RegisterBank", "&", "Dst", ",", "const", "RegisterBank", "&", "Src", ",", "unsigned", "Size", ")", "const", "{", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "&&", "(", "isVectorRegisterBank", "(", "Src", ")", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", ")", "{", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "}", "if", "(", "Size", "==", "1", "&&", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", ")", "&&", "(", "isVectorRegisterBank", "(", "Src", ")", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "AGPRRegBankID", "&&", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "AGPRRegBankID", ")", "return", "4", ";", "return", "RegisterBankInfo", "::", "copyCost", "(", "Dst", ",", "Src", ",", "Size", ")", ";", "}", "</s>" ]

[ "Get", "the", "cost", "of", "a", "copy", "from", "B", "to", "A", ",", "or", "put", "differently", ",", "get", "the", "cost", "of", "A", "=", "COPY", "B", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::SGPRRegBankID", "AMDGPU::VCCRegBankID", "1", "AMDGPU::SGPRRegBankID", "AMDGPU::SGPRRegBankID", "AMDGPU::VCCRegBankID", "AMDGPU::AGPRRegBankID", "AMDGPU::AGPRRegBankID", "4" ]

[]

[ "<s>", "bool", "MipsSubtarget", "::", "enablePostRAScheduler", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "MCSection", "*", "LanaiTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "Align", "&", "Alignment", ")", "const", "{", "if", "(", "isConstantInSmallSection", "(", "DL", ",", "C", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "getSectionForConstant", "(", "DL", ",", "Kind", ",", "C", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "static", "bool", "iq2000_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "(", "int_size_in_bytes", "(", "type", ")", ">", "(", "2", "*", "UNITS_PER_WORD", ")", ")", "||", "(", "int_size_in_bytes", "(", "type", ")", "==", "-", "1", ")", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "." ]

[ "iq2000", "2", "1" ]

[]

[ "<s>", "void", "RISCVDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "SDLoc", "DL", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "DL", ",", "Subtarget", ".", "isRV64", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ";", "unsigned", "Opc", "=", "Subtarget", ".", "isRV64", "(", ")", "?", "RISCV", "::", "ADDI64", ":", "RISCV", "::", "ADDI", ";", "EVT", "VT", "=", "Subtarget", ".", "isRV64", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "{", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ",", "imm", ")", ";", "return", ";", "}", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "DL", ",", "VT", ",", "TFI", ",", "imm", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "return", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "RISCV", "RISCV", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "ISD::FrameIndex", "0", "MVT::i64", "MVT::i32", "RISCV::ADDI64", "RISCV::ADDI", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "VE", "VE", "\"Should not custom lower this!\"", "ISD::BlockAddress", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::VASTART", "ISD::VAARG" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "1", ",", "false", ",", "false", ",", "true", ",", "true", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "ARM", "ARM", "1", "ARM" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "assert", "(", "TheModule", "==", "&", "M", ")", ";", "TheModule", "=", "nullptr", ";", "EHLinkRegistrationTy", "=", "nullptr", ";", "CXXEHRegistrationTy", "=", "nullptr", ";", "SEHRegistrationTy", "=", "nullptr", ";", "return", "false", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "X86" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "StackAlignment", "(", "16", ")", ",", "DarwinDirective", "(", "PPC", "::", "DIR_NONE", ")", ",", "IsGigaProcessor", "(", "false", ")", ",", "Has64BitSupport", "(", "false", ")", ",", "Use64BitRegs", "(", "false", ")", ",", "IsPPC64", "(", "is64Bit", ")", ",", "HasAltivec", "(", "false", ")", ",", "HasFSQRT", "(", "false", ")", ",", "HasSTFIWX", "(", "false", ")", ",", "IsBookE", "(", "false", ")", ",", "HasLazyResolverStubs", "(", "false", ")", ",", "IsJITCodeModel", "(", "false", ")", ",", "TargetTriple", "(", "TT", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "if", "(", "CPUName", "==", "\"generic\"", ")", "CPUName", "=", "GetCurrentPowerPCCPU", "(", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "is64Bit", ")", "{", "Has64BitSupport", "=", "true", ";", "Use64BitRegs", "=", "true", ";", "}", "if", "(", "use64BitRegs", "(", ")", "&&", "!", "has64BitSupport", "(", ")", ")", "Use64BitRegs", "=", "false", ";", "if", "(", "isDarwin", "(", ")", ")", "HasLazyResolverStubs", "=", "true", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "16", "PPC::DIR_NONE", "PPC", "\"generic\"", "\"generic\"" ]

[]

[ "<s>", "const", "char", "*", "pa_output_block_clear", "(", "rtx", "*", "operands", ",", "int", "size_is_constant", "ATTRIBUTE_UNUSED", ")", "{", "int", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "unsigned", "long", "n_bytes", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "align", ">", "(", "TARGET_64BIT", "?", "8", ":", "4", ")", ")", "align", "=", "(", "TARGET_64BIT", "?", "8", ":", "4", ")", ";", "switch", "(", "align", ")", "{", "case", "8", ":", "operands", "[", "2", "]", "=", "GEN_INT", "(", "n_bytes", "-", "16", ")", ";", "output_asm_insn", "(", "\"ldi %2,%1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"std,ma %%r0,8(%0)\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"addib,>= -16,%1,.-4\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"std,ma %%r0,8(%0)\"", ",", "operands", ")", ";", "if", "(", "n_bytes", "%", "16", "!=", "0", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "n_bytes", "%", "8", ")", ";", "if", "(", "n_bytes", "%", "16", ">=", "8", ")", "output_asm_insn", "(", "\"std,ma %%r0,8(%0)\"", ",", "operands", ")", ";", "if", "(", "n_bytes", "%", "8", "!=", "0", ")", "output_asm_insn", "(", "\"stdby,e %%r0,%2(%0)\"", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "case", "4", ":", "operands", "[", "2", "]", "=", "GEN_INT", "(", "n_bytes", "-", "8", ")", ";", "output_asm_insn", "(", "\"ldi %2,%1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"{stws|stw},ma %%r0,4(%0)\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"addib,>= -8,%1,.-4\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"{stws|stw},ma %%r0,4(%0)\"", ",", "operands", ")", ";", "if", "(", "n_bytes", "%", "8", "!=", "0", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "n_bytes", "%", "4", ")", ";", "if", "(", "n_bytes", "%", "8", ">=", "4", ")", "output_asm_insn", "(", "\"{stws|stw},ma %%r0,4(%0)\"", ",", "operands", ")", ";", "if", "(", "n_bytes", "%", "4", "!=", "0", ")", "output_asm_insn", "(", "\"{stbys|stby},e %%r0,%2(%0)\"", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "case", "2", ":", "operands", "[", "2", "]", "=", "GEN_INT", "(", "n_bytes", "-", "4", ")", ";", "output_asm_insn", "(", "\"ldi %2,%1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"{sths|sth},ma %%r0,2(%0)\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"addib,>= -4,%1,.-4\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"{sths|sth},ma %%r0,2(%0)\"", ",", "operands", ")", ";", "if", "(", "n_bytes", "%", "4", "!=", "0", ")", "{", "if", "(", "n_bytes", "%", "4", ">=", "2", ")", "output_asm_insn", "(", "\"{sths|sth},ma %%r0,2(%0)\"", ",", "operands", ")", ";", "if", "(", "n_bytes", "%", "2", "!=", "0", ")", "output_asm_insn", "(", "\"stb %%r0,0(%0)\"", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "case", "1", ":", "operands", "[", "2", "]", "=", "GEN_INT", "(", "n_bytes", "-", "2", ")", ";", "output_asm_insn", "(", "\"ldi %2,%1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"{stbs|stb},ma %%r0,1(%0)\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"addib,>= -2,%1,.-4\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"{stbs|stb},ma %%r0,1(%0)\"", ",", "operands", ")", ";", "if", "(", "n_bytes", "%", "2", "!=", "0", ")", "output_asm_insn", "(", "\"stb %%r0,0(%0)\"", ",", "operands", ")", ";", "return", "\"\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "perform", "a", "block", "clear", ".", "OPERANDS", "[", "0", "]", "is", "the", "destination", "pointer", "as", "a", "REG", ",", "clobbered", ".", "OPERANDS", "[", "1", "]", "is", "a", "register", "for", "temporary", "storage", ".", "OPERANDS", "[", "2", "]", "is", "the", "size", "as", "a", "CONST_INT", "OPERANDS", "[", "3", "]", "is", "the", "alignment", "safe", "to", "use", ",", "as", "a", "CONST_INT", "." ]

[ "pa", "3", "2", "8", "4", "8", "4", "8", "2", "16", "\"ldi %2,%1\"", "\"std,ma %%r0,8(%0)\"", "\"addib,>= -16,%1,.-4\"", "\"std,ma %%r0,8(%0)\"", "16", "0", "2", "8", "16", "8", "\"std,ma %%r0,8(%0)\"", "8", "0", "\"stdby,e %%r0,%2(%0)\"", "\"\"", "4", "2", "8", "\"ldi %2,%1\"", "\"{stws|stw},ma %%r0,4(%0)\"", "\"addib,>= -8,%1,.-4\"", "\"{stws|stw},ma %%r0,4(%0)\"", "8", "0", "2", "4", "8", "4", "\"{stws|stw},ma %%r0,4(%0)\"", "4", "0", "\"{stbys|stby},e %%r0,%2(%0)\"", "\"\"", "2", "2", "4", "\"ldi %2,%1\"", "\"{sths|sth},ma %%r0,2(%0)\"", "\"addib,>= -4,%1,.-4\"", "\"{sths|sth},ma %%r0,2(%0)\"", "4", "0", "4", "2", "\"{sths|sth},ma %%r0,2(%0)\"", "2", "0", "\"stb %%r0,0(%0)\"", "\"\"", "1", "2", "2", "\"ldi %2,%1\"", "\"{stbs|stb},ma %%r0,1(%0)\"", "\"addib,>= -2,%1,.-4\"", "\"{stbs|stb},ma %%r0,1(%0)\"", "2", "0", "\"stb %%r0,0(%0)\"", "\"\"" ]

[]

[ "<s>", "const", "SparcSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "void", "or1k_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "nreg", "=", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "gcc_assert", "(", "nreg", "<=", "2", ")", ";", "if", "(", "named", ")", "*", "cum", "+=", "nreg", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_FUNCTION_ARG_ADVANCE", ".", "Update", "the", "cumulative", "args", "descriptor", "CUM_V", "to", "advance", "past", "the", "next", "function", "argument", ".", "Note", ",", "this", "is", "not", "called", "for", "arguments", "passed", "on", "the", "stack", "." ]

[ "or1k", "2" ]

[]

[ "<s>", "void", "split_double_mode", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ",", "int", "num", ",", "rtx", "lo_half", "[", "]", ",", "rtx", "hi_half", "[", "]", ")", "{", "machine_mode", "half_mode", ";", "unsigned", "int", "byte", ";", "rtx", "mem_op", "=", "NULL_RTX", ";", "int", "mem_num", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "E_TImode", ":", "half_mode", "=", "DImode", ";", "break", ";", "case", "E_DImode", ":", "half_mode", "=", "SImode", ";", "break", ";", "case", "E_P2HImode", ":", "half_mode", "=", "HImode", ";", "break", ";", "case", "E_P2QImode", ":", "half_mode", "=", "QImode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "byte", "=", "GET_MODE_SIZE", "(", "half_mode", ")", ";", "while", "(", "num", "--", ")", "{", "rtx", "op", "=", "operands", "[", "num", "]", ";", "if", "(", "MEM_P", "(", "op", ")", ")", "{", "if", "(", "mem_op", "&&", "rtx_equal_p", "(", "op", ",", "mem_op", ")", ")", "{", "lo_half", "[", "num", "]", "=", "lo_half", "[", "mem_num", "]", ";", "hi_half", "[", "num", "]", "=", "hi_half", "[", "mem_num", "]", ";", "}", "else", "{", "mem_op", "=", "op", ";", "mem_num", "=", "num", ";", "lo_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "half_mode", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "half_mode", ",", "byte", ")", ";", "}", "}", "else", "{", "lo_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "half_mode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "mode", ":", "GET_MODE", "(", "op", ")", ",", "0", ")", ";", "rtx", "tmp", "=", "simplify_gen_subreg", "(", "half_mode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "mode", ":", "GET_MODE", "(", "op", ")", ",", "byte", ")", ";", "hi_half", "[", "num", "]", "=", "tmp", "?", "tmp", ":", "gen_reg_rtx", "(", "half_mode", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "one", "or", "more", "double-mode", "RTL", "references", "into", "pairs", "of", "half-mode", "references", ".", "The", "RTL", "can", "be", "REG", ",", "offsettable", "MEM", ",", "integer", "constant", ",", "or", "CONST_DOUBLE", ".", "``", "operands", "''", "is", "a", "pointer", "to", "an", "array", "of", "double-mode", "RTLs", "to", "split", "and", "``", "num", "''", "is", "its", "length", ".", "lo_half", "and", "hi_half", "are", "output", "arrays", "that", "parallel", "``", "operands", "''", "." ]

[ "i386", "0", "0", "0" ]

[]

[ "<s>", "const", "MCExpr", "*", "SystemZMCInstLower", "::", "getExpr", "(", "const", "MachineOperand", "&", "MO", ",", "MCSymbolRefExpr", "::", "VariantKind", "Kind", ")", "const", "{", "const", "MCSymbol", "*", "Symbol", ";", "bool", "HasOffset", "=", "true", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "Symbol", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "HasOffset", "=", "false", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "Symbol", "=", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "Symbol", "=", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "Symbol", "=", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ";", "HasOffset", "=", "false", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "Symbol", "=", "AsmPrinter", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "Symbol", "=", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "Create", "(", "Symbol", ",", "Kind", ",", "Ctx", ")", ";", "if", "(", "HasOffset", ")", "if", "(", "int64_t", "Offset", "=", "MO", ".", "getOffset", "(", ")", ")", "{", "const", "MCExpr", "*", "OffsetExpr", "=", "MCConstantExpr", "::", "Create", "(", "Offset", ",", "Ctx", ")", ";", "Expr", "=", "MCBinaryExpr", "::", "CreateAdd", "(", "Expr", ",", "OffsetExpr", ",", "Ctx", ")", ";", "}", "return", "Expr", ";", "}", "</s>" ]

[ "Implementation", "of", "the", "SCEVPredicate", "interface", "." ]

[ "SystemZ", "SystemZ", "\"unknown operand type\"" ]

[]

[ "<s>", "SDValue", "LoongArchTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "analyzeOutputArgs", "(", "CCInfo", ",", "Outs", ",", "CC_LoongArch", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "return", "DAG", ".", "getNode", "(", "LoongArchISD", "::", "RET", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "LoongArch", "LoongArch", "ISD::OutputArg", "LoongArch", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "LoongArchISD::RET", "MVT::Other" ]

[]

[ "<s>", "int", "aarch64_fpconst_pow_of_2", "(", "rtx", "x", ")", "{", "const", "REAL_VALUE_TYPE", "*", "r", ";", "if", "(", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "-", "1", ";", "r", "=", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_NEGATIVE", "(", "*", "r", ")", "||", "REAL_VALUE_ISNAN", "(", "*", "r", ")", "||", "REAL_VALUE_ISINF", "(", "*", "r", ")", "||", "!", "real_isinteger", "(", "r", ",", "DFmode", ")", ")", "return", "-", "1", ";", "return", "exact_log2", "(", "real_to_integer", "(", "r", ")", ")", ";", "}", "</s>" ]

[ "If", "X", "is", "a", "positive", "CONST_DOUBLE", "with", "a", "value", "that", "is", "a", "power", "of", "2", "return", "the", "log2", "of", "that", "value", ".", "Otherwise", "return", "-1", "." ]

[ "aarch64", "1", "1" ]

[]

[ "<s>", "bool", "PatmosSPBundling", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "PSPI", "=", "&", "getAnalysis", "<", "PatmosSinglePathInfo", ">", "(", ")", ";", "PostDom", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "if", "(", "PSPI", "->", "isConverting", "(", "MF", ")", "&&", "STC", ".", "enableBundling", "(", "TM", ".", "getOptLevel", "(", ")", ")", ")", "{", "SPBlocks", "+=", "MF", ".", "size", "(", ")", ";", "doBundlingFunction", "(", "PSPI", "->", "getRootScope", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "avr_emit_cpymemhi", "(", "rtx", "*", "xop", ")", "{", "HOST_WIDE_INT", "count", ";", "machine_mode", "loop_mode", ";", "addr_space_t", "as", "=", "MEM_ADDR_SPACE", "(", "xop", "[", "1", "]", ")", ";", "rtx", "loop_reg", ",", "addr1", ",", "a_src", ",", "a_dest", ",", "insn", ",", "xas", ";", "rtx", "a_hi8", "=", "NULL_RTX", ";", "if", "(", "avr_mem_flash_p", "(", "xop", "[", "0", "]", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "xop", "[", "2", "]", ")", ")", "return", "false", ";", "count", "=", "INTVAL", "(", "xop", "[", "2", "]", ")", ";", "if", "(", "count", "<=", "0", ")", "return", "false", ";", "a_src", "=", "XEXP", "(", "xop", "[", "1", "]", ",", "0", ")", ";", "a_dest", "=", "XEXP", "(", "xop", "[", "0", "]", ",", "0", ")", ";", "if", "(", "PSImode", "==", "GET_MODE", "(", "a_src", ")", ")", "{", "gcc_assert", "(", "as", "==", "ADDR_SPACE_MEMX", ")", ";", "loop_mode", "=", "(", "count", "<", "0x100", ")", "?", "QImode", ":", "HImode", ";", "loop_reg", "=", "gen_rtx_REG", "(", "loop_mode", ",", "24", ")", ";", "emit_move_insn", "(", "loop_reg", ",", "gen_int_mode", "(", "count", ",", "loop_mode", ")", ")", ";", "addr1", "=", "simplify_gen_subreg", "(", "HImode", ",", "a_src", ",", "PSImode", ",", "0", ")", ";", "a_hi8", "=", "simplify_gen_subreg", "(", "QImode", ",", "a_src", ",", "PSImode", ",", "2", ")", ";", "}", "else", "{", "int", "segment", "=", "avr_addrspace", "[", "as", "]", ".", "segment", ";", "if", "(", "segment", "&&", "avr_n_flash", ">", "1", ")", "{", "a_hi8", "=", "GEN_INT", "(", "segment", ")", ";", "emit_move_insn", "(", "rampz_rtx", ",", "a_hi8", "=", "copy_to_mode_reg", "(", "QImode", ",", "a_hi8", ")", ")", ";", "}", "else", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "{", "as", "=", "ADDR_SPACE_FLASH", ";", "}", "addr1", "=", "a_src", ";", "loop_mode", "=", "(", "count", "<=", "0x100", ")", "?", "QImode", ":", "HImode", ";", "loop_reg", "=", "copy_to_mode_reg", "(", "loop_mode", ",", "gen_int_mode", "(", "count", ",", "loop_mode", ")", ")", ";", "}", "xas", "=", "GEN_INT", "(", "as", ")", ";", "emit_move_insn", "(", "lpm_addr_reg_rtx", ",", "addr1", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "HImode", ",", "REG_X", ")", ",", "a_dest", ")", ";", "gcc_assert", "(", "TMP_REGNO", "==", "LPM_REGNO", ")", ";", "if", "(", "as", "!=", "ADDR_SPACE_MEMX", ")", "{", "rtx", "(", "*", "fun", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "QImode", "==", "loop_mode", "?", "gen_cpymem_qi", ":", "gen_cpymem_hi", ";", "insn", "=", "fun", "(", "xas", ",", "loop_reg", ",", "loop_reg", ")", ";", "}", "else", "{", "rtx", "(", "*", "fun", ")", "(", "rtx", ",", "rtx", ")", "=", "QImode", "==", "loop_mode", "?", "gen_cpymemx_qi", ":", "gen_cpymemx_hi", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "QImode", ",", "23", ")", ",", "a_hi8", ")", ";", "insn", "=", "fun", "(", "xas", ",", "GEN_INT", "(", "avr_addr", ".", "rampz", ")", ")", ";", "}", "set_mem_addr_space", "(", "SET_SRC", "(", "XVECEXP", "(", "insn", ",", "0", ",", "0", ")", ")", ",", "as", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Worker", "function", "for", "cpymemhi", "expander", ".", "XOP", "[", "0", "]", "Destination", "as", "MEM", ":", "BLK", "XOP", "[", "1", "]", "Source", "``", "``", "XOP", "[", "2", "]", "#", "Bytes", "to", "copy", "Return", "TRUE", "if", "the", "expansion", "is", "accomplished", ".", "Return", "FALSE", "if", "the", "operand", "compination", "is", "not", "supported", "." ]

[ "avr", "1", "0", "2", "2", "0", "1", "0", "0", "0", "0x100", "24", "0", "2", "1", "0x100", "23", "0", "0" ]

[]

[ "<s>", "unsigned", "R600InstrInfo", "::", "calculateIndirectAddress", "(", "unsigned", "RegIndex", ",", "unsigned", "Channel", ")", "const", "{", "assert", "(", "Channel", "==", "0", ")", ";", "return", "RegIndex", ";", "}", "</s>" ]

[ "Calculate", "the", "``", "Indirect", "Address", "''", "for", "the", "given", "RegIndex", "and", "Channel", "." ]

[ "AMDGPU", "R600", "0" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "Cpu0" ]

[]

[ "<s>", "bool", "use_mask_predication_p", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "We", "choose", "to", "return", "true", "by", "default", "since", "most", "of", "the", "intrinsics", "use", "mask", "predication", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction not supported on this GPU\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "if", "(", "isForcedVOP3", "(", ")", ")", "{", "AMDGPUOperand", "&", "LastOp", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "Operands", ".", "size", "(", ")", "-", "1", "]", ")", ";", "if", "(", "LastOp", ".", "isRegKind", "(", ")", "||", "(", "LastOp", ".", "isImm", "(", ")", "&&", "LastOp", ".", "getImmTy", "(", ")", "!=", "AMDGPUOperand", "::", "ImmTyNone", ")", ")", "{", "SMLoc", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "0", ",", "S", ",", "AMDGPUOperand", "::", "ImmTyClamp", ")", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "0", ",", "S", ",", "AMDGPUOperand", "::", "ImmTyOMod", ")", ")", ";", "bool", "Res", "=", "MatchAndEmitInstruction", "(", "IDLoc", ",", "Opcode", ",", "Operands", ",", "Out", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "if", "(", "!", "Res", ")", "return", "Res", ";", "}", "}", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "AMDGPU", "AMDGPU", "\"instruction not supported on this GPU\"", "\"unrecognized instruction mnemonic\"", "0ULL", "AMDGPU", "AMDGPU", "1", "AMDGPU", "AMDGPU", "0", "AMDGPU", "AMDGPU", "0", "AMDGPU", "\"too few operands for instruction\"", "AMDGPU", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", "&&", "!", "getARMSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "addPass", "(", "createGlobalMergePass", "(", "TM", "->", "getTargetLowering", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "HexagonRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegsV3", "[", "]", "=", "{", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsV3EHReturn", "[", "]", "=", "{", "Hexagon", "::", "R0", ",", "Hexagon", "::", "R1", ",", "Hexagon", "::", "R2", ",", "Hexagon", "::", "R3", ",", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "bool", "HasEHReturn", "=", "MF", "->", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ";", "switch", "(", "MF", "->", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getHexagonArchVersion", "(", ")", ")", "{", "case", "Hexagon", "::", "ArchEnum", "::", "V4", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V5", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V55", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V60", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V62", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V65", ":", "return", "HasEHReturn", "?", "CalleeSavedRegsV3EHReturn", ":", "CalleeSavedRegsV3", ";", "}", "llvm_unreachable", "(", "\"Callee saved registers requested for unknown architecture \"", "\"version\"", ")", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "Hexagon", "Hexagon", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon::R0", "Hexagon::R1", "Hexagon::R2", "Hexagon::R3", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "\"Callee saved registers requested for unknown architecture \"", "\"version\"" ]

[]

[ "<s>", "const", "J2RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "RegisterInfo", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "J2", "J2" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "LLVM_OVERRIDE", "{", "return", "\"ARM Assembly Printer\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "ARM", "\"ARM Assembly Printer\"" ]

[]

[ "<s>", "bool", "ix86_expand_mask_vec_cmp", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ")", "{", "machine_mode", "mask_mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "cmp_mode", "=", "GET_MODE", "(", "cmp_op0", ")", ";", "rtx", "imm", "=", "GEN_INT", "(", "ix86_cmp_code_to_pcmp_immediate", "(", "code", ",", "cmp_mode", ")", ")", ";", "int", "unspec_code", ";", "rtx", "unspec", ";", "switch", "(", "code", ")", "{", "case", "LEU", ":", "case", "GTU", ":", "case", "GEU", ":", "case", "LTU", ":", "unspec_code", "=", "UNSPEC_UNSIGNED_PCMP", ";", "break", ";", "default", ":", "unspec_code", "=", "UNSPEC_PCMP", ";", "}", "unspec", "=", "gen_rtx_UNSPEC", "(", "mask_mode", ",", "gen_rtvec", "(", "3", ",", "cmp_op0", ",", "cmp_op1", ",", "imm", ")", ",", "unspec_code", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "unspec", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Expand", "AVX-512", "vector", "comparison", "." ]

[ "i386", "3" ]

[]

[ "<s>", "void", "PIC16InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "const", "std", "::", "string", "FuncName", "=", "Func", "->", "getName", "(", ")", ";", "char", "*", "tmpName", "=", "new", "char", "[", "strlen", "(", "FuncName", ".", "c_str", "(", ")", ")", "+", "6", "]", ";", "sprintf", "(", "tmpName", ",", "\"%s.tmp\"", ",", "FuncName", ".", "c_str", "(", ")", ")", ";", "if", "(", "RC", "==", "PIC16", "::", "GPRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "PIC16", "::", "movwf", ")", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ".", "addImm", "(", "FI", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "if", "(", "RC", "==", "PIC16", "::", "FSR16RegisterClass", ")", "assert", "(", "0", "&&", "\"Don't know yet how to store a FSR16 to stack slot\"", ")", ";", "else", "assert", "(", "0", "&&", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "PIC16", "PIC16", "6", "\"%s.tmp\"", "PIC16::GPRRegisterClass", "PIC16::movwf", "1", "PIC16::FSR16RegisterClass", "0", "\"Don't know yet how to store a FSR16 to stack slot\"", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "IsPCRel", ",", "Ctx", ",", "IsLittleEndian", ",", "true", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "!", "IsLittleEndian", ")", "{", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "(", "Offset", "+", "FullSizeBytes", ")", "<=", "DataSize", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FullSizeBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "FullSizeBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "ARM", "ARM", "\"Invalid fixup offset!\"", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"esp\"", ",", "X86", "::", "ESP", ")", ".", "Case", "(", "\"rsp\"", ",", "X86", "::", "RSP", ")", ".", "Case", "(", "\"ebp\"", ",", "X86", "::", "EBP", ")", ".", "Case", "(", "\"rbp\"", ",", "X86", "::", "RBP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", "==", "X86", "::", "EBP", "||", "Reg", "==", "X86", "::", "RBP", ")", "{", "if", "(", "!", "TFI", ".", "hasFP", "(", "MF", ")", ")", "report_fatal_error", "(", "\"register \"", "+", "StringRef", "(", "RegName", ")", "+", "\" is allocatable: function has no frame pointer\"", ")", ";", "else", "{", "const", "X86RegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "FrameReg", "=", "RegInfo", "->", "getPtrSizedFrameRegister", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "assert", "(", "(", "FrameReg", "==", "X86", "::", "EBP", "||", "FrameReg", "==", "X86", "::", "RBP", ")", "&&", "\"Invalid Frame Register!\"", ")", ";", "}", "}", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "X86", "X86", "\"esp\"", "X86::ESP", "\"rsp\"", "X86::RSP", "\"ebp\"", "X86::EBP", "\"rbp\"", "X86::RBP", "0", "X86::EBP", "X86::RBP", "\"register \"", "\" is allocatable: function has no frame pointer\"", "X86", "X86::EBP", "X86::RBP", "\"Invalid Frame Register!\"", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "unsigned", "TVMRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "TVM", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "TVM", "TVM", "TVM::SP" ]

[]

[ "<s>", "static", "section", "*", "rs6000_elf_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "x", ",", "mode", ")", ")", "return", "toc_section", ";", "else", "return", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "}", "</s>" ]

[ "A", "C", "statement", "or", "statements", "to", "switch", "to", "the", "appropriate", "section", "for", "output", "of", "RTX", "in", "mode", "MODE", ".", "You", "can", "assume", "that", "RTX", "is", "some", "kind", "of", "constant", "in", "RTL", ".", "The", "argument", "MODE", "is", "redundant", "except", "in", "the", "case", "of", "a", "`", "const_int", "'", "rtx", ".", "Select", "the", "section", "by", "calling", "`", "text_section", "'", "or", "one", "of", "the", "alternatives", "for", "other", "sections", ".", "Do", "not", "define", "this", "macro", "if", "you", "put", "all", "constants", "in", "the", "read-only", "data", "section", "." ]

[ "rs6000" ]

[]

[ "<s>", "inline", "void", "classify_registers", "(", "const_tree", ",", "int", "bitpos", ",", "bool", "fp", ",", "classify_data_t", "*", "data", ")", "{", "if", "(", "fp", ")", "{", "data", "->", "fp_regs", "=", "true", ";", "if", "(", "bitpos", "<", "BITS_PER_WORD", ")", "data", "->", "fp_regs_in_first_word", "=", "true", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_slotno", ".", "Classify", "the", "field", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "void", "ix86_emit_restore_sse_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ",", "bool", "maybe_eh_return", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "maybe_eh_return", ",", "true", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "V4SFmode", ",", "regno", ")", ";", "rtx", "mem", ";", "unsigned", "int", "align", "=", "GET_MODE_ALIGNMENT", "(", "V4SFmode", ")", ";", "mem", "=", "choose_baseaddr", "(", "cfa_offset", ",", "&", "align", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "V4SFmode", ",", "mem", ")", ";", "align", "=", "MIN", "(", "GET_MODE_ALIGNMENT", "(", "V4SFmode", ")", ",", "align", ")", ";", "gcc_assert", "(", "!", "(", "cfa_offset", "&", "(", "align", "/", "BITS_PER_UNIT", "-", "1", ")", ")", ")", ";", "set_mem_align", "(", "mem", ",", "align", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "ix86_add_cfa_restore_note", "(", "NULL", ",", "reg", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "GET_MODE_SIZE", "(", "V4SFmode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "saved", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "CFA", "-", "CFA_OFFSET", "." ]

[ "i386", "0", "1" ]

[]

[ "<s>", "void", "alpha_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "cond", ",", "retval", ",", "mem", ",", "oldval", ",", "newval", ";", "bool", "is_weak", ";", "enum", "memmodel", "mod_s", ",", "mod_f", ";", "machine_mode", "mode", ";", "rtx", "label1", ",", "label2", ",", "x", ";", "cond", "=", "operands", "[", "0", "]", ";", "retval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "(", "operands", "[", "5", "]", "!=", "const0_rtx", ")", ";", "mod_s", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "6", "]", ")", ";", "mod_f", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "7", "]", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "alpha_pre_atomic_barrier", "(", "mod_s", ")", ";", "label1", "=", "NULL_RTX", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label1", ",", "0", ")", ")", ";", "}", "label2", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "x", "=", "gen_lowpart", "(", "DImode", ",", "retval", ")", ";", "if", "(", "oldval", "==", "const0_rtx", ")", "{", "emit_move_insn", "(", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "DImode", ",", "x", ",", "const0_rtx", ")", ";", "}", "else", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "x", ",", "oldval", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cond", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "}", "emit_unlikely_jump", "(", "x", ",", "label2", ")", ";", "emit_move_insn", "(", "cond", ",", "newval", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "cond", ")", ")", ";", "if", "(", "!", "is_weak", ")", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label1", ")", ";", "}", "if", "(", "mod_f", "!=", "MEMMODEL_RELAXED", ")", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "alpha_post_atomic_barrier", "(", "mod_s", ")", ";", "if", "(", "mod_f", "==", "MEMMODEL_RELAXED", ")", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "compare", "and", "swap", "operation", "." ]

[ "alpha", "0", "1", "2", "3", "4", "5", "6", "7", "0", "0", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "riscv_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_FP_REG", "-", "1", ")", "/", "UNITS_PER_FP_REG", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_NREGS", "." ]

[ "riscv", "1", "1" ]

[]

[ "<s>", "bool", "SystemZAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "FeatureBitset", "MissingFeatures", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MissingFeatures", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "MissingFeatures", ".", "any", "(", ")", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MissingFeatures", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "MissingFeatures", "[", "I", "]", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "I", ")", ";", "}", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "SystemZOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "SystemZMnemonicSpellCheck", "(", "(", "(", "SystemZOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "SystemZOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Unexpected match type\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "SystemZ", "SystemZ", "\"Unknown missing feature!\"", "\"instruction requires:\"", "0", "\" \"", "0ULL", "\"too few operands for instruction\"", "SystemZ", "\"invalid operand for instruction\"", "SystemZ", "SystemZ", "0", "\"invalid instruction\"", "SystemZ", "0", "\"Unexpected match type\"" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMADD64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMAND64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMNAND64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMOR64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMSUB64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMXOR64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMSWAP64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMCMPXCHG64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMMIN64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMUMIN64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMMAX64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMUMAX64_DAG", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::ATOMIC_LOAD_ADD", "ARMISD::ATOMADD64_DAG", "ISD::ATOMIC_LOAD_AND", "ARMISD::ATOMAND64_DAG", "ISD::ATOMIC_LOAD_NAND", "ARMISD::ATOMNAND64_DAG", "ISD::ATOMIC_LOAD_OR", "ARMISD::ATOMOR64_DAG", "ISD::ATOMIC_LOAD_SUB", "ARMISD::ATOMSUB64_DAG", "ISD::ATOMIC_LOAD_XOR", "ARMISD::ATOMXOR64_DAG", "ISD::ATOMIC_SWAP", "ARMISD::ATOMSWAP64_DAG", "ISD::ATOMIC_CMP_SWAP", "ARMISD::ATOMCMPXCHG64_DAG", "ISD::ATOMIC_LOAD_MIN", "ARMISD::ATOMMIN64_DAG", "ISD::ATOMIC_LOAD_UMIN", "ARMISD::ATOMUMIN64_DAG", "ISD::ATOMIC_LOAD_MAX", "ARMISD::ATOMMAX64_DAG", "ISD::ATOMIC_LOAD_UMAX", "ARMISD::ATOMUMAX64_DAG" ]

[]

[ "<s>", "StringRef", "X86TargetLowering", "::", "getStackProbeSymbolName", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"probe-stack\"", ")", ")", "return", "MF", ".", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"probe-stack\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isOSWindows", "(", ")", "||", "Subtarget", ".", "isTargetMachO", "(", ")", ")", "return", "\"\"", ";", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "\"___chkstk_ms\"", ":", "\"__chkstk\"", ";", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "\"_alloca\"", ":", "\"_chkstk\"", ";", "}", "</s>" ]

[ "Returns", "the", "name", "of", "the", "symbol", "used", "to", "emit", "stack", "probes", "or", "the", "empty", "string", "if", "not", "applicable", "." ]

[ "X86", "X86", "\"probe-stack\"", "\"probe-stack\"", "\"\"", "\"___chkstk_ms\"", "\"__chkstk\"", "\"_alloca\"", "\"_chkstk\"" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "HasCRC", "(", "false", ")", ",", "HasZeroCycleRegMove", "(", "false", ")", ",", "HasZeroCycleZeroing", "(", "false", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", "TM", ".", "getDataLayout", "(", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "split_alu_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "lhs", ",", "rtx", "*", "rhs1", ",", "rtx", "*", "rhs2", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", ";", "*", "lhs", "=", "SET_DEST", "(", "pat", ")", ";", "*", "rhs1", "=", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ";", "if", "(", "GET_RTX_CLASS", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", ")", "!=", "RTX_UNARY", ")", "*", "rhs2", "=", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ";", "return", ";", "}", "</s>" ]

[ "Splits", "out", "the", "operands", "of", "an", "ALU", "insn", ",", "places", "them", "in", "*", "LHS", ",", "*", "RHS1", ",", "*", "RHS2", "." ]

[ "nios2", "0", "1" ]

[]

[ "<s>", "bool", "CSKYAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MCSubtargetInfo", "&", "NewSTI", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getSubtargetCopy", "(", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ")", ";", "NewSTI", ".", "setFeatureBits", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "Subtarget", "=", "&", "NewSTI", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "void", "output_ascii", "(", "FILE", "*", "file", ",", "const", "char", "*", "p", ",", "int", "size", ")", "{", "int", "i", ";", "fprintf", "(", "file", ",", "\"\\t.byte \"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "register", "int", "c", "=", "p", "[", "i", "]", ";", "if", "(", "c", "<", "0", ")", "c", "+=", "256", ";", "fprintf", "(", "file", ",", "\"%#o\"", ",", "c", ")", ";", "if", "(", "i", "<", "size", "-", "1", ")", "putc", "(", "','", ",", "file", ")", ";", "}", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "</s>" ]

[ "Output", "an", "assembler", "pseudo-op", "to", "write", "an", "ASCII", "string", "of", "N", "characters", "starting", "at", "P", "to", "FILE", ".", "On", "the", "RS/6000", ",", "we", "have", "to", "do", "this", "using", "the", ".byte", "operation", "and", "write", "out", "special", "characters", "outside", "the", "quoted", "string", ".", "Also", ",", "the", "assembler", "is", "broken", ";", "very", "long", "strings", "are", "truncated", ",", "so", "we", "must", "artificially", "break", "them", "up", "early", "." ]

[ "pdp11", "\"\\t.byte \"", "0", "0", "256", "\"%#o\"", "1" ]

[]

[ "<s>", "void", "avr_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "cum", "->", "nregs", "=", "AVR_TINY", "?", "6", ":", "18", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "if", "(", "!", "libname", "&&", "stdarg_p", "(", "fntype", ")", ")", "cum", "->", "nregs", "=", "0", ";", "cfun", "->", "machine", "->", "sibcall_fails", "=", "0", ";", "}", "</s>" ]

[ "Initializing", "the", "variable", "cum", "for", "the", "state", "at", "the", "beginning", "of", "the", "argument", "list", "." ]

[ "avr", "6", "18", "0", "0" ]

[]

[ "<s>", "void", "reset", "(", ")", "{", "Inst2Replace", "=", "nullptr", ";", "BackedgeInst", "=", "nullptr", ";", "DepChains", ".", "clear", "(", ")", ";", "Iterations", "=", "-", "1", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "Hexagon", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n********** Patmos Delay Slot Filler **********\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Function: \"", "<<", "F", ".", "getFunction", "(", ")", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "LLVM_DEBUG", "(", "F", ".", "dump", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "fillDelaySlots", "(", "*", "FI", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "insertNOPs", "(", "*", "FI", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n********** Finished Patmos Delay Slot Filler **********\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Function: \"", "<<", "F", ".", "getFunction", "(", ")", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "LLVM_DEBUG", "(", "F", ".", "dump", "(", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "Patmos", "\"\\n********** Patmos Delay Slot Filler **********\\n\"", "\"********** Function: \"", "\"**********\\n\"", "\"\\n********** Finished Patmos Delay Slot Filler **********\\n\"", "\"********** Function: \"", "\"**********\\n\"" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "canMacroFuseCmp", "(", ")", "{", "return", "ST", "->", "hasMacroFusion", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "can", "fuse", "a", "compare", "and", "branch", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "uint8_t", "get_ratio", "(", ")", "const", "{", "return", "m_ratio", ";", "}", "</s>" ]

[ "Get", "ratio", "according", "to", "machine", "mode", "." ]

[ "riscv" ]

[]

[ "<s>", "virtual", "bool", "isDivergentRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "override", "{", "return", "!", "isSGPRClass", "(", "RC", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "register", "class", "is", "considered", "divergent", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "void", "extract_devices_dir_from_collect_gcc", "(", "char", "*", "*", "devices_loc", ")", "{", "char", "*", "t_devices_loc", "=", "*", "devices_loc", ";", "t_devices_loc", "=", "msp430_dirname", "(", "msp430_dirname", "(", "t_devices_loc", ")", ")", ";", "t_devices_loc", "=", "concat", "(", "t_devices_loc", ",", "rest_of_devices_path", ",", "NULL", ")", ";", "*", "devices_loc", "=", "t_devices_loc", ";", "}", "</s>" ]

[ "Given", "the", "path", "to", "the", "GCC", "executable", ",", "return", "the", "path", "to", "the", "installed", "device", "data", "in", "``", "$", "TOOLCHAIN_ROOT/msp430-elf/include/devices", "''", ".", "Assumes", "the", "GCC", "executable", "is", "in", "``", "$", "TOOLCHAIN_ROOT/", "<", "somedir", ">", "/", "''", "." ]

[ "msp430" ]

[]

[ "<s>", "static", "rtx", "frv_ifcvt_load_value", "(", "rtx", "value", ",", "rtx", "insn", "ATTRIBUTE_UNUSED", ")", "{", "int", "num_alloc", "=", "frv_ifcvt", ".", "cur_scratch_regs", ";", "int", "i", ";", "rtx", "reg", ";", "if", "(", "value", "==", "const0_rtx", ")", "return", "gen_rtx_REG", "(", "SImode", ",", "GPR_FIRST", ")", ";", "if", "(", "CONSTANT_P", "(", "value", ")", "||", "(", "GET_CODE", "(", "value", ")", "==", "REG", "&&", "REGNO", "(", "value", ")", "==", "LR_REGNO", ")", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "num_alloc", ";", "i", "++", ")", "{", "if", "(", "rtx_equal_p", "(", "SET_SRC", "(", "frv_ifcvt", ".", "scratch_regs", "[", "i", "]", ")", ",", "value", ")", ")", "return", "SET_DEST", "(", "frv_ifcvt", ".", "scratch_regs", "[", "i", "]", ")", ";", "}", "}", "if", "(", "num_alloc", ">=", "GPR_TEMP_NUM", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Too many temporary registers allocated\\n\"", ")", ";", "return", "NULL_RTX", ";", "}", "reg", "=", "frv_alloc_temp_reg", "(", "&", "frv_ifcvt", ".", "tmp_reg", ",", "GPR_REGS", ",", "SImode", ",", "TRUE", ",", "TRUE", ")", ";", "if", "(", "!", "reg", ")", "{", "if", "(", "dump_file", ")", "fputs", "(", "\"Could not find a scratch register\\n\"", ",", "dump_file", ")", ";", "return", "NULL_RTX", ";", "}", "frv_ifcvt", ".", "cur_scratch_regs", "++", ";", "frv_ifcvt", ".", "scratch_regs", "[", "num_alloc", "]", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "value", ")", ";", "if", "(", "dump_file", ")", "{", "if", "(", "GET_CODE", "(", "value", ")", "==", "CONST_INT", ")", "fprintf", "(", "dump_file", ",", "\"Register %s will hold %ld\\n\"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ",", "(", "long", ")", "INTVAL", "(", "value", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "value", ")", "==", "REG", "&&", "REGNO", "(", "value", ")", "==", "LR_REGNO", ")", "fprintf", "(", "dump_file", ",", "\"Register %s will hold LR\\n\"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ")", ";", "else", "fprintf", "(", "dump_file", ",", "\"Register %s will hold a saved value\\n\"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ")", ";", "}", "return", "reg", ";", "}", "</s>" ]

[ "Return", "a", "register", "which", "will", "be", "loaded", "with", "a", "value", "if", "an", "IF", "block", "is", "converted", "to", "conditional", "execution", ".", "This", "is", "used", "to", "rewrite", "instructions", "that", "use", "constants", "to", "ones", "that", "just", "use", "registers", "." ]

[ "frv", "0", "\"Too many temporary registers allocated\\n\"", "\"Could not find a scratch register\\n\"", "\"Register %s will hold %ld\\n\"", "\"Register %s will hold LR\\n\"", "\"Register %s will hold a saved value\\n\"" ]

[]

[ "<s>", "bool", "SNESAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "Loc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "return", "emit", "(", "Inst", ",", "Loc", ",", "Out", ")", ";", "case", "Match_MissingFeature", ":", "return", "missingFeature", "(", "Loc", ",", "ErrorInfo", ")", ";", "case", "Match_InvalidOperand", ":", "return", "invalidOperand", "(", "Loc", ",", "Operands", ",", "ErrorInfo", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "Loc", ",", "\"invalid instruction\"", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "SNES", "SNES", "\"invalid instruction\"" ]

[]

[ "<s>", "RISCVSubtarget", "&", "RISCVSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "TuneCPU", ",", "StringRef", "FS", ",", "StringRef", "ABIName", ")", "{", "bool", "Is64Bit", "=", "TT", ".", "isArch64Bit", "(", ")", ";", "if", "(", "CPU", ".", "empty", "(", ")", ")", "CPU", "=", "Is64Bit", "?", "\"generic-rv64\"", ":", "\"generic-rv32\"", ";", "if", "(", "CPU", "==", "\"generic\"", ")", "report_fatal_error", "(", "Twine", "(", "\"CPU 'generic' is not supported. Use \"", ")", "+", "(", "Is64Bit", "?", "\"generic-rv64\"", ":", "\"generic-rv32\"", ")", ")", ";", "if", "(", "TuneCPU", ".", "empty", "(", ")", ")", "TuneCPU", "=", "CPU", ";", "ParseSubtargetFeatures", "(", "CPU", ",", "TuneCPU", ",", "FS", ")", ";", "if", "(", "Is64Bit", ")", "{", "XLenVT", "=", "MVT", "::", "i64", ";", "XLen", "=", "64", ";", "}", "TargetABI", "=", "RISCVABI", "::", "computeTargetABI", "(", "TT", ",", "getFeatureBits", "(", ")", ",", "ABIName", ")", ";", "RISCVFeatures", "::", "validate", "(", "TT", ",", "getFeatureBits", "(", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "RISCV", "RISCV", "RISCV", "\"generic-rv64\"", "\"generic-rv32\"", "\"generic\"", "\"CPU 'generic' is not supported. Use \"", "\"generic-rv64\"", "\"generic-rv32\"", "MVT::i64", "64", "RISCVABI::computeTargetABI", "RISCVFeatures::validate" ]

[]

[ "<s>", "void", "cmse_nonsecure_entry_clear_before_return", "(", "void", ")", "{", "bool", "clear_vfpregs", "=", "TARGET_HARD_FLOAT", "||", "TARGET_HAVE_FPCXT_CMSE", ";", "int", "regno", ",", "maxregno", "=", "clear_vfpregs", "?", "LAST_VFP_REGNUM", ":", "IP_REGNUM", ";", "uint32_t", "padding_bits_to_clear", "=", "0", ";", "auto_sbitmap", "to_clear_bitmap", "(", "maxregno", "+", "1", ")", ";", "rtx", "r1_reg", ",", "result_rtl", ",", "clearing_reg", "=", "NULL_RTX", ";", "tree", "result_type", ";", "bitmap_clear", "(", "to_clear_bitmap", ")", ";", "bitmap_set_range", "(", "to_clear_bitmap", ",", "R0_REGNUM", ",", "NUM_ARG_REGS", ")", ";", "bitmap_set_bit", "(", "to_clear_bitmap", ",", "IP_REGNUM", ")", ";", "if", "(", "clear_vfpregs", ")", "{", "int", "float_bits", "=", "D7_VFP_REGNUM", "-", "FIRST_VFP_REGNUM", "+", "1", ";", "bitmap_set_range", "(", "to_clear_bitmap", ",", "FIRST_VFP_REGNUM", ",", "float_bits", ")", ";", "if", "(", "!", "TARGET_HAVE_FPCXT_CMSE", ")", "{", "emit_use", "(", "gen_rtx_REG", "(", "SImode", ",", "IP_REGNUM", ")", ")", ";", "bitmap_clear_bit", "(", "to_clear_bitmap", ",", "IP_REGNUM", ")", ";", "emit_use", "(", "gen_rtx_REG", "(", "SImode", ",", "4", ")", ")", ";", "bitmap_clear_bit", "(", "to_clear_bitmap", ",", "4", ")", ";", "}", "}", "for", "(", "regno", "=", "NUM_ARG_REGS", ";", "regno", "<=", "maxregno", ";", "regno", "++", ")", "{", "if", "(", "IN_RANGE", "(", "regno", ",", "FIRST_VFP_REGNUM", ",", "D7_VFP_REGNUM", ")", ")", "continue", ";", "if", "(", "IN_RANGE", "(", "regno", ",", "IP_REGNUM", ",", "PC_REGNUM", ")", ")", "continue", ";", "if", "(", "!", "callee_saved_reg_p", "(", "regno", ")", "&&", "(", "!", "IN_RANGE", "(", "regno", ",", "FIRST_VFP_REGNUM", ",", "LAST_VFP_REGNUM", ")", "||", "TARGET_HARD_FLOAT", ")", ")", "bitmap_set_bit", "(", "to_clear_bitmap", ",", "regno", ")", ";", "}", "result_type", "=", "TREE_TYPE", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", ";", "if", "(", "!", "VOID_TYPE_P", "(", "result_type", ")", ")", "{", "uint64_t", "to_clear_return_mask", ";", "result_rtl", "=", "arm_function_value", "(", "result_type", ",", "current_function_decl", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "result_rtl", ")", ")", ";", "to_clear_return_mask", "=", "compute_not_to_clear_mask", "(", "result_type", ",", "result_rtl", ",", "0", ",", "&", "padding_bits_to_clear", ")", ";", "if", "(", "to_clear_return_mask", ")", "{", "gcc_assert", "(", "(", "unsigned", ")", "maxregno", "<", "sizeof", "(", "long", "long", ")", "*", "__CHAR_BIT__", ")", ";", "for", "(", "regno", "=", "R0_REGNUM", ";", "regno", "<=", "maxregno", ";", "regno", "++", ")", "{", "if", "(", "to_clear_return_mask", "&", "(", "1ULL", "<<", "regno", ")", ")", "bitmap_clear_bit", "(", "to_clear_bitmap", ",", "regno", ")", ";", "}", "}", "}", "if", "(", "padding_bits_to_clear", "!=", "0", ")", "{", "int", "to_clear_bitmap_size", "=", "SBITMAP_SIZE", "(", "(", "sbitmap", ")", "to_clear_bitmap", ")", ";", "auto_sbitmap", "to_clear_arg_regs_bitmap", "(", "to_clear_bitmap_size", ")", ";", "bitmap_clear", "(", "to_clear_arg_regs_bitmap", ")", ";", "bitmap_set_range", "(", "to_clear_arg_regs_bitmap", ",", "R1_REGNUM", ",", "NUM_ARG_REGS", "-", "1", ")", ";", "gcc_assert", "(", "bitmap_subset_p", "(", "to_clear_arg_regs_bitmap", ",", "to_clear_bitmap", ")", ")", ";", "}", "clearing_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "TARGET_THUMB1", "?", "R0_REGNUM", ":", "LR_REGNUM", ")", ";", "r1_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "R0_REGNUM", "+", "1", ")", ";", "cmse_clear_registers", "(", "to_clear_bitmap", ",", "&", "padding_bits_to_clear", ",", "1", ",", "r1_reg", ",", "clearing_reg", ")", ";", "}", "</s>" ]

[ "Clear", "caller", "saved", "registers", "not", "used", "to", "pass", "return", "values", "and", "leaked", "condition", "flags", "before", "exiting", "a", "cmse_nonsecure_entry", "function", "." ]

[ "arm", "0", "1", "1", "4", "4", "0", "0", "1ULL", "0", "1", "1", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "Z80RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "switch", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "CSR_Z80_C_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "return", "CSR_Z80_AllRegs_SaveList", ";", "}", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "Z80", "Z80", "\"Unsupported calling convention\"", "Z80", "Z80" ]

[]

[ "<s>", "bool", "arm_coproc_builtin_available", "(", "enum", "unspecv", "builtin", ")", "{", "if", "(", "TARGET_THUMB1", ")", "return", "false", ";", "switch", "(", "builtin", ")", "{", "case", "VUNSPEC_CDP", ":", "case", "VUNSPEC_LDC", ":", "case", "VUNSPEC_LDCL", ":", "case", "VUNSPEC_STC", ":", "case", "VUNSPEC_STCL", ":", "case", "VUNSPEC_MCR", ":", "case", "VUNSPEC_MRC", ":", "if", "(", "arm_arch4", ")", "return", "true", ";", "break", ";", "case", "VUNSPEC_CDP2", ":", "case", "VUNSPEC_LDC2", ":", "case", "VUNSPEC_LDC2L", ":", "case", "VUNSPEC_STC2", ":", "case", "VUNSPEC_STC2L", ":", "case", "VUNSPEC_MCR2", ":", "case", "VUNSPEC_MRC2", ":", "if", "(", "arm_arch5t", ")", "return", "true", ";", "break", ";", "case", "VUNSPEC_MCRR", ":", "case", "VUNSPEC_MRRC", ":", "if", "(", "arm_arch6", "||", "arm_arch5te", ")", "return", "true", ";", "break", ";", "case", "VUNSPEC_MCRR2", ":", "case", "VUNSPEC_MRRC2", ":", "if", "(", "arm_arch6", ")", "return", "true", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "checks", "for", "the", "availability", "of", "the", "coprocessor", "builtin", "passed", "in", "BUILTIN", "for", "the", "current", "target", ".", "Returns", "true", "if", "it", "is", "available", "and", "false", "otherwise", ".", "If", "a", "BUILTIN", "is", "passed", "for", "which", "this", "function", "has", "not", "been", "implemented", "it", "will", "cause", "an", "exception", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "csky_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "addr", ",", "bool", "strict_p", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "addr", ")", ";", "if", "(", "reload_completed", "&&", "(", "(", "code", "==", "LABEL_REF", ")", "||", "(", "code", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "1", ";", "if", "(", "is_csky_address_register_rtx_p", "(", "addr", ",", "strict_p", ")", ")", "return", "1", ";", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", "return", "1", ";", "if", "(", "code", "==", "PLUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "(", "(", "is_csky_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "csky_legitimate_index_p", "(", "mode", ",", "xop1", ",", "strict_p", ")", ")", "||", "(", "is_csky_address_register_rtx_p", "(", "xop1", ",", "strict_p", ")", "&&", "csky_legitimate_index_p", "(", "mode", ",", "xop0", ",", "strict_p", ")", ")", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_ADDRESS_P", ".", "Recognizes", "RTL", "expressions", "that", "are", "valid", "memory", "addresses", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "It", "only", "recognizes", "address", "in", "canonical", "form", ".", "LEGITIMIZE_ADDRESS", "should", "convert", "common", "non-canonical", "forms", "to", "canonical", "form", "so", "that", "they", "will", "be", "recognized", "." ]

[ "csky", "0", "0", "0", "0", "1", "1", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreEmitPass", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createAMDGPUCFGPreparationPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createAMDGPUCFGStructurizerPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createR600ExpandSpecialInstrsPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "&", "FinalizeMachineBundlesID", ")", ";", "addPass", "(", "createR600Packetizer", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createR600ControlFlowFinalizer", "(", "*", "TM", ")", ")", ";", "}", "else", "{", "addPass", "(", "createSILowerControlFlowPass", "(", "*", "TM", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "bool", "FPGATTIImpl", "::", "shouldBuildLookupTables", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "switches", "should", "be", "turned", "into", "lookup", "tables", "for", "the", "target", "." ]

[ "FPGA", "FPGA" ]

[]

[ "<s>", "uint64_t", "flags", "(", ")", "const", "{", "return", "llvm", "::", "ELF", "::", "EF_ARM_EABI_VER5", ";", "}", "</s>" ]

[ "Get", "the", "flags", "for", "this", "GlobalValue", "(", "see", "struct", "GVFlags", ")", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"A57 FP Anti-dependency breaker\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "AArch64", "\"A57 FP Anti-dependency breaker\"" ]

[]

[ "<s>", "Instruction", "*", "ARMTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "switch", "(", "Ord", ")", "{", "case", "AtomicOrdering", "::", "NotAtomic", ":", "case", "AtomicOrdering", "::", "Unordered", ":", "llvm_unreachable", "(", "\"Invalid fence: unordered/non-atomic\"", ")", ";", "case", "AtomicOrdering", "::", "Monotonic", ":", "case", "AtomicOrdering", "::", "Acquire", ":", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "SequentiallyConsistent", ":", "if", "(", "!", "Inst", "->", "hasAtomicStore", "(", ")", ")", "return", "nullptr", ";", "LLVM_FALLTHROUGH", ";", "case", "AtomicOrdering", "::", "Release", ":", "case", "AtomicOrdering", "::", "AcquireRelease", ":", "if", "(", "Subtarget", "->", "preferISHSTBarriers", "(", ")", ")", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISHST", ")", ";", "else", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISH", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown fence ordering in emitLeadingFence\"", ")", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "ARM", "ARM", "\"Invalid fence: unordered/non-atomic\"", "ARM_MB::ISHST", "ARM_MB::ISH", "\"Unknown fence ordering in emitLeadingFence\"" ]

[]

[ "<s>", "static", "void", "s390_reorg", "(", "void", ")", "{", "bool", "pool_overflow", "=", "false", ";", "int", "hw_before", ",", "hw_after", ";", "if", "(", "s390_tune", "==", "PROCESSOR_2964_Z13", ")", "s390_adjust_loops", "(", ")", ";", "split_all_insns_noflow", "(", ")", ";", "for", "(", ";", ";", ")", "{", "struct", "constant_pool", "*", "pool", "=", "NULL", ";", "if", "(", "!", "pool_overflow", ")", "{", "pool", "=", "s390_mainpool_start", "(", ")", ";", "if", "(", "!", "pool", ")", "pool_overflow", "=", "true", ";", "}", "if", "(", "pool_overflow", ")", "pool", "=", "s390_chunkify_start", "(", ")", ";", "if", "(", "!", "TARGET_CPU_ZARCH", "&&", "s390_split_branches", "(", ")", ")", "{", "if", "(", "pool_overflow", ")", "s390_chunkify_cancel", "(", "pool", ")", ";", "else", "s390_mainpool_cancel", "(", "pool", ")", ";", "continue", ";", "}", "if", "(", "pool_overflow", ")", "s390_chunkify_finish", "(", "pool", ")", ";", "else", "s390_mainpool_finish", "(", "pool", ")", ";", "cfun", "->", "machine", "->", "split_branches_pending_p", "=", "false", ";", "break", ";", "}", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "rtx_insn", "*", "insn", ",", "*", "target", ";", "rtx", "label", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "label", "=", "s390_execute_label", "(", "insn", ")", ";", "if", "(", "!", "label", ")", "continue", ";", "gcc_assert", "(", "label", "!=", "const0_rtx", ")", ";", "target", "=", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "INSN_ADDRESSES_NEW", "(", "target", ",", "-", "1", ")", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "{", "target", "=", "emit_jump_insn", "(", "s390_execute_target", "(", "insn", ")", ")", ";", "JUMP_LABEL", "(", "target", ")", "=", "JUMP_LABEL", "(", "insn", ")", ";", "}", "else", "target", "=", "emit_insn", "(", "s390_execute_target", "(", "insn", ")", ")", ";", "INSN_ADDRESSES_NEW", "(", "target", ",", "-", "1", ")", ";", "}", "}", "s390_optimize_prologue", "(", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2097_Z10", ")", "{", "rtx_insn", "*", "insn", ";", "bool", "insn_added_p", "=", "false", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "INSN_CODE", "(", "insn", ")", "<=", "0", ")", "continue", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "insn_added_p", "|=", "s390_fix_long_loop_prediction", "(", "insn", ")", ";", "if", "(", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "&&", "s390_tune", "==", "PROCESSOR_2097_Z10", ")", "insn_added_p", "|=", "s390_z10_optimize_cmp", "(", "insn", ")", ";", "}", "if", "(", "insn_added_p", ")", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "}", "s390_function_num_hotpatch_hw", "(", "current_function_decl", ",", "&", "hw_before", ",", "&", "hw_after", ")", ";", "if", "(", "hw_after", ">", "0", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "active_insn_p", "(", "insn", ")", "||", "BARRIER_P", "(", "insn", ")", "||", "LABEL_P", "(", "insn", ")", ")", "break", ";", "while", "(", "insn", "&&", "hw_after", ">", "0", ")", "{", "if", "(", "hw_after", ">=", "3", "&&", "TARGET_CPU_ZARCH", ")", "{", "emit_insn_before", "(", "gen_nop_6_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "3", ";", "}", "else", "if", "(", "hw_after", ">=", "2", ")", "{", "emit_insn_before", "(", "gen_nop_4_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "2", ";", "}", "else", "{", "emit_insn_before", "(", "gen_nop_2_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "1", ";", "}", "}", "}", "}", "</s>" ]

[ "Perform", "machine-dependent", "processing", "." ]

[ "s390", "0", "1", "1", "0", "0", "0", "3", "3", "2", "2", "1" ]

[]

[ "<s>", "iterator", "begin", "(", ")", "const", "{", "return", "SubExceptions", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "!", "Expr", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "MCS51", "0" ]

[]

[ "<s>", "static", "int", "mips_mode_rep_extended", "(", "scalar_int_mode", "mode", ",", "scalar_int_mode", "mode_rep", ")", "{", "if", "(", "TARGET_64BIT", "&&", "mode", "==", "SImode", "&&", "mode_rep", "==", "DImode", ")", "return", "SIGN_EXTEND", ";", "return", "UNKNOWN", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODE_REP_EXTENDED", "." ]

[ "mips" ]

[]

[ "<s>", "StringRef", "AArch64MCExpr", "::", "getVariantKindName", "(", ")", "const", "{", "switch", "(", "static_cast", "<", "uint32_t", ">", "(", "getKind", "(", ")", ")", ")", "{", "case", "VK_CALL", ":", "return", "\"\"", ";", "case", "VK_LO12", ":", "return", "\":lo12:\"", ";", "case", "VK_ABS_G3", ":", "return", "\":abs_g3:\"", ";", "case", "VK_ABS_G2", ":", "return", "\":abs_g2:\"", ";", "case", "VK_ABS_G2_S", ":", "return", "\":abs_g2_s:\"", ";", "case", "VK_ABS_G2_NC", ":", "return", "\":abs_g2_nc:\"", ";", "case", "VK_ABS_G1", ":", "return", "\":abs_g1:\"", ";", "case", "VK_ABS_G1_S", ":", "return", "\":abs_g1_s:\"", ";", "case", "VK_ABS_G1_NC", ":", "return", "\":abs_g1_nc:\"", ";", "case", "VK_ABS_G0", ":", "return", "\":abs_g0:\"", ";", "case", "VK_ABS_G0_S", ":", "return", "\":abs_g0_s:\"", ";", "case", "VK_ABS_G0_NC", ":", "return", "\":abs_g0_nc:\"", ";", "case", "VK_DTPREL_G2", ":", "return", "\":dtprel_g2:\"", ";", "case", "VK_DTPREL_G1", ":", "return", "\":dtprel_g1:\"", ";", "case", "VK_DTPREL_G1_NC", ":", "return", "\":dtprel_g1_nc:\"", ";", "case", "VK_DTPREL_G0", ":", "return", "\":dtprel_g0:\"", ";", "case", "VK_DTPREL_G0_NC", ":", "return", "\":dtprel_g0_nc:\"", ";", "case", "VK_DTPREL_HI12", ":", "return", "\":dtprel_hi12:\"", ";", "case", "VK_DTPREL_LO12", ":", "return", "\":dtprel_lo12:\"", ";", "case", "VK_DTPREL_LO12_NC", ":", "return", "\":dtprel_lo12_nc:\"", ";", "case", "VK_TPREL_G2", ":", "return", "\":tprel_g2:\"", ";", "case", "VK_TPREL_G1", ":", "return", "\":tprel_g1:\"", ";", "case", "VK_TPREL_G1_NC", ":", "return", "\":tprel_g1_nc:\"", ";", "case", "VK_TPREL_G0", ":", "return", "\":tprel_g0:\"", ";", "case", "VK_TPREL_G0_NC", ":", "return", "\":tprel_g0_nc:\"", ";", "case", "VK_TPREL_HI12", ":", "return", "\":tprel_hi12:\"", ";", "case", "VK_TPREL_LO12", ":", "return", "\":tprel_lo12:\"", ";", "case", "VK_TPREL_LO12_NC", ":", "return", "\":tprel_lo12_nc:\"", ";", "case", "VK_TLSDESC_LO12", ":", "return", "\":tlsdesc_lo12:\"", ";", "case", "VK_ABS_PAGE", ":", "return", "\"\"", ";", "case", "VK_ABS_PAGE_NC", ":", "return", "\":pg_hi21_nc:\"", ";", "case", "VK_GOT", ":", "return", "\":got:\"", ";", "case", "VK_GOT_PAGE", ":", "return", "\":got:\"", ";", "case", "VK_GOT_LO12", ":", "return", "\":got_lo12:\"", ";", "case", "VK_GOTTPREL", ":", "return", "\":gottprel:\"", ";", "case", "VK_GOTTPREL_PAGE", ":", "return", "\":gottprel:\"", ";", "case", "VK_GOTTPREL_LO12_NC", ":", "return", "\":gottprel_lo12:\"", ";", "case", "VK_GOTTPREL_G1", ":", "return", "\":gottprel_g1:\"", ";", "case", "VK_GOTTPREL_G0_NC", ":", "return", "\":gottprel_g0_nc:\"", ";", "case", "VK_TLSDESC", ":", "return", "\"\"", ";", "case", "VK_TLSDESC_PAGE", ":", "return", "\":tlsdesc:\"", ";", "case", "VK_SECREL_LO12", ":", "return", "\":secrel_lo12:\"", ";", "case", "VK_SECREL_HI12", ":", "return", "\":secrel_hi12:\"", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "AArch64", "AArch64", "\"\"", "\":lo12:\"", "\":abs_g3:\"", "\":abs_g2:\"", "\":abs_g2_s:\"", "\":abs_g2_nc:\"", "\":abs_g1:\"", "\":abs_g1_s:\"", "\":abs_g1_nc:\"", "\":abs_g0:\"", "\":abs_g0_s:\"", "\":abs_g0_nc:\"", "\":dtprel_g2:\"", "\":dtprel_g1:\"", "\":dtprel_g1_nc:\"", "\":dtprel_g0:\"", "\":dtprel_g0_nc:\"", "\":dtprel_hi12:\"", "\":dtprel_lo12:\"", "\":dtprel_lo12_nc:\"", "\":tprel_g2:\"", "\":tprel_g1:\"", "\":tprel_g1_nc:\"", "\":tprel_g0:\"", "\":tprel_g0_nc:\"", "\":tprel_hi12:\"", "\":tprel_lo12:\"", "\":tprel_lo12_nc:\"", "\":tlsdesc_lo12:\"", "\"\"", "\":pg_hi21_nc:\"", "\":got:\"", "\":got:\"", "\":got_lo12:\"", "\":gottprel:\"", "\":gottprel:\"", "\":gottprel_lo12:\"", "\":gottprel_g1:\"", "\":gottprel_g0_nc:\"", "\"\"", "\":tlsdesc:\"", "\":secrel_lo12:\"", "\":secrel_hi12:\"", "\"Invalid ELF symbol kind\"" ]

[]

[ "<s>", "static", "int", "elf_dcachebsize", "(", "void", ")", "{", "int", "fd", ";", "fd", "=", "open", "(", "\"/proc/self/auxv\"", ",", "O_RDONLY", ")", ";", "if", "(", "fd", "!=", "-", "1", ")", "{", "char", "buf", "[", "1024", "]", ";", "ElfW", "(", "auxv_t", ")", "*", "av", ";", "ssize_t", "n", ";", "n", "=", "read", "(", "fd", ",", "buf", ",", "sizeof", "(", "buf", ")", ")", ";", "close", "(", "fd", ")", ";", "if", "(", "n", ">", "0", ")", "{", "for", "(", "av", "=", "(", "ElfW", "(", "auxv_t", ")", "*", ")", "buf", ";", "av", "->", "a_type", "!=", "AT_NULL", ";", "++", "av", ")", "switch", "(", "av", "->", "a_type", ")", "{", "case", "AT_DCACHEBSIZE", ":", "return", "av", "->", "a_un", ".", "a_val", ";", "default", ":", "break", ";", "}", "}", "}", "</s>" ]

[ "Returns", "AT_DCACHEBSIZE", "if", "present", ",", "otherwise", "generic", "32", "." ]

[ "rs6000", "\"/proc/self/auxv\"", "1", "1024", "0" ]

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "Hexagon", "::", "ArchEnum", ">", "CpuTable", "{", "{", "\"generic\"", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "\"hexagonv5\"", ",", "Hexagon", "::", "ArchEnum", "::", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "Hexagon", "::", "ArchEnum", "::", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "\"hexagonv62\"", ",", "Hexagon", "::", "ArchEnum", "::", "V62", "}", ",", "{", "\"hexagonv65\"", ",", "Hexagon", "::", "ArchEnum", "::", "V65", "}", ",", "{", "\"hexagonv66\"", ",", "Hexagon", "::", "ArchEnum", "::", "V66", "}", ",", "}", ";", "auto", "FoundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "FoundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "FoundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "reset", "(", "Hexagon", "::", "FeatureDuplex", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "\"generic\"", "Hexagon::ArchEnum", "\"hexagonv5\"", "Hexagon::ArchEnum", "\"hexagonv55\"", "Hexagon::ArchEnum", "\"hexagonv60\"", "Hexagon::ArchEnum", "\"hexagonv62\"", "Hexagon::ArchEnum", "\"hexagonv65\"", "Hexagon::ArchEnum", "\"hexagonv66\"", "Hexagon::ArchEnum", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon::FeatureDuplex", "Hexagon" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "getBaseAndOffsetPosition", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "BasePos", ",", "unsigned", "&", "OffsetPos", ")", "const", "{", "if", "(", "isMemOp", "(", "MI", ")", ")", "{", "BasePos", "=", "0", ";", "OffsetPos", "=", "1", ";", "}", "else", "if", "(", "MI", ".", "mayStore", "(", ")", ")", "{", "BasePos", "=", "0", ";", "OffsetPos", "=", "1", ";", "}", "else", "if", "(", "MI", ".", "mayLoad", "(", ")", ")", "{", "BasePos", "=", "1", ";", "OffsetPos", "=", "2", ";", "}", "else", "return", "false", ";", "if", "(", "isPredicated", "(", "MI", ")", ")", "{", "BasePos", "++", ";", "OffsetPos", "++", ";", "}", "if", "(", "isPostIncrement", "(", "MI", ")", ")", "{", "BasePos", "++", ";", "OffsetPos", "++", ";", "}", "if", "(", "!", "MI", ".", "getOperand", "(", "BasePos", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "OffsetPos", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "contains", "a", "base", "register", "and", "offset", "." ]

[ "Hexagon", "Hexagon", "0", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "BitVector", "HexagonRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R30", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R31", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "USR", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UGP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "CS0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "CS1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "C8", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "USR_OVF", ")", ";", "for", "(", "int", "x", "=", "Reserved", ".", "find_first", "(", ")", ";", "x", ">=", "0", ";", "x", "=", "Reserved", ".", "find_next", "(", "x", ")", ")", "markSuperRegs", "(", "Reserved", ",", "x", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "Hexagon", "Hexagon", "Hexagon::R29", "Hexagon::R30", "Hexagon::R31", "Hexagon::SA0", "Hexagon::LC0", "Hexagon::SA1", "Hexagon::LC1", "Hexagon::USR", "Hexagon::PC", "Hexagon::UGP", "Hexagon::GP", "Hexagon::CS0", "Hexagon::CS1", "Hexagon::C8", "Hexagon::USR_OVF", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "if", "(", "!", "getTargetMachine", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "return", "false", ";", "return", "Subtarget", "->", "ClassifyGlobalReference", "(", "GA", "->", "getGlobal", "(", ")", ",", "getTargetMachine", "(", ")", ")", "==", "AArch64II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "AArch64", "AArch64", "AArch64II::MO_NO_FLAG" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "bool", "IsN64", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ".", "getABI", "(", ")", ".", "IsN64", "(", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Mips", "::", "S0", ":", "Mips", "::", "SP", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "IsN64", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ")", ":", "(", "IsN64", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ")", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::S0", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::SP_64", "Mips::SP" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "TargetRegisterInfo", "&", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ")", "return", "0", ";", "static", "const", "uint16_t", "CallerSavedRegs32Bit", "[", "]", "=", "{", "X86", "::", "EAX", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", ",", "0", "}", ";", "static", "const", "uint16_t", "CallerSavedRegs64Bit", "[", "]", "=", "{", "X86", "::", "RAX", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "RSI", ",", "X86", "::", "RDI", ",", "X86", "::", "R8", ",", "X86", "::", "R9", ",", "X86", "::", "R10", ",", "X86", "::", "R11", ",", "0", "}", ";", "unsigned", "Opc", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "0", ";", "case", "X86", "::", "RETL", ":", "case", "X86", "::", "RETQ", ":", "case", "X86", "::", "RETIL", ":", "case", "X86", "::", "RETIQ", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "NACL_CG_TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "&", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "const", "uint16_t", "*", "CS", "=", "Is64Bit", "?", "CallerSavedRegs64Bit", ":", "CallerSavedRegs32Bit", ";", "for", "(", ";", "*", "CS", ";", "++", "CS", ")", "if", "(", "!", "Uses", ".", "count", "(", "*", "CS", ")", ")", "return", "*", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "0", "X86::EAX", "X86::EDX", "X86::ECX", "0", "X86::RAX", "X86::RDX", "X86::RCX", "X86::RSI", "X86::RDI", "X86::R8", "X86::R9", "X86::R10", "X86::R11", "0", "0", "X86::RETL", "X86::RETQ", "X86::RETIL", "X86::RETIQ", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::NACL_CG_TCRETURNdi64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "0" ]

[]

[ "<s>", "static", "AMDGPUOperand", "::", "Ptr", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "const", "MCRegisterInfo", "*", "TRI", ",", "const", "MCSubtargetInfo", "*", "STI", ",", "bool", "ForceVOP3", ")", "{", "auto", "Op", "=", "llvm", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "TRI", "=", "TRI", ";", "Op", "->", "Reg", ".", "STI", "=", "STI", ";", "Op", "->", "Reg", ".", "Mods", "=", "{", "false", ",", "false", ",", "false", "}", ";", "Op", "->", "Reg", ".", "IsForcedVOP3", "=", "ForceVOP3", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "{", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MSP430", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "MSP430", "0", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "MVT::Other", "MVT::Other" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "if", "(", "Subtarget", "->", "hasLSE", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "MachineOperand", "&", "Callee", ",", "const", "ArgInfo", "&", "OrigRet", ",", "ArrayRef", "<", "ArgInfo", ">", "OrigArgs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "const", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "genLongCalls", "(", ")", ")", "return", "false", ";", "MIRBuilder", ".", "buildInstr", "(", "ARM", "::", "ADJCALLSTACKDOWN", ")", ".", "addImm", "(", "0", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "auto", "CallConv", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "ARM", "::", "BLX", ")", ".", "add", "(", "Callee", ")", ".", "addRegMask", "(", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallConv", ")", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "for", "(", "auto", "Arg", ":", "OrigArgs", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "Ty", ")", ")", "return", "false", ";", "if", "(", "!", "Arg", ".", "IsFixed", ")", "return", "false", ";", "splitToValueTypes", "(", "Arg", ",", "ArgInfos", ",", "DL", ",", "MRI", ")", ";", "}", "auto", "ArgAssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "CallConv", ",", "false", ")", ";", "OutgoingValueHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "ArgAssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "if", "(", "!", "OrigRet", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "OrigRet", ".", "Ty", ")", ")", "return", "false", ";", "ArgInfos", ".", "clear", "(", ")", ";", "splitToValueTypes", "(", "OrigRet", ",", "ArgInfos", ",", "DL", ",", "MRI", ")", ";", "auto", "RetAssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "CallConv", ",", "false", ")", ";", "CallReturnHandler", "RetHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetAssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "RetHandler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "buildInstr", "(", "ARM", "::", "ADJCALLSTACKUP", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::ADJCALLSTACKDOWN", "0", "ARMCC::AL", "ARM::BLX", "8", "ARM::ADJCALLSTACKUP", "0", "0", "ARMCC::AL" ]

[]

[ "<s>", "static", "bool", "is_branch_slot_insn", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "return", "false", ";", "if", "(", "rs6000_sched_groups", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "type", "==", "TYPE_BRANCH", "||", "type", "==", "TYPE_JMPREG", ")", "return", "true", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "true", "if", "INSN", "can", "be", "issued", "only", "from", "the", "branch", "slot", "." ]

[ "rs6000" ]

[]

[ "<s>", "MachineSDNode", "*", "SITargetLowering", "::", "buildRSRC", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Ptr", ",", "uint32_t", "RsrcDword1", ",", "uint64_t", "RsrcDword2And3", ")", "const", "{", "SDValue", "PtrLo", "=", "DAG", ".", "getTargetExtractSubreg", "(", "AMDGPU", "::", "sub0", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ")", ";", "SDValue", "PtrHi", "=", "DAG", ".", "getTargetExtractSubreg", "(", "AMDGPU", "::", "sub1", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ")", ";", "if", "(", "RsrcDword1", ")", "{", "PtrHi", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "AMDGPU", "::", "S_OR_B32", ",", "DL", ",", "MVT", "::", "i32", ",", "PtrHi", ",", "DAG", ".", "getConstant", "(", "RsrcDword1", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "SDValue", "DataLo", "=", "buildSMovImm32", "(", "DAG", ",", "DL", ",", "RsrcDword2And3", "&", "UINT64_C", "(", "0xFFFFFFFF", ")", ")", ";", "SDValue", "DataHi", "=", "buildSMovImm32", "(", "DAG", ",", "DL", ",", "RsrcDword2And3", ">>", "32", ")", ";", "const", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "SReg_128RegClassID", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "PtrLo", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub0", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "PtrHi", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub1", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DataLo", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub2", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DataHi", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub3", ",", "DL", ",", "MVT", "::", "i32", ")", "}", ";", "return", "DAG", ".", "getMachineNode", "(", "AMDGPU", "::", "REG_SEQUENCE", ",", "DL", ",", "MVT", "::", "v4i32", ",", "Ops", ")", ";", "}", "</s>" ]

[ "Return", "a", "resource", "descriptor", "with", "the", "'Add", "TID", "'", "bit", "enabled", "The", "TID", "(", "Thread", "ID", ")", "is", "multiplied", "by", "the", "stride", "value", "(", "bits", "[", "61:48", "]", "of", "the", "resource", "descriptor", ")", "to", "create", "an", "offset", ",", "which", "is", "added", "to", "the", "resource", "pointer", "." ]

[ "AMDGPU", "SI", "AMDGPU::sub0", "MVT::i32", "AMDGPU::sub1", "MVT::i32", "AMDGPU::S_OR_B32", "MVT::i32", "MVT::i32", "0", "0xFFFFFFFF", "32", "AMDGPU::SReg_128RegClassID", "MVT::i32", "AMDGPU::sub0", "MVT::i32", "AMDGPU::sub1", "MVT::i32", "AMDGPU::sub2", "MVT::i32", "AMDGPU::sub3", "MVT::i32", "AMDGPU::REG_SEQUENCE", "MVT::v4i32" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "RISCV", "::", "SB", ":", "case", "RISCV", "::", "SH", ":", "case", "RISCV", "::", "SW", ":", "case", "RISCV", "::", "FSW", ":", "case", "RISCV", "::", "SD", ":", "case", "RISCV", "::", "FSD", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "RISCV", "RISCV", "0", "RISCV::SB", "RISCV::SH", "RISCV::SW", "RISCV::FSW", "RISCV::SD", "RISCV::FSD", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "cris_asm_output_symbol_ref", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", ";", "if", "(", "flag_pic", "&&", "in_code", ">", "0", ")", "{", "const", "char", "*", "origstr", "=", "XSTR", "(", "x", ",", "0", ")", ";", "const", "char", "*", "str", ";", "str", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "origstr", ")", ";", "assemble_name", "(", "file", ",", "str", ")", ";", "if", "(", "!", "current_function_uses_pic_offset_table", ")", "output_operand_lossage", "(", "\"PIC register isn't set up\"", ")", ";", "}", "else", "assemble_name", "(", "file", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "ASM_OUTPUT_SYMBOL_REF", "." ]

[ "cris", "0", "0", "\"PIC register isn't set up\"", "0" ]

[]

[ "<s>", "static", "void", "nds32_asm_function_begin_epilogue", "(", "FILE", "*", "file", ")", "{", "if", "(", "!", "frame_pointer_needed", "&&", "!", "cfun", "->", "machine", "->", "naked_p", "&&", "cfun", "->", "machine", "->", "fp_as_gp_p", ")", "{", "fprintf", "(", "file", ",", "\"\\t! ----------------------------------------\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t! Claim the range of fp-as-gp \"", "\"link time optimization\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.omit_fp_end\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t! ----------------------------------------\\n\"", ")", ";", "}", "fprintf", "(", "file", ",", "\"\\t! BEGIN EPILOGUE\\n\"", ")", ";", "}", "</s>" ]

[ "Before", "rtl", "epilogue", "has", "been", "expanded", ",", "this", "function", "is", "used", "." ]

[ "nds32", "\"\\t! ----------------------------------------\\n\"", "\"\\t! Claim the range of fp-as-gp \"", "\"link time optimization\\n\"", "\"\\t.omit_fp_end\\n\"", "\"\\t! ----------------------------------------\\n\"", "\"\\t! BEGIN EPILOGUE\\n\"" ]

[]

[ "<s>", "static", "void", "mt_debug_stack", "(", "struct", "mt_frame_info", "*", "info", ")", "{", "int", "regno", ";", "if", "(", "!", "info", ")", "{", "error", "(", "\"info pointer NULL\"", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "stderr", ",", "\"\\nStack information for function %s:\\n\"", ",", "(", "(", "current_function_decl", "&&", "DECL_NAME", "(", "current_function_decl", ")", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", ":", "\"<unknown>\"", ")", ")", ";", "fprintf", "(", "stderr", ",", "\"\\ttotal_size = %d\\n\"", ",", "info", "->", "total_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tpretend_size = %d\\n\"", ",", "info", "->", "pretend_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\targs_size = %d\\n\"", ",", "info", "->", "args_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\textra_size = %d\\n\"", ",", "info", "->", "extra_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\treg_size = %d\\n\"", ",", "info", "->", "reg_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tvar_size = %d\\n\"", ",", "info", "->", "var_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tframe_size = %d\\n\"", ",", "info", "->", "frame_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\treg_mask = 0x%x\\n\"", ",", "info", "->", "reg_mask", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tsave_fp = %d\\n\"", ",", "info", "->", "save_fp", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tsave_lr = %d\\n\"", ",", "info", "->", "save_lr", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tinitialized = %d\\n\"", ",", "info", "->", "initialized", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tsaved registers =\"", ")", ";", "for", "(", "regno", "=", "GPR_R0", ";", "regno", "<=", "GPR_LAST", ";", "regno", "++", ")", "if", "(", "(", "1", "<<", "regno", ")", "&", "info", "->", "reg_mask", ")", "fprintf", "(", "stderr", ",", "\" %s\"", ",", "reg_names", "[", "regno", "]", ")", ";", "putc", "(", "'\\n'", ",", "stderr", ")", ";", "fflush", "(", "stderr", ")", ";", "}", "</s>" ]

[ "Print", "debugging", "information", "for", "a", "frame", "." ]

[ "mt", "\"info pointer NULL\"", "\"\\nStack information for function %s:\\n\"", "\"<unknown>\"", "\"\\ttotal_size = %d\\n\"", "\"\\tpretend_size = %d\\n\"", "\"\\targs_size = %d\\n\"", "\"\\textra_size = %d\\n\"", "\"\\treg_size = %d\\n\"", "\"\\tvar_size = %d\\n\"", "\"\\tframe_size = %d\\n\"", "\"\\treg_mask = 0x%x\\n\"", "\"\\tsave_fp = %d\\n\"", "\"\\tsave_lr = %d\\n\"", "\"\\tinitialized = %d\\n\"", "\"\\tsaved registers =\"", "1", "\" %s\"" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_vpshufb2_vpermq_even_odd", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "rtx", "rperm", "[", "2", "]", "[", "32", "]", ",", "vperm", ",", "l", ",", "h", ",", "ior", ",", "op", ",", "m128", ";", "unsigned", "int", "i", ",", "nelt", ",", "eltsz", ";", "if", "(", "!", "TARGET_AVX2", "||", "d", "->", "one_operand_p", "||", "(", "d", "->", "vmode", "!=", "V32QImode", "&&", "d", "->", "vmode", "!=", "V16HImode", ")", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "d", "->", "nelt", ";", "++", "i", ")", "if", "(", "(", "d", "->", "perm", "[", "i", "]", "^", "(", "i", "*", "2", ")", ")", "&", "(", "3", "*", "d", "->", "nelt", "/", "2", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "nelt", "=", "d", "->", "nelt", ";", "eltsz", "=", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "d", "->", "vmode", ")", ")", ";", "m128", "=", "GEN_INT", "(", "-", "128", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "j", ",", "e", "=", "d", "->", "perm", "[", "i", "]", "&", "(", "nelt", "/", "2", "-", "1", ")", ";", "unsigned", "which", "=", "d", "->", "perm", "[", "i", "]", ">=", "nelt", ";", "unsigned", "xorv", "=", "(", "i", ">=", "nelt", "/", "4", "&&", "i", "<", "3", "*", "nelt", "/", "4", ")", "?", "24", ":", "0", ";", "for", "(", "j", "=", "0", ";", "j", "<", "eltsz", ";", "++", "j", ")", "{", "rperm", "[", "which", "]", "[", "(", "i", "*", "eltsz", "+", "j", ")", "^", "xorv", "]", "=", "GEN_INT", "(", "e", "*", "eltsz", "+", "j", ")", ";", "rperm", "[", "1", "-", "which", "]", "[", "(", "i", "*", "eltsz", "+", "j", ")", "^", "xorv", "]", "=", "m128", ";", "}", "}", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V32QImode", ",", "gen_rtvec_v", "(", "32", ",", "rperm", "[", "0", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V32QImode", ",", "vperm", ")", ";", "l", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V32QImode", ",", "d", "->", "op0", ")", ";", "emit_insn", "(", "gen_avx2_pshufbv32qi3", "(", "l", ",", "op", ",", "vperm", ")", ")", ";", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V32QImode", ",", "gen_rtvec_v", "(", "32", ",", "rperm", "[", "1", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V32QImode", ",", "vperm", ")", ";", "h", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V32QImode", ",", "d", "->", "op1", ")", ";", "emit_insn", "(", "gen_avx2_pshufbv32qi3", "(", "h", ",", "op", ",", "vperm", ")", ")", ";", "ior", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "emit_insn", "(", "gen_iorv32qi3", "(", "ior", ",", "l", ",", "h", ")", ")", ";", "op", "=", "gen_reg_rtx", "(", "V4DImode", ")", ";", "ior", "=", "gen_lowpart", "(", "V4DImode", ",", "ior", ")", ";", "emit_insn", "(", "gen_avx2_permv4di_1", "(", "op", ",", "ior", ",", "const0_rtx", ",", "const2_rtx", ",", "const1_rtx", ",", "GEN_INT", "(", "3", ")", ")", ")", ";", "emit_move_insn", "(", "d", "->", "target", ",", "gen_lowpart", "(", "d", "->", "vmode", ",", "op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "expand_vec_perm_even_odd_1", ".", "Implement", "extract-even", "and", "extract-odd", "permutations", "of", "two", "V32QImode", "and", "V16QImode", "operand", "with", "two", "vpshufb", "insns", ",", "vpor", "and", "vpermq", ".", "We", "should", "have", "already", "failed", "all", "two", "or", "three", "instruction", "sequences", "." ]

[ "i386", "2", "32", "0", "2", "3", "2", "128", "0", "2", "1", "4", "3", "4", "24", "0", "0", "1", "32", "0", "32", "1", "3" ]

[]