Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "recps_type", "get_recps_type", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "return", "(", "gen_aarch64_frecpssf", ")", ";", "case", "V2SFmode", ":", "return", "(", "gen_aarch64_frecpsv2sf", ")", ";", "case", "V4SFmode", ":", "return", "(", "gen_aarch64_frecpsv4sf", ")", ";", "case", "DFmode", ":", "return", "(", "gen_aarch64_frecpsdf", ")", ";", "case", "V2DFmode", ":", "return", "(", "gen_aarch64_frecpsv2df", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Select", "reciprocal", "series", "step", "insn", "depending", "on", "machine", "mode", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "char", "*", "output_fp_compare", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "bool", "eflags_p", ",", "bool", "unordered_p", ")", "{", "int", "stack_top_dies", ";", "rtx", "cmp_op0", ",", "cmp_op1", ";", "int", "is_sse", "=", "SSE_REG_P", "(", "operands", "[", "0", "]", ")", "||", "SSE_REG_P", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "eflags_p", ")", "{", "cmp_op0", "=", "operands", "[", "0", "]", ";", "cmp_op1", "=", "operands", "[", "1", "]", ";", "}", "else", "{", "cmp_op0", "=", "operands", "[", "1", "]", ";", "cmp_op1", "=", "operands", "[", "2", "]", ";", "}", "if", "(", "is_sse", ")", "{", "if", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "SFmode", ")", "if", "(", "unordered_p", ")", "return", "\"%vucomiss\\t{%1, %0|%0, %1}\"", ";", "else", "return", "\"%vcomiss\\t{%1, %0|%0, %1}\"", ";", "else", "if", "(", "unordered_p", ")", "return", "\"%vucomisd\\t{%1, %0|%0, %1}\"", ";", "else", "return", "\"%vcomisd\\t{%1, %0|%0, %1}\"", ";", "}", "gcc_assert", "(", "STACK_TOP_P", "(", "cmp_op0", ")", ")", ";", "stack_top_dies", "=", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "FIRST_STACK_REG", ")", "!=", "0", ";", "if", "(", "cmp_op1", "==", "CONST0_RTX", "(", "GET_MODE", "(", "cmp_op1", ")", ")", ")", "{", "if", "(", "stack_top_dies", ")", "{", "output_asm_insn", "(", "\"ftst\\n\\tfnstsw\\t%0\"", ",", "operands", ")", ";", "return", "output_387_ffreep", "(", "operands", ",", "1", ")", ";", "}", "else", "return", "\"ftst\\n\\tfnstsw\\t%0\"", ";", "}", "if", "(", "STACK_REG_P", "(", "cmp_op1", ")", "&&", "stack_top_dies", "&&", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "REGNO", "(", "cmp_op1", ")", ")", "&&", "REGNO", "(", "cmp_op1", ")", "!=", "FIRST_STACK_REG", ")", "{", "if", "(", "eflags_p", ")", "{", "if", "(", "unordered_p", ")", "output_asm_insn", "(", "\"fucomip\\t{%y1, %0|%0, %y1}\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"fcomip\\t{%y1, %0|%0, %y1}\"", ",", "operands", ")", ";", "return", "output_387_ffreep", "(", "operands", ",", "0", ")", ";", "}", "else", "{", "if", "(", "unordered_p", ")", "return", "\"fucompp\\n\\tfnstsw\\t%0\"", ";", "else", "return", "\"fcompp\\n\\tfnstsw\\t%0\"", ";", "}", "}", "else", "{", "static", "const", "char", "*", "const", "alt", "[", "16", "]", "=", "{", "\"fcom%Z2\\t%y2\\n\\tfnstsw\\t%0\"", ",", "\"fcomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"", ",", "\"fucom%Z2\\t%y2\\n\\tfnstsw\\t%0\"", ",", "\"fucomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"", ",", "\"ficom%Z2\\t%y2\\n\\tfnstsw\\t%0\"", ",", "\"ficomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"", ",", "NULL", ",", "NULL", ",", "\"fcomi\\t{%y1, %0|%0, %y1}\"", ",", "\"fcomip\\t{%y1, %0|%0, %y1}\"", ",", "\"fucomi\\t{%y1, %0|%0, %y1}\"", ",", "\"fucomip\\t{%y1, %0|%0, %y1}\"", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", "}", ";", "int", "mask", ";", "const", "char", "*", "ret", ";", "mask", "=", "eflags_p", "<<", "3", ";", "mask", "|=", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp_op1", ")", ")", "==", "MODE_INT", ")", "<<", "2", ";", "mask", "|=", "unordered_p", "<<", "1", ";", "mask", "|=", "stack_top_dies", ";", "gcc_assert", "(", "mask", "<", "16", ")", ";", "ret", "=", "alt", "[", "mask", "]", ";", "gcc_assert", "(", "ret", ")", ";", "return", "ret", ";", "}", "}", "</s>" ]

[ "Output", "code", "for", "INSN", "to", "compare", "OPERANDS", ".", "EFLAGS_P", "is", "1", "when", "fcomi", "should", "be", "used", "and", "2", "when", "fnstsw", "should", "be", "used", ".", "UNORDERED_P", "is", "true", "when", "fucom", "should", "be", "used", "." ]

[ "i386", "0", "1", "0", "1", "1", "2", "0", "\"%vucomiss\\t{%1, %0|%0, %1}\"", "\"%vcomiss\\t{%1, %0|%0, %1}\"", "\"%vucomisd\\t{%1, %0|%0, %1}\"", "\"%vcomisd\\t{%1, %0|%0, %1}\"", "0", "\"ftst\\n\\tfnstsw\\t%0\"", "1", "\"ftst\\n\\tfnstsw\\t%0\"", "\"fucomip\\t{%y1, %0|%0, %y1}\"", "\"fcomip\\t{%y1, %0|%0, %y1}\"", "0", "\"fucompp\\n\\tfnstsw\\t%0\"", "\"fcompp\\n\\tfnstsw\\t%0\"", "16", "\"fcom%Z2\\t%y2\\n\\tfnstsw\\t%0\"", "\"fcomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"", "\"fucom%Z2\\t%y2\\n\\tfnstsw\\t%0\"", "\"fucomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"", "\"ficom%Z2\\t%y2\\n\\tfnstsw\\t%0\"", "\"ficomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"", "\"fcomi\\t{%y1, %0|%0, %y1}\"", "\"fcomip\\t{%y1, %0|%0, %y1}\"", "\"fucomi\\t{%y1, %0|%0, %y1}\"", "\"fucomip\\t{%y1, %0|%0, %y1}\"", "3", "2", "1", "16" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "F2003fRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "F2003f", "::", "RegRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "F2003f", "F2003f", "F2003f::RegRegClass" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "AArch64InstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "AArch64II", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_PAGE", ",", "\"aarch64-page\"", "}", ",", "{", "MO_PAGEOFF", ",", "\"aarch64-pageoff\"", "}", ",", "{", "MO_G3", ",", "\"aarch64-g3\"", "}", ",", "{", "MO_G2", ",", "\"aarch64-g2\"", "}", ",", "{", "MO_G1", ",", "\"aarch64-g1\"", "}", ",", "{", "MO_G0", ",", "\"aarch64-g0\"", "}", ",", "{", "MO_HI12", ",", "\"aarch64-hi12\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "AArch64", "AArch64", "AArch64", "\"aarch64-page\"", "\"aarch64-pageoff\"", "\"aarch64-g3\"", "\"aarch64-g2\"", "\"aarch64-g1\"", "\"aarch64-g0\"", "\"aarch64-hi12\"" ]

[]

[ "<s>", "int", "pa_attr_length_call", "(", "rtx_insn", "*", "insn", ",", "int", "sibcall", ")", "{", "int", "local_call", ";", "rtx", "call", ",", "call_dest", ";", "tree", "call_decl", ";", "int", "length", "=", "0", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "unsigned", "long", "distance", "=", "-", "1", ";", "gcc_assert", "(", "CALL_P", "(", "insn", ")", ")", ";", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "unsigned", "long", "total", ";", "total", "=", "IN_NAMED_SECTION_P", "(", "cfun", "->", "decl", ")", "?", "0", ":", "total_code_bytes", ";", "distance", "=", "(", "total", "+", "insn_current_reference_address", "(", "insn", ")", ")", ";", "if", "(", "distance", "<", "total", ")", "distance", "=", "-", "1", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", ";", "call", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "==", "SET", ")", "call", "=", "SET_SRC", "(", "call", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "call", ")", "==", "CALL", ")", ";", "call_dest", "=", "XEXP", "(", "XEXP", "(", "call", ",", "0", ")", ",", "0", ")", ";", "call_decl", "=", "SYMBOL_REF_DECL", "(", "call_dest", ")", ";", "local_call", "=", "call_decl", "&&", "targetm", ".", "binds_local_p", "(", "call_decl", ")", ";", "if", "(", "!", "TARGET_LONG_CALLS", "&&", "(", "(", "TARGET_PA_20", "&&", "!", "sibcall", "&&", "distance", "<", "7600000", ")", "||", "distance", "<", "MAX_PCREL17F_OFFSET", ")", ")", "length", "+=", "8", ";", "else", "if", "(", "TARGET_64BIT", "&&", "!", "local_call", ")", "length", "+=", "sibcall", "?", "28", ":", "24", ";", "else", "if", "(", "(", "TARGET_LONG_ABS_CALL", "||", "local_call", ")", "&&", "!", "flag_pic", ")", "length", "+=", "12", ";", "else", "if", "(", "TARGET_LONG_PIC_SDIFF_CALL", "||", "(", "TARGET_GAS", "&&", "!", "TARGET_SOM", "&&", "(", "TARGET_LONG_PIC_PCREL_CALL", "||", "local_call", ")", ")", ")", "{", "length", "+=", "20", ";", "if", "(", "!", "TARGET_PA_20", "&&", "!", "TARGET_NO_SPACE_REGS", "&&", "(", "!", "local_call", "||", "flag_pic", ")", ")", "length", "+=", "8", ";", "}", "else", "{", "length", "+=", "32", ";", "if", "(", "TARGET_SOM", ")", "length", "+=", "length_fp_args", "(", "insn", ")", ";", "if", "(", "flag_pic", ")", "length", "+=", "4", ";", "if", "(", "!", "TARGET_PA_20", ")", "{", "if", "(", "!", "sibcall", ")", "length", "+=", "8", ";", "if", "(", "!", "TARGET_NO_SPACE_REGS", "&&", "(", "!", "local_call", "||", "flag_pic", ")", ")", "length", "+=", "8", ";", "}", "}", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "attribute", "length", "of", "the", "call", "instruction", "INSN", ".", "The", "SIBCALL", "flag", "indicates", "whether", "INSN", "is", "a", "regular", "call", "or", "a", "sibling", "call", ".", "The", "length", "returned", "must", "be", "longer", "than", "the", "code", "actually", "generated", "by", "pa_output_call", ".", "Since", "branch", "shortening", "is", "done", "before", "delay", "branch", "sequencing", ",", "there", "is", "no", "way", "to", "determine", "whether", "or", "not", "the", "delay", "slot", "will", "be", "filled", "during", "branch", "shortening", ".", "Even", "when", "the", "delay", "slot", "is", "filled", ",", "we", "may", "have", "to", "add", "a", "nop", "if", "the", "delay", "slot", "contains", "a", "branch", "that", "ca", "n't", "reach", "its", "target", ".", "Thus", ",", "we", "always", "have", "to", "include", "the", "delay", "slot", "in", "the", "length", "estimate", ".", "This", "used", "to", "be", "done", "in", "pa_adjust_insn_length", "but", "we", "do", "it", "here", "now", "as", "some", "sequences", "always", "fill", "the", "delay", "slot", "and", "we", "can", "save", "four", "bytes", "in", "the", "estimate", "for", "these", "sequences", "." ]

[ "pa", "0", "1", "0", "1", "0", "0", "0", "0", "7600000", "8", "28", "24", "12", "20", "8", "32", "4", "8", "8" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"R600 Eliminate Symbolic Operand\"", ";", "}", "</s>" ]

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

[ "R600", "\"R600 Eliminate Symbolic Operand\"" ]

[]

[ "<s>", "unsigned", "X86TTIImpl", "::", "getNumberOfRegisters", "(", "unsigned", "ClassID", ")", "const", "{", "bool", "Vector", "=", "(", "ClassID", "==", "1", ")", ";", "if", "(", "Vector", "&&", "!", "ST", "->", "hasSSE1", "(", ")", ")", "return", "0", ";", "if", "(", "ST", "->", "is64Bit", "(", ")", ")", "{", "if", "(", "Vector", "&&", "ST", "->", "hasAVX512", "(", ")", ")", "return", "32", ";", "return", "16", ";", "}", "return", "8", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "X86", "X86", "1", "0", "32", "16", "8" ]

[]

[ "<s>", "static", "SDValue", "WidenVector", "(", "SDValue", "V64Reg", ",", "SelectionDAG", "&", "DAG", ")", "{", "EVT", "VT", "=", "V64Reg", ".", "getValueType", "(", ")", ";", "unsigned", "NarrowSize", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "EltTy", "=", "VT", ".", "getVectorElementType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "MVT", "WideTy", "=", "MVT", "::", "getVectorVT", "(", "EltTy", ",", "2", "*", "NarrowSize", ")", ";", "SDLoc", "DL", "(", "V64Reg", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "DL", ",", "WideTy", ",", "DAG", ".", "getUNDEF", "(", "WideTy", ")", ",", "V64Reg", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "}", "</s>" ]

[ "Widen", "the", "vector", "up", "to", "the", "next", "power", "of", "two", "using", "INSERT_SUBVECTOR", "." ]

[ "AArch64", "MVT::getVectorVT", "2", "ISD::INSERT_SUBVECTOR", "0", "MVT::i64" ]

[]

[ "<s>", "static", "int", "ia64_dfa_sched_reorder", "(", "FILE", "*", "dump", ",", "int", "sched_verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "pn_ready", ",", "int", "clock_var", ",", "int", "reorder_type", ")", "{", "int", "n_asms", ";", "int", "n_ready", "=", "*", "pn_ready", ";", "rtx_insn", "*", "*", "e_ready", "=", "ready", "+", "n_ready", ";", "rtx_insn", "*", "*", "insnp", ";", "if", "(", "sched_verbose", ")", "fprintf", "(", "dump", ",", "\"// ia64_dfa_sched_reorder (type %d):\\n\"", ",", "reorder_type", ")", ";", "if", "(", "reorder_type", "==", "0", ")", "{", "n_asms", "=", "0", ";", "for", "(", "insnp", "=", "ready", ";", "insnp", "<", "e_ready", ";", "insnp", "++", ")", "if", "(", "insnp", "<", "e_ready", ")", "{", "rtx_insn", "*", "insn", "=", "*", "insnp", ";", "enum", "attr_type", "t", "=", "ia64_safe_type", "(", "insn", ")", ";", "if", "(", "t", "==", "TYPE_UNKNOWN", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", ")", "{", "rtx_insn", "*", "lowest", "=", "ready", "[", "n_asms", "]", ";", "ready", "[", "n_asms", "]", "=", "insn", ";", "*", "insnp", "=", "lowest", ";", "n_asms", "++", ";", "}", "else", "{", "rtx_insn", "*", "highest", "=", "ready", "[", "n_ready", "-", "1", "]", ";", "ready", "[", "n_ready", "-", "1", "]", "=", "insn", ";", "*", "insnp", "=", "highest", ";", "return", "1", ";", "}", "}", "}", "if", "(", "n_asms", "<", "n_ready", ")", "{", "ready", "+=", "n_asms", ";", "n_ready", "-=", "n_asms", ";", "}", "else", "if", "(", "n_ready", ">", "0", ")", "return", "1", ";", "}", "if", "(", "ia64_final_schedule", ")", "{", "int", "deleted", "=", "0", ";", "int", "nr_need_stop", "=", "0", ";", "for", "(", "insnp", "=", "ready", ";", "insnp", "<", "e_ready", ";", "insnp", "++", ")", "if", "(", "safe_group_barrier_needed", "(", "*", "insnp", ")", ")", "nr_need_stop", "++", ";", "if", "(", "reorder_type", "==", "1", "&&", "n_ready", "==", "nr_need_stop", ")", "return", "0", ";", "if", "(", "reorder_type", "==", "0", ")", "return", "1", ";", "insnp", "=", "e_ready", ";", "while", "(", "insnp", "--", ">", "ready", "+", "deleted", ")", "while", "(", "insnp", ">=", "ready", "+", "deleted", ")", "{", "rtx_insn", "*", "insn", "=", "*", "insnp", ";", "if", "(", "!", "safe_group_barrier_needed", "(", "insn", ")", ")", "break", ";", "memmove", "(", "ready", "+", "1", ",", "ready", ",", "(", "insnp", "-", "ready", ")", "*", "sizeof", "(", "rtx", ")", ")", ";", "*", "ready", "=", "insn", ";", "deleted", "++", ";", "}", "n_ready", "-=", "deleted", ";", "ready", "+=", "deleted", ";", "}", "current_cycle", "=", "clock_var", ";", "if", "(", "reload_completed", "&&", "mem_ops_in_group", "[", "clock_var", "%", "4", "]", ">=", "ia64_max_memory_insns", ")", "{", "int", "moved", "=", "0", ";", "insnp", "=", "e_ready", ";", "while", "(", "insnp", "--", ">", "ready", "+", "moved", ")", "while", "(", "insnp", ">=", "ready", "+", "moved", ")", "{", "rtx_insn", "*", "insn", "=", "*", "insnp", ";", "if", "(", "!", "is_load_p", "(", "insn", ")", ")", "break", ";", "memmove", "(", "ready", "+", "1", ",", "ready", ",", "(", "insnp", "-", "ready", ")", "*", "sizeof", "(", "rtx", ")", ")", ";", "*", "ready", "=", "insn", ";", "moved", "++", ";", "}", "n_ready", "-=", "moved", ";", "ready", "+=", "moved", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "We", "are", "about", "to", "being", "issuing", "insns", "for", "this", "clock", "cycle", ".", "Override", "the", "default", "sort", "algorithm", "to", "better", "slot", "instructions", "." ]

[ "ia64", "\"// ia64_dfa_sched_reorder (type %d):\\n\"", "0", "0", "0", "1", "1", "1", "0", "1", "0", "0", "1", "0", "0", "1", "1", "4", "0", "1", "1" ]

[]

[ "<s>", "const", "X86_64GOT", "&", "X86_64GNULDBackend", "::", "getGOT", "(", ")", "const", "{", "assert", "(", "m_pGOT", "!=", "NULL", ")", ";", "return", "*", "m_pGOT", ";", "}", "</s>" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "global", "offset", "table", "(", "or", "something", "the", "like", ")", "." ]

[ "X86", "X86", "X86" ]

[]

[ "<s>", "unsigned", "MBlazeRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "int", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "oi", "=", "i", "==", "2", "?", "1", ":", "2", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "int", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "int", "Offset", "=", "(", "spOffset", "<", "0", ")", "?", "(", "stackSize", "-", "spOffset", ")", ":", "(", "spOffset", "+", "4", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "oi", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "MI", ".", "getOperand", "(", "oi", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "MBlaze", "MBlaze", "0", "\"Instr doesn't have FrameIndex operand!\"", "2", "1", "2", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "0", "4", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "0" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", "->", "print", "(", "errs", "(", ")", ",", "&", "DAG", ")", ";", "llvm_unreachable", "(", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FREM", ":", "return", "LowerFREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCEIL", ":", "return", "LowerFCEIL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FTRUNC", ":", "return", "LowerFTRUNC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRINT", ":", "return", "LowerFRINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEARBYINT", ":", "return", "LowerFNEARBYINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FROUND", ":", "return", "LowerFROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FFLOOR", ":", "return", "LowerFFLOOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLOG", ":", "return", "LowerFLOG", "(", "Op", ",", "DAG", ",", "1", "/", "AMDGPU_LOG2E_F", ")", ";", "case", "ISD", "::", "FLOG10", ":", "return", "LowerFLOG", "(", "Op", ",", "DAG", ",", "AMDGPU_LN2_F", "/", "AMDGPU_LN10_F", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_FP16", ":", "return", "LowerFP_TO_FP16", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ_CTTZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::UDIVREM", "ISD::SDIVREM", "ISD::FREM", "ISD::FCEIL", "ISD::FTRUNC", "ISD::FRINT", "ISD::FNEARBYINT", "ISD::FROUND", "ISD::FFLOOR", "ISD::FLOG", "1", "AMDGPU", "ISD::FLOG10", "AMDGPU", "AMDGPU", "ISD::SINT_TO_FP", "SI", "ISD::UINT_TO_FP", "ISD::FP_TO_FP16", "ISD::FP_TO_SINT", "SI", "ISD::FP_TO_UINT", "ISD::CTTZ", "ISD::CTTZ_ZERO_UNDEF", "ISD::CTLZ", "ISD::CTLZ_ZERO_UNDEF", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "LLT", "MemTy", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "LLT", "ValTy", "(", "VA", ".", "getValVT", "(", ")", ")", ";", "LLT", "LocTy", "(", "VA", ".", "getLocVT", "(", ")", ")", ";", "if", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i8", "||", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i16", ")", "std", "::", "swap", "(", "ValTy", ",", "LocTy", ")", ";", "else", "{", "assert", "(", "LocTy", ".", "getSizeInBits", "(", ")", "==", "MemTy", ".", "getSizeInBits", "(", ")", ")", ";", "LocTy", "=", "MemTy", ";", "}", "auto", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOInvariant", ",", "LocTy", ",", "inferAlignFromPtrInfo", "(", "MF", ",", "MPO", ")", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "LocInfo", "::", "ZExt", ":", "MIRBuilder", ".", "buildLoadInstr", "(", "TargetOpcode", "::", "G_ZEXTLOAD", ",", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "return", ";", "case", "CCValAssign", "::", "LocInfo", "::", "SExt", ":", "MIRBuilder", ".", "buildLoadInstr", "(", "TargetOpcode", "::", "G_SEXTLOAD", ",", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "return", ";", "default", ":", "MIRBuilder", ".", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "AArch64", "MVT::i8", "MVT::i16" ]

[]

[ "<s>", "void", "WebAssemblyTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IntNo", "=", "Op", ".", "getConstantOperandVal", "(", "0", ")", ";", "switch", "(", "IntNo", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "wasm_bitmask", ":", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getOperand", "(", "1", ")", ".", "getSimpleValueType", "(", ")", ";", "unsigned", "PossibleBits", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "APInt", "ZeroMask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "PossibleBits", ")", ";", "Known", ".", "Zero", "|=", "ZeroMask", ";", "break", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "WebAssembly", "WebAssembly", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::wasm_bitmask", "1" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "optForSize", "(", ")", ")", "return", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "value_op_begin", "(", ")", ",", "I", ".", "value_op_end", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ")", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "0", "4", "\"Cost of loop: \"", "\"\\n\"", "4", "12" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "hasLowDefLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "DefMI", ",", "unsigned", "DefIdx", ")", "const", "{", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "false", ";", "unsigned", "DDomain", "=", "DefMI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "if", "(", "DDomain", "==", "ARMII", "::", "DomainGeneral", ")", "{", "unsigned", "DefClass", "=", "DefMI", "->", "getDesc", "(", ")", ".", "getSchedClass", "(", ")", ";", "int", "DefCycle", "=", "ItinData", "->", "getOperandCycle", "(", "DefClass", ",", "DefIdx", ")", ";", "return", "(", "DefCycle", "!=", "-", "1", "&&", "DefCycle", "<=", "2", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Compute", "operand", "latency", "of", "a", "def", "of", "'Reg", "'", "." ]

[ "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainGeneral", "1", "2" ]

[]

[ "<s>", "unsigned", "HexagonMCInstrInfo", "::", "getType", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "const", "uint64_t", "F", "=", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "MCI", ")", ".", "TSFlags", ";", "return", "(", "(", "F", ">>", "HexagonII", "::", "TypePos", ")", "&", "HexagonII", "::", "TypeMask", ")", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "HexagonII::TypePos", "HexagonII::TypeMask" ]

[]

[ "<s>", "static", "void", "ix86_lower_local_decl_alignment", "(", "tree", "decl", ")", "{", "unsigned", "int", "new_align", "=", "ix86_local_alignment", "(", "decl", ",", "VOIDmode", ",", "DECL_ALIGN", "(", "decl", ")", ",", "true", ")", ";", "if", "(", "new_align", "<", "DECL_ALIGN", "(", "decl", ")", ")", "SET_DECL_ALIGN", "(", "decl", ",", "new_align", ")", ";", "}", "</s>" ]

[ "Implememnt", "TARGET_LOWER_LOCAL_DECL_ALIGNMENT", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "query", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "&", "AA", ",", "bool", "&", "Read", ",", "bool", "&", "Write", ",", "bool", "&", "Effects", ",", "bool", "&", "StackPointer", ")", "{", "assert", "(", "!", "MI", ".", "isTerminator", "(", ")", ")", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", "&&", "!", "MI", ".", "isDereferenceableInvariantLoad", "(", "&", "AA", ")", ")", "Read", "=", "true", ";", "if", "(", "MI", ".", "mayStore", "(", ")", ")", "{", "Write", "=", "true", ";", "}", "else", "if", "(", "MI", ".", "hasOrderedMemoryRef", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "DIV_S_I32", ":", "case", "WebAssembly", "::", "DIV_S_I64", ":", "case", "WebAssembly", "::", "REM_S_I32", ":", "case", "WebAssembly", "::", "REM_S_I64", ":", "case", "WebAssembly", "::", "DIV_U_I32", ":", "case", "WebAssembly", "::", "DIV_U_I64", ":", "case", "WebAssembly", "::", "REM_U_I32", ":", "case", "WebAssembly", "::", "REM_U_I64", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F64", ":", "break", ";", "default", ":", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "{", "Write", "=", "true", ";", "Effects", "=", "true", ";", "}", "break", ";", "}", "}", "if", "(", "MI", ".", "hasUnmodeledSideEffects", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "DIV_S_I32", ":", "case", "WebAssembly", "::", "DIV_S_I64", ":", "case", "WebAssembly", "::", "REM_S_I32", ":", "case", "WebAssembly", "::", "REM_S_I64", ":", "case", "WebAssembly", "::", "DIV_U_I32", ":", "case", "WebAssembly", "::", "DIV_U_I64", ":", "case", "WebAssembly", "::", "REM_U_I32", ":", "case", "WebAssembly", "::", "REM_U_I64", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F64", ":", "break", ";", "default", ":", "Effects", "=", "true", ";", "break", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "GLOBAL_SET_I32", "&&", "strcmp", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "\"__stack_pointer\"", ")", "==", "0", ")", "StackPointer", "=", "true", ";", "if", "(", "MI", ".", "isCall", "(", ")", ")", "{", "unsigned", "CalleeOpNo", "=", "WebAssembly", "::", "getCalleeOpNo", "(", "MI", ")", ";", "queryCallee", "(", "MI", ",", "CalleeOpNo", ",", "Read", ",", "Write", ",", "Effects", ",", "StackPointer", ")", ";", "}", "}", "</s>" ]

[ "Query", "a", "line", "of", "the", "assigned", "virtual", "register", "matrix", "directly", "." ]

[ "WebAssembly", "WebAssembly::DIV_S_I32", "WebAssembly::DIV_S_I64", "WebAssembly::REM_S_I32", "WebAssembly::REM_S_I64", "WebAssembly::DIV_U_I32", "WebAssembly::DIV_U_I64", "WebAssembly::REM_U_I32", "WebAssembly::REM_U_I64", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::DIV_S_I32", "WebAssembly::DIV_S_I64", "WebAssembly::REM_S_I32", "WebAssembly::REM_S_I64", "WebAssembly::DIV_U_I32", "WebAssembly::DIV_U_I64", "WebAssembly::REM_U_I32", "WebAssembly::REM_U_I64", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::GLOBAL_SET_I32", "0", "\"__stack_pointer\"", "0", "WebAssembly::getCalleeOpNo" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "(", "Count", "%", "4", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "4", ")", "OW", "->", "write32", "(", "0x13", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "RISCV", "RISCV", "4", "0", "0", "4", "0x13" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getFrameInfo", "(", ")", "->", "hasStackObjects", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "Subtarget", ".", "is64BitELFABI", "(", ")", ")", "return", "LowerFormalArguments_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", ")", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::InputArg" ]

[]

[ "<s>", "bool", "AMDGPUAlwaysInline", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "std", "::", "vector", "<", "Function", "*", ">", "FuncsToClone", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "hasLocalLinkage", "(", ")", "&&", "!", "F", ".", "isDeclaration", "(", ")", "&&", "!", "F", ".", "use_empty", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoInline", ")", ")", "FuncsToClone", ".", "push_back", "(", "&", "F", ")", ";", "}", "for", "(", "Function", "*", "F", ":", "FuncsToClone", ")", "{", "ValueToValueMapTy", "VMap", ";", "Function", "*", "NewFunc", "=", "CloneFunction", "(", "F", ",", "VMap", ")", ";", "NewFunc", "->", "setLinkage", "(", "GlobalValue", "::", "InternalLinkage", ")", ";", "F", "->", "replaceAllUsesWith", "(", "NewFunc", ")", ";", "}", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "hasLocalLinkage", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoInline", ")", ")", "{", "F", ".", "addFnAttr", "(", "Attribute", "::", "AlwaysInline", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "csky_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "return", "(", "GET_MODE_SIZE", "(", "from", ")", "==", "GET_MODE_SIZE", "(", "to", ")", "||", "!", "reg_classes_intersect_p", "(", "V_REGS", ",", "rclass", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", ".", "V_REG", "registers", "ca", "n't", "do", "subreg", "as", "all", "values", "are", "reformatted", "to", "internal", "precision", "." ]

[ "csky" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "GBZ80RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "GB", "::", "R16RegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "GBZ80", "GB", "GB::R16RegClass" ]

[]

[ "<s>", "bool", "X86SpeculativeExecutionSideEffectSuppression", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "auto", "&", "OptLevel", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "EnableSpeculativeExecutionSideEffectSuppression", "&&", "!", "(", "Subtarget", ".", "useLVILoadHardening", "(", ")", "&&", "OptLevel", "==", "CodeGenOpt", "::", "None", ")", "&&", "!", "Subtarget", ".", "useSpeculativeExecutionSideEffectSuppression", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" **********\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "const", "X86InstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineInstr", "*", "FirstTerminator", "=", "nullptr", ";", "bool", "PrevInstIsLFENCE", "=", "false", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "X86", "::", "LFENCE", ")", "{", "PrevInstIsLFENCE", "=", "true", ";", "continue", ";", "}", "if", "(", "MI", ".", "mayLoadOrStore", "(", ")", "&&", "!", "MI", ".", "isTerminator", "(", ")", ")", "{", "if", "(", "!", "PrevInstIsLFENCE", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "NumLFENCEsInserted", "++", ";", "Modified", "=", "true", ";", "}", "if", "(", "OneLFENCEPerBasicBlock", ")", "break", ";", "}", "if", "(", "MI", ".", "isTerminator", "(", ")", "&&", "FirstTerminator", "==", "nullptr", ")", "FirstTerminator", "=", "&", "MI", ";", "if", "(", "!", "MI", ".", "isBranch", "(", ")", "||", "OmitBranchLFENCEs", ")", "{", "PrevInstIsLFENCE", "=", "false", ";", "continue", ";", "}", "if", "(", "OnlyLFENCENonConst", "&&", "hasConstantAddressingMode", "(", "MI", ")", ")", "{", "PrevInstIsLFENCE", "=", "false", ";", "continue", ";", "}", "if", "(", "!", "PrevInstIsLFENCE", ")", "{", "assert", "(", "FirstTerminator", "&&", "\"Unknown terminator instruction\"", ")", ";", "BuildMI", "(", "MBB", ",", "FirstTerminator", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "NumLFENCEsInserted", "++", ";", "Modified", "=", "true", ";", "}", "break", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"********** \"", "\" : \"", "\" **********\\n\"", "X86", "X86::LFENCE", "X86::LFENCE", "\"Unknown terminator instruction\"", "X86::LFENCE" ]

[]

[ "<s>", "static", "void", "s300_set_up_by_prologue", "(", "hard_reg_set_container", "*", "regs", ")", "{", "if", "(", "cfun", "->", "machine", "->", "base_reg", "&&", "!", "call_really_used_regs", "[", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "]", ")", "SET_HARD_REG_BIT", "(", "regs", "->", "set", ",", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SET_UP_BY_PROLOGUE", "." ]

[ "s390" ]

[]

[ "<s>", "static", "inline", "bool", "getConstantValue", "(", "SDValue", "N", ",", "uint32_t", "&", "Out", ")", "{", "if", "(", "N", ".", "isUndef", "(", ")", ")", "{", "Out", "=", "0", ";", "return", "true", ";", "}", "if", "(", "const", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", ")", ")", "{", "Out", "=", "C", "->", "getAPIntValue", "(", ")", ".", "getSExtValue", "(", ")", ";", "return", "true", ";", "}", "if", "(", "const", "ConstantFPSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "N", ")", ")", "{", "Out", "=", "C", "->", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getSExtValue", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Converts", "a", "Constant", "*", "into", "a", "GenericValue", ",", "including", "handling", "of", "ConstantExpr", "values", "." ]

[ "AMDGPU", "0" ]

[]

[ "<s>", "SDValue", "ARCompactTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "default", ":", "assert", "(", "0", "&&", "\"Unimplemented operation!\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

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

[ "ARCompact", "ARC", "ISD::GlobalAddress", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "0", "\"Unimplemented operation!\"" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedCompressStore", "(", "Type", "*", "DataTy", ")", "{", "return", "isLegalMaskedExpandLoad", "(", "DataTy", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "compress", "store", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "LinearizedRegion", "::", "contains", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "return", "MBBs", ".", "contains", "(", "MBB", ")", ";", "}", "</s>" ]

[ "contains", "-", "Returns", "true", "if", "this", "trace", "contains", "the", "given", "basic", "block", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "WebAssemblyTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "const", "{", "for", "(", "BasicBlock", "*", "BB", ":", "L", "->", "blocks", "(", ")", ")", "for", "(", "Instruction", "&", "I", ":", "*", "BB", ")", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "if", "(", "isLoweredToCall", "(", "F", ")", ")", "return", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "30", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "UP", ".", "BEInsns", "=", "2", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "WebAssembly", "WebAssembly", "30", "0", "0", "2" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ReserveX18", "(", "TT", ".", "isOSDarwin", "(", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ",", "CPU", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "GISel", "(", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUAlwaysInline", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "return", "alwaysInlineImpl", "(", "M", ",", "GlobalOpt", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "mips_expand_vpc_loongson_pshufh", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "mask", ";", "rtx", "rmask", ";", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_LOONGSON_VECTORS", ")", ")", "return", "false", ";", "if", "(", "d", "->", "vmode", "!=", "V4HImode", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "for", "(", "i", "=", "mask", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "mask", "|=", "(", "d", "->", "perm", "[", "i", "]", "&", "3", ")", "<<", "(", "i", "*", "2", ")", ";", "rmask", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "mask", ")", ")", ";", "if", "(", "d", "->", "one_vector_p", ")", "emit_insn", "(", "gen_loongson_pshufh", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "rmask", ")", ")", ";", "else", "{", "rtx", "t0", ",", "t1", ",", "x", ",", "merge", ",", "rmerge", "[", "4", "]", ";", "t0", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "t1", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "emit_insn", "(", "gen_loongson_pshufh", "(", "t1", ",", "d", "->", "op1", ",", "rmask", ")", ")", ";", "emit_insn", "(", "gen_loongson_pshufh", "(", "t0", ",", "d", "->", "op0", ",", "rmask", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "rmerge", "[", "i", "]", "=", "(", "d", "->", "perm", "[", "i", "]", "&", "4", "?", "constm1_rtx", ":", "const0_rtx", ")", ";", "merge", "=", "gen_rtx_CONST_VECTOR", "(", "V4HImode", ",", "gen_rtvec_v", "(", "4", ",", "rmerge", ")", ")", ";", "merge", "=", "force_reg", "(", "V4HImode", ",", "merge", ")", ";", "x", "=", "gen_rtx_AND", "(", "V4HImode", ",", "merge", ",", "t1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "t1", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "V4HImode", ",", "merge", ")", ";", "x", "=", "gen_rtx_AND", "(", "V4HImode", ",", "x", ",", "t0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "t0", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_IOR", "(", "V4HImode", ",", "t0", ",", "t1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "d", "->", "target", ",", "x", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "Loongson", "PSHUFH", "instruction", "." ]

[ "mips", "0", "4", "3", "2", "4", "0", "4", "4", "4" ]

[]

[ "<s>", "void", "xstormy16_expand_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "MEM_P", "(", "dest", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "PRE_MODIFY", ")", ")", "{", "rtx", "pmv", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "rtx", "dest_reg", "=", "XEXP", "(", "pmv", ",", "0", ")", ";", "rtx", "dest_mod", "=", "XEXP", "(", "pmv", ",", "1", ")", ";", "rtx", "set", "=", "gen_rtx_SET", "(", "Pmode", ",", "dest_reg", ",", "dest_mod", ")", ";", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "BImode", ",", "CARRY_REGNUM", ")", ")", ";", "dest", "=", "gen_rtx_MEM", "(", "mode", ",", "dest_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "PRE_MODIFY", ")", ")", "{", "rtx", "pmv", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "src_reg", "=", "XEXP", "(", "pmv", ",", "0", ")", ";", "rtx", "src_mod", "=", "XEXP", "(", "pmv", ",", "1", ")", ";", "rtx", "set", "=", "gen_rtx_SET", "(", "Pmode", ",", "src_reg", ",", "src_mod", ")", ";", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "BImode", ",", "CARRY_REGNUM", ")", ")", ";", "src", "=", "gen_rtx_MEM", "(", "mode", ",", "src_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "if", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", "&&", "MEM_P", "(", "dest", ")", "&&", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "||", "!", "xstormy16_legitimate_address_p", "(", "mode", ",", "XEXP", "(", "dest", ",", "0", ")", ",", "0", ")", ")", "&&", "!", "xstormy16_below100_operand", "(", "dest", ",", "mode", ")", "&&", "!", "REG_P", "(", "src", ")", "&&", "GET_CODE", "(", "src", ")", "!=", "SUBREG", ")", "src", "=", "copy_to_mode_reg", "(", "mode", ",", "src", ")", ";", "if", "(", "reload_completed", "&&", "mode", "!=", "HImode", "&&", "mode", "!=", "QImode", ")", "{", "xstormy16_split_move", "(", "mode", ",", "dest", ",", "src", ")", ";", "return", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src", ")", ")", ";", "}", "</s>" ]

[ "Expander", "for", "the", "'move", "'", "patterns", ".", "Emit", "insns", "to", "copy", "a", "value", "of", "mode", "MODE", "from", "SRC", "to", "DEST", "." ]

[ "stormy16", "0", "0", "0", "1", "2", "0", "0", "0", "1", "2", "0", "0", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "aarch64_sve_ld1ro_operand_p", "(", "rtx", "op", ",", "scalar_mode", "elem_mode", ")", "{", "return", "aarch64_sve_ld1rq_ld1ro_operand_p", "(", "op", ",", "OImode", ",", "elem_mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "valid", "MEM", "operand", "for", "an", "SVE", "LD1RO", "instruction", "for", "accessing", "a", "vector", "where", "the", "element", "size", "is", "specified", "by", "`", "elem_mode", "`", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Emit Clause Markers Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"R600 Emit Clause Markers Pass\"" ]

[]

[ "<s>", "static", "void", "s390_code_end", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "16", ";", "i", "++", ")", "{", "if", "(", "indirect_branch_z10thunk_mask", "&", "(", "1", "<<", "i", ")", ")", "s390_output_indirect_thunk_function", "(", "i", ",", "true", ")", ";", "if", "(", "indirect_branch_prez10thunk_mask", "&", "(", "1", "<<", "i", ")", ")", "s390_output_indirect_thunk_function", "(", "i", ",", "false", ")", ";", "}", "if", "(", "TARGET_INDIRECT_BRANCH_TABLE", ")", "{", "int", "o", ";", "int", "i", ";", "for", "(", "o", "=", "0", ";", "o", "<", "INDIRECT_BRANCH_NUM_OPTIONS", ";", "o", "++", ")", "{", "if", "(", "indirect_branch_table_label_no", "[", "o", "]", "==", "0", ")", "continue", ";", "switch_to_section", "(", "get_section", "(", "indirect_branch_table_name", "[", "o", "]", ",", "0", ",", "NULL_TREE", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "indirect_branch_table_label_no", "[", "o", "]", ";", "i", "++", ")", "{", "char", "label_start", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "label_start", ",", "indirect_branch_table_label", "[", "o", "]", ",", "i", ")", ";", "fputs", "(", "\"\\t.long\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "label_start", ")", ";", "fputs", "(", "\"-.\\n\"", ",", "asm_out_file", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Implement", "the", "asm.code_end", "target", "hook", "." ]

[ "s390", "1", "16", "1", "1", "0", "0", "0", "0", "32", "\"\\t.long\\t\"", "\"-.\\n\"" ]

[]

[ "<s>", "SDValue", "MipsDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "unsigned", "GP", "=", "0", ";", "for", "(", "MachineRegisterInfo", "::", "livein_iterator", "ii", "=", "MF", "->", "getRegInfo", "(", ")", ".", "livein_begin", "(", ")", ",", "ee", "=", "MF", "->", "getRegInfo", "(", ")", ".", "livein_end", "(", ")", ";", "ii", "!=", "ee", ";", "++", "ii", ")", "if", "(", "ii", "->", "first", "==", "Mips", "::", "GP", ")", "{", "GP", "=", "ii", "->", "second", ";", "break", ";", "}", "assert", "(", "GP", "&&", "\"GOT PTR not in liveins\"", ")", ";", "return", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "DebugLoc", "::", "getUnknownLoc", "(", ")", ",", "GP", ",", "MVT", "::", "i32", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Mips", "Mips", "0", "Mips::GP", "\"GOT PTR not in liveins\"", "MVT::i32" ]

[]

[ "<s>", "bool", "cris_cc0_user_requires_cmp", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "cc0_user", "=", "NULL", ";", "rtx", "body", ";", "rtx", "set", ";", "gcc_assert", "(", "insn", "!=", "NULL", ")", ";", "if", "(", "!", "TARGET_V32", ")", "return", "false", ";", "cc0_user", "=", "next_cc0_user", "(", "insn", ")", ";", "if", "(", "cc0_user", "==", "NULL", ")", "return", "false", ";", "body", "=", "PATTERN", "(", "cc0_user", ")", ";", "set", "=", "single_set", "(", "cc0_user", ")", ";", "if", "(", "JUMP_P", "(", "cc0_user", ")", "&&", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "SET_DEST", "(", "body", ")", "==", "pc_rtx", "&&", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "IF_THEN_ELSE", "&&", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ",", "0", ")", "==", "cc0_rtx", ")", "{", "return", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "==", "GT", "||", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "==", "LE", ";", "}", "else", "if", "(", "set", ")", "{", "return", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "GT", "||", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "LE", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Whether", "next_cc0_user", "of", "insn", "is", "LE", "or", "GT", "or", "requires", "a", "real", "compare", "insn", "for", "other", "reasons", "." ]

[ "cris", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "OR1K" ]

[]

[ "<s>", "const", "char", "*", "WebAssemblyAsmPrinter", "::", "toString", "(", "MVT", "VT", ")", "const", "{", "return", "WebAssembly", "::", "TypeToString", "(", "VT", ")", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::TypeToString" ]

[]

[ "<s>", "static", "rtx", "visium_function_arg", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "size", ";", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "size", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "GEN_INT", "(", "0", ")", ";", "if", "(", "TARGET_FPU", "&&", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", ")", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", "*", "2", ")", ")", ")", "{", "if", "(", "ca", "->", "frcount", "+", "size", "<=", "MAX_ARGS_IN_FP_REGISTERS", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP_ARG_FIRST", "+", "ca", "->", "frcount", ")", ";", "else", "return", "NULL_RTX", ";", "}", "if", "(", "ca", "->", "grcount", "+", "size", "<=", "MAX_ARGS_IN_GP_REGISTERS", ")", "return", "gen_rtx_REG", "(", "mode", ",", "ca", "->", "grcount", "+", "GP_ARG_FIRST", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Define", "how", "arguments", "are", "passed", ".", "A", "range", "of", "general", "registers", "and", "floating", "registers", "is", "available", "for", "passing", "arguments", ".", "When", "the", "class", "of", "registers", "which", "an", "argument", "would", "normally", "use", "is", "exhausted", ",", "that", "argument", ",", "is", "passed", "in", "the", "overflow", "region", "of", "the", "stack", ".", "No", "argument", "is", "split", "between", "registers", "and", "stack", ".", "Arguments", "of", "type", "float", "or", "_Complex", "float", "go", "in", "FP", "registers", "if", "FP", "hardware", "is", "available", ".", "If", "there", "is", "no", "FP", "hardware", ",", "arguments", "of", "type", "float", "go", "in", "general", "registers", ".", "All", "other", "arguments", "are", "passed", "in", "general", "registers", "." ]

[ "visium", "1", "0", "2" ]

[]

[ "<s>", "bool", "MipsOptimizePICCall", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "F", ".", "getSubtarget", "(", ")", ")", ".", "inMips16Mode", "(", ")", ")", "return", "false", ";", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "SmallVector", "<", "MBBInfo", ",", "8", ">", "WorkList", "(", "1", ",", "MBBInfo", "(", "MDT", "->", "getRootNode", "(", ")", ")", ")", ";", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", "{", "MBBInfo", "&", "MBBI", "=", "WorkList", ".", "back", "(", ")", ";", "if", "(", "MBBI", ".", "isVisited", "(", ")", ")", "{", "MBBI", ".", "postVisit", "(", ")", ";", "WorkList", ".", "pop_back", "(", ")", ";", "continue", ";", "}", "MBBI", ".", "preVisit", "(", "ScopedHT", ")", ";", "Changed", "|=", "visitNode", "(", "MBBI", ")", ";", "const", "MachineDomTreeNode", "*", "Node", "=", "MBBI", ".", "getNode", "(", ")", ";", "WorkList", ".", "append", "(", "Node", "->", "begin", "(", ")", ",", "Node", "->", "end", "(", ")", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "8", "1" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "isHsaAbiVersion3", "(", "&", "getSTI", "(", ")", ")", ")", "{", "if", "(", "IDVal", "==", "\".amdgcn_target\"", ")", "return", "ParseDirectiveAMDGCNTarget", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdhsa_kernel\"", ")", "return", "ParseDirectiveAMDHSAKernel", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "V3", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "else", "{", "if", "(", "IDVal", "==", "\".hsa_code_object_version\"", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_isa\"", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_kernel_code_t\"", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_hsa_kernel\"", ")", "return", "ParseDirectiveAMDGPUHsaKernel", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_amdgpu_isa\"", ")", "return", "ParseDirectiveISAVersion", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".amdgpu_lds\"", ")", "return", "ParseDirectiveAMDGPULDS", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectivePALMetadataBegin", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirective", ")", "return", "ParseDirectivePALMetadata", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "AMDGPU", "AMDGPU", "\".amdgcn_target\"", "\".amdhsa_kernel\"", "AMDGPU::HSAMD", "\".hsa_code_object_version\"", "\".hsa_code_object_isa\"", "\".amd_kernel_code_t\"", "\".amdgpu_hsa_kernel\"", "AMDGPU", "\".amd_amdgpu_isa\"", "AMDGPU::HSAMD", "\".amdgpu_lds\"", "AMDGPU" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForStrcmp", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src1", ",", "SDValue", "Src2", ",", "MachinePointerInfo", "Op1PtrInfo", ",", "MachinePointerInfo", "Op2PtrInfo", ")", "const", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Src1", ".", "getValueType", "(", ")", ",", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "SDValue", "Unused", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "STRCMP", ",", "DL", ",", "VTs", ",", "Chain", ",", "Src1", ",", "Src2", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "Chain", "=", "Unused", ".", "getValue", "(", "1", ")", ";", "SDValue", "Glue", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "return", "std", "::", "make_pair", "(", "addIPMSequence", "(", "DL", ",", "Glue", ",", "DAG", ")", ",", "Chain", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "strcmp", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "MVT::Other", "MVT::Glue", "SystemZISD::STRCMP", "0", "MVT::i32", "1", "2" ]

[]

[ "<s>", "unsigned", "BPFInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "BPF", "::", "JMP", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "BPF", "BPF", "\"code size not handled\"", "0", "BPF::JMP" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".gpword\"", ")", "{", "parseDirectiveGpWord", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".word\"", ")", "{", "parseDirectiveWord", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".option\"", ")", "return", "parseDirectiveOption", "(", ")", ";", "if", "(", "IDVal", "==", "\".abicalls\"", ")", "{", "getTargetStreamer", "(", ")", ".", "emitDirectiveAbiCalls", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "\"unexpected token in directive\"", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "Mips", "Mips", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".gpword\"", "\".word\"", "4", "\".option\"", "\".abicalls\"", "\"unexpected token in directive\"" ]

[]

[ "<s>", "bool", "TOYRegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "TOY", "TOY" ]

[]

[ "<s>", "static", "void", "nvptx_end_call_args", "(", "void", ")", "{", "cfun", "->", "machine", "->", "doing_call", "=", "false", ";", "free_EXPR_LIST_list", "(", "&", "cfun", "->", "machine", "->", "call_args", ")", ";", "}", "</s>" ]

[ "Implement", "the", "corresponding", "END_CALL_ARGS", "hook", ".", "Clear", "and", "free", "the", "information", "we", "recorded", "." ]

[ "nvptx" ]

[]

[ "<s>", "void", "or1k_expand_epilogue", "(", "void", ")", "{", "HOST_WIDE_INT", "reg_offset", ",", "sp_offset", ";", "rtx", "insn", ",", "cfa_restores", "=", "NULL", ";", "sp_offset", "=", "cfun", "->", "machine", "->", "total_size", ";", "if", "(", "sp_offset", "==", "0", ")", "return", ";", "reg_offset", "=", "cfun", "->", "machine", "->", "local_vars_size", "+", "cfun", "->", "machine", "->", "args_size", ";", "if", "(", "sp_offset", ">=", "32768", "||", "cfun", "->", "calls_alloca", ")", "{", "if", "(", "frame_pointer_needed", ")", "{", "sp_offset", "-=", "reg_offset", ";", "reg_offset", "=", "0", ";", "insn", "=", "emit_insn", "(", "gen_frame_addsi3", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ",", "GEN_INT", "(", "-", "sp_offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "sp_offset", ")", ")", ";", "}", "else", "if", "(", "sp_offset", ">=", "3", "*", "32768", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "PE_TMP_REGNUM", ")", ";", "emit_move_insn", "(", "tmp", ",", "GEN_INT", "(", "reg_offset", ")", ")", ";", "insn", "=", "emit_insn", "(", "gen_frame_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "sp_offset", "-=", "reg_offset", ";", "reg_offset", "=", "0", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "sp_offset", ")", ")", ";", "}", "else", "{", "do", "{", "HOST_WIDE_INT", "this_offset", "=", "MIN", "(", "reg_offset", ",", "32764", ")", ";", "reg_offset", "-=", "this_offset", ";", "sp_offset", "-=", "this_offset", ";", "insn", "=", "emit_insn", "(", "gen_frame_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "this_offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "sp_offset", ")", ")", ";", "}", "while", "(", "sp_offset", ">=", "32768", ")", ";", "}", "}", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "&&", "regno", "!=", "LR_REGNUM", "&&", "callee_saved_regno_p", "(", "regno", ")", ")", "{", "cfa_restores", "=", "or1k_restore_reg", "(", "regno", ",", "reg_offset", ",", "cfa_restores", ")", ";", "reg_offset", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "callee_saved_regno_p", "(", "HARD_FRAME_POINTER_REGNUM", ")", ")", "{", "cfa_restores", "=", "or1k_restore_reg", "(", "HARD_FRAME_POINTER_REGNUM", ",", "reg_offset", ",", "cfa_restores", ")", ";", "reg_offset", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "callee_saved_regno_p", "(", "LR_REGNUM", ")", ")", "{", "cfa_restores", "=", "or1k_restore_reg", "(", "LR_REGNUM", ",", "reg_offset", ",", "cfa_restores", ")", ";", "reg_offset", "+=", "UNITS_PER_WORD", ";", "}", "gcc_assert", "(", "reg_offset", "==", "sp_offset", ")", ";", "insn", "=", "emit_insn", "(", "gen_frame_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "sp_offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "cfa_restores", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "stack_pointer_rtx", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "``", "epilogue", "''", "pattern", "." ]

[ "or1k", "0", "32768", "0", "1", "3", "32768", "0", "1", "32764", "1", "32768", "0", "1" ]

[]

[ "<s>", "MachineInstr", "*", "SystemZInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "MachineInstr", "&", "LoadMI", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "reg_class_t", "ix86_preferred_output_reload_class", "(", "rtx", "x", ",", "reg_class_t", "regclass", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "SSE_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_SSE_MATH", ")", "return", "MAYBE_SSE_CLASS_P", "(", "regclass", ")", "?", "ALL_SSE_REGS", ":", "NO_REGS", ";", "if", "(", "IS_STACK_MODE", "(", "mode", ")", ")", "{", "if", "(", "regclass", "==", "FP_TOP_SSE_REGS", ")", "return", "FP_TOP_REG", ";", "else", "if", "(", "regclass", "==", "FP_SECOND_SSE_REGS", ")", "return", "FP_SECOND_REG", ";", "else", "return", "FLOAT_CLASS_P", "(", "regclass", ")", "?", "regclass", ":", "NO_REGS", ";", "}", "return", "regclass", ";", "}", "</s>" ]

[ "Discourage", "putting", "floating-point", "values", "in", "SSE", "registers", "unless", "SSE", "math", "is", "being", "used", ",", "and", "likewise", "for", "the", "387", "registers", "." ]

[ "i386" ]

[]

[ "<s>", "void", "load_got_register", "(", "void", ")", "{", "if", "(", "!", "got_register_rtx", ")", "got_register_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "GLOBAL_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "TARGET_VXWORKS_RTP", ")", "emit_insn", "(", "gen_vxworks_load_got", "(", ")", ")", ";", "else", "{", "if", "(", "!", "got_helper_rtx", ")", "{", "char", "name", "[", "32", "]", ";", "get_pc_thunk_name", "(", "name", ",", "GLOBAL_OFFSET_TABLE_REGNUM", ")", ";", "got_helper_rtx", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "name", ")", ")", ";", "}", "emit_insn", "(", "gen_load_pcrel_sym", "(", "got_register_rtx", ",", "sparc_got", "(", ")", ",", "got_helper_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "load", "the", "GOT", "register", "." ]

[ "sparc", "32" ]

[]

[ "<s>", "static", "void", "rs6000_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_conditional_register_usage called\\n\"", ")", ";", "fixed_regs", "[", "64", "]", "=", "1", ";", "if", "(", "TARGET_64BIT", ")", "fixed_regs", "[", "13", "]", "=", "call_used_regs", "[", "13", "]", "=", "call_really_used_regs", "[", "13", "]", "=", "1", ";", "if", "(", "TARGET_SOFT_FLOAT", "||", "!", "TARGET_FPRS", ")", "for", "(", "i", "=", "32", ";", "i", "<", "64", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "call_really_used_regs", "[", "2", "]", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", "&&", "flag_pic", "==", "2", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", "&&", "flag_pic", "==", "1", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_SPE", ")", "{", "global_regs", "[", "SPEFSCR_REGNO", "]", "=", "1", ";", "fixed_regs", "[", "14", "]", "=", "call_used_regs", "[", "14", "]", "=", "call_really_used_regs", "[", "14", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_ALTIVEC", "&&", "!", "TARGET_VSX", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "call_really_used_regs", "[", "VRSAVE_REGNO", "]", "=", "1", ";", "}", "if", "(", "TARGET_ALTIVEC", "||", "TARGET_VSX", ")", "global_regs", "[", "VSCR_REGNO", "]", "=", "1", ";", "if", "(", "TARGET_ALTIVEC_ABI", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "++", "i", ")", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "TARGET_XCOFF", ")", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "32", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Change", "register", "usage", "conditional", "on", "target", "flags", "." ]

[ "rs6000", "\"rs6000_conditional_register_usage called\\n\"", "64", "1", "13", "13", "13", "1", "32", "64", "1", "2", "0", "2", "1", "1", "1", "1", "1", "1", "14", "14", "14", "1", "1", "1", "1", "20", "1", "20", "32", "1" ]

[]

[ "<s>", "bool", "isLabel", "(", ")", "const", "{", "if", "(", "!", "isImm", "(", ")", ")", "return", "false", ";", "if", "(", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "Imm", ".", "Val", ")", ")", "{", "return", "true", ";", "}", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Imm", ".", "Val", ")", ")", "{", "int64_t", "Val", "=", "CE", "->", "getValue", "(", ")", ";", "int64_t", "Min", "=", "-", "(", "scale", "*", "(", "1LL", "<<", "(", "field_width", "-", "1", ")", ")", ")", ";", "int64_t", "Max", "=", "scale", "*", "(", "(", "1LL", "<<", "(", "field_width", "-", "1", ")", ")", "-", "1", ")", ";", "return", "(", "Val", "%", "scale", ")", "==", "0", "&&", "Val", ">=", "Min", "&&", "Val", "<=", "Max", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "MachineInstr", "represents", "a", "label", "." ]

[ "AArch64", "1LL", "1", "1LL", "1", "1", "0" ]

[]

[ "<s>", "const", "char", "*", "VETargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "VEISD", "::", "NAME", ":", "\\", "return", "\"VEISD::\"", "#", "NAME", ";", "switch", "(", "(", "VEISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "VEISD", "::", "FIRST_NUMBER", ":", "break", ";", "TARGET_NODE_CASE", "(", "CALL", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_LONGJMP", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_SETJMP", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_SETUP_DISPATCH", ")", "TARGET_NODE_CASE", "(", "GETFUNPLT", ")", "TARGET_NODE_CASE", "(", "GETSTACKTOP", ")", "TARGET_NODE_CASE", "(", "GETTLSADDR", ")", "TARGET_NODE_CASE", "(", "GLOBAL_BASE_REG", ")", "TARGET_NODE_CASE", "(", "Hi", ")", "TARGET_NODE_CASE", "(", "Lo", ")", "TARGET_NODE_CASE", "(", "MEMBARRIER", ")", "TARGET_NODE_CASE", "(", "RET_FLAG", ")", "TARGET_NODE_CASE", "(", "TS1AM", ")", "TARGET_NODE_CASE", "(", "VEC_BROADCAST", ")", "TARGET_NODE_CASE", "(", "REPL_I32", ")", "TARGET_NODE_CASE", "(", "REPL_F32", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "VE", "VE", "VEISD::NAME", "\"VEISD::\"", "VEISD::NodeType", "VEISD::FIRST_NUMBER", "VE" ]

[]

[ "<s>", "static", "poly_int64", "vax_return_pops_args", "(", "tree", "fundecl", "ATTRIBUTE_UNUSED", ",", "tree", "funtype", "ATTRIBUTE_UNUSED", ",", "poly_int64", "size", ")", "{", "return", "size", ">", "255", "*", "4", "?", "0", ":", "(", "HOST_WIDE_INT", ")", "size", ";", "}", "</s>" ]

[ "Value", "is", "the", "number", "of", "bytes", "of", "arguments", "automatically", "popped", "when", "returning", "from", "a", "subroutine", "call", ".", "FUNDECL", "is", "the", "declaration", "node", "of", "the", "function", "(", "as", "a", "tree", ")", ",", "FUNTYPE", "is", "the", "data", "type", "of", "the", "function", "(", "as", "a", "tree", ")", ",", "or", "for", "a", "library", "call", "it", "is", "an", "identifier", "node", "for", "the", "subroutine", "name", ".", "SIZE", "is", "the", "number", "of", "bytes", "of", "arguments", "passed", "on", "the", "stack", ".", "On", "the", "VAX", ",", "the", "RET", "insn", "pops", "a", "maximum", "of", "255", "args", "for", "any", "function", "." ]

[ "vax", "255", "4", "0" ]

[]

[ "<s>", "static", "void", "gr5_avoid_hazard", "(", "rtx_insn", "*", "insn", ",", "unsigned", "int", "*", "last_reg", ",", "bool", "*", "last_insn_call", ")", "{", "unsigned", "int", "dest_reg", "=", "0", ";", "rtx", "set", ";", "switch", "(", "GET_CODE", "(", "insn", ")", ")", "{", "case", "CALL_INSN", ":", "*", "last_reg", "=", "0", ";", "*", "last_insn_call", "=", "true", ";", "return", ";", "case", "JUMP_INSN", ":", "if", "(", "!", "empty_asm_p", "(", "insn", ")", ")", "{", "*", "last_reg", "=", "0", ";", "*", "last_insn_call", "=", "false", ";", "}", "return", ";", "case", "INSN", ":", "if", "(", "empty_asm_p", "(", "insn", ")", ")", "return", ";", "break", ";", "default", ":", "return", ";", "}", "set", "=", "single_set_and_flags", "(", "insn", ")", ";", "if", "(", "set", "!=", "NULL_RTX", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "const", "bool", "double_p", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", ">", "UNITS_PER_WORD", ";", "rtx", "memrtx", "=", "NULL", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "MEM", ")", "{", "memrtx", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "STRICT_LOW_PART", ")", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "if", "(", "REG_P", "(", "dest", ")", ")", "dest_reg", "=", "REGNO", "(", "dest", ")", ";", "if", "(", "double_p", ")", "{", "unsigned", "int", "base_reg", ";", "if", "(", "GET_CODE", "(", "memrtx", ")", "==", "PLUS", ")", "base_reg", "=", "REGNO", "(", "XEXP", "(", "memrtx", ",", "0", ")", ")", ";", "else", "base_reg", "=", "REGNO", "(", "memrtx", ")", ";", "if", "(", "dest_reg", "!=", "base_reg", ")", "dest_reg", "++", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "memrtx", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "dest", ")", ")", "!=", "MODE_CC", ")", "{", "if", "(", "GET_CODE", "(", "dest", ")", "==", "STRICT_LOW_PART", "||", "GET_CODE", "(", "dest", ")", "==", "ZERO_EXTRACT", ")", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "dest_reg", "=", "REGNO", "(", "dest", ")", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "REG", ")", "{", "unsigned", "int", "srcreg", "=", "REGNO", "(", "SET_SRC", "(", "set", ")", ")", ";", "if", "(", "srcreg", "==", "dest_reg", ")", "return", ";", "if", "(", "double_p", "&&", "dest_reg", "!=", "srcreg", "+", "1", ")", "dest_reg", "++", ";", "}", "}", "if", "(", "*", "last_insn_call", ")", "dest_reg", "=", "0", ";", "if", "(", "*", "last_reg", "!=", "0", "&&", "memrtx", "!=", "NULL_RTX", ")", "{", "unsigned", "int", "reg", "=", "0", ";", "if", "(", "GET_CODE", "(", "memrtx", ")", "==", "PLUS", ")", "reg", "=", "REGNO", "(", "XEXP", "(", "memrtx", ",", "0", ")", ")", ";", "else", "if", "(", "TARGET_MCM", "||", "(", "double_p", "&&", "REGNO", "(", "memrtx", ")", "==", "dest_reg", ")", ")", "reg", "=", "REGNO", "(", "memrtx", ")", ";", "if", "(", "reg", "==", "*", "last_reg", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"inserting nop before insn %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "emit_insn_after", "(", "gen_hazard_nop", "(", ")", ",", "prev_active_insn", "(", "insn", ")", ")", ";", "emit_insn_after", "(", "gen_blockage", "(", ")", ",", "insn", ")", ";", "}", "}", "*", "last_reg", "=", "dest_reg", ";", "}", "*", "last_insn_call", "=", "false", ";", "}", "</s>" ]

[ "Insert", "a", "NOP", "immediately", "before", "INSN", "wherever", "there", "is", "a", "pipeline", "hazard", ".", "LAST_REG", "records", "the", "register", "set", "in", "the", "last", "insn", "and", "LAST_INSN_CALL", "records", "whether", "the", "last", "insn", "was", "a", "call", "insn", "." ]

[ "visium", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "\"inserting nop before insn %d\\n\"" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_xcoff_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "align", ";", "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "(", "flags", "&", "SECTION_CODE", ")", "!=", "0", "||", "!", "decl", "||", "!", "DECL_P", "(", "decl", ")", ")", "align", "=", "MIN_UNITS_PER_WORD", ";", "else", "align", "=", "MAX", "(", "(", "DECL_ALIGN", "(", "decl", ")", "/", "BITS_PER_UNIT", ")", ",", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ">", "MIN_UNITS_PER_WORD", "?", "UNITS_PER_FP_WORD", ":", "MIN_UNITS_PER_WORD", ")", ";", "return", "flags", "|", "(", "exact_log2", "(", "align", ")", "&", "SECTION_ENTSIZE", ")", ";", "}", "</s>" ]

[ "Section", "attributes", ".", "AIX", "is", "always", "PIC", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "void", "X86AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "X86MCInstLower", "MCInstLowering", "(", "Mang", ",", "*", "MF", ",", "*", "this", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "if", "(", "isVerbose", "(", ")", "&&", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "{", "std", "::", "string", "TmpStr", ";", "raw_string_ostream", "OS", "(", "TmpStr", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "OS", ".", "str", "(", ")", ")", ")", ";", "}", "return", ";", "case", "X86", "::", "Int_MemBarrier", ":", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "\"\\t#MEMBARRIER\"", ")", ")", ";", "return", ";", "case", "X86", "::", "TAILJMPr", ":", "case", "X86", "::", "TAILJMPd", ":", "case", "X86", "::", "TAILJMPd64", ":", "OutStreamer", ".", "AddComment", "(", "\"TAILCALL\"", ")", ";", "break", ";", "case", "X86", "::", "MOVPC32r", ":", "{", "MCInst", "TmpInst", ";", "MCSymbol", "*", "PICBase", "=", "MCInstLowering", ".", "GetPICBaseSymbol", "(", ")", ";", "TmpInst", ".", "setOpcode", "(", "X86", "::", "CALLpcrel32", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "PICBase", ",", "OutContext", ")", ")", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "PICBase", ")", ";", "TmpInst", ".", "setOpcode", "(", "X86", "::", "POP32r", ")", ";", "TmpInst", ".", "getOperand", "(", "0", ")", "=", "MCOperand", "::", "CreateReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "return", ";", "}", "case", "X86", "::", "ADD32ri", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getTargetFlags", "(", ")", "!=", "X86II", "::", "MO_GOT_ABSOLUTE_ADDRESS", ")", "break", ";", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "CreateTempSymbol", "(", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "DotSym", ")", ";", "MCSymbol", "*", "OpSym", "=", "MCInstLowering", ".", "GetSymbolFromOperand", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "Create", "(", "DotSym", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PICBase", "=", "MCSymbolRefExpr", "::", "Create", "(", "MCInstLowering", ".", "GetPICBaseSymbol", "(", ")", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateSub", "(", "DotExpr", ",", "PICBase", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateAdd", "(", "MCSymbolRefExpr", "::", "Create", "(", "OpSym", ",", "OutContext", ")", ",", "DotExpr", ",", "OutContext", ")", ";", "MCInst", "TmpInst", ";", "TmpInst", ".", "setOpcode", "(", "X86", "::", "ADD32ri", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "DotExpr", ")", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "return", ";", "}", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "X86", "X86", "X86", "X86::Int_MemBarrier", "\"\\t#MEMBARRIER\"", "X86::TAILJMPr", "X86::TAILJMPd", "X86::TAILJMPd64", "\"TAILCALL\"", "X86::MOVPC32r", "X86::CALLpcrel32", "X86::POP32r", "0", "0", "X86::ADD32ri", "2", "X86II::MO_GOT_ABSOLUTE_ADDRESS", "2", "X86::ADD32ri", "0", "1" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeFrameSize", "=", "0", ";", "unsigned", "LowReg", "=", "0", ",", "HighReg", "=", "0", ",", "StartOffset", "=", "-", "1U", ",", "EndOffset", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "SystemZ", "::", "FP64RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "Offset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "CalleeFrameSize", "+=", "8", ";", "if", "(", "StartOffset", ">", "Offset", ")", "{", "LowReg", "=", "Reg", ";", "StartOffset", "=", "Offset", ";", "}", "if", "(", "EndOffset", "<", "Offset", ")", "{", "HighReg", "=", "Reg", ";", "EndOffset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "}", "}", "}", "MFI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "MFI", "->", "setLowReg", "(", "LowReg", ")", ";", "MFI", "->", "setHighReg", "(", "HighReg", ")", ";", "if", "(", "StartOffset", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "(", "LowReg", "==", "HighReg", "?", "SystemZ", "::", "MOV64mr", ":", "SystemZ", "::", "MOV64mrm", ")", ")", ")", ";", "MIB", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ".", "addImm", "(", "StartOffset", ")", ";", "if", "(", "LowReg", "==", "HighReg", ")", "MIB", ".", "addReg", "(", "0", ")", ";", "MIB", ".", "addReg", "(", "LowReg", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "LowReg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "HighReg", ",", "RegState", "::", "Kill", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "!=", "LowReg", "&&", "Reg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "}", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64RegClass", ",", "&", "RI", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "0", "0", "1U", "0", "0", "SystemZ::FP64RegClass", "8", "SystemZ::MOV64mr", "SystemZ::MOV64mrm", "SystemZ::R15D", "0", "0", "0", "SystemZ::FP64RegClass", "SystemZ::FP64RegClass" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "AMDGPUISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "IF", ")", "NODE_NAME_CASE", "(", "ELSE", ")", "NODE_NAME_CASE", "(", "LOOP", ")", "NODE_NAME_CASE", "(", "CALL", ")", "NODE_NAME_CASE", "(", "TC_RETURN", ")", "NODE_NAME_CASE", "(", "TRAP", ")", "NODE_NAME_CASE", "(", "RET_FLAG", ")", "NODE_NAME_CASE", "(", "RETURN_TO_EPILOG", ")", "NODE_NAME_CASE", "(", "ENDPGM", ")", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "SETCC", ")", "NODE_NAME_CASE", "(", "SETREG", ")", "NODE_NAME_CASE", "(", "FMA_W_CHAIN", ")", "NODE_NAME_CASE", "(", "FMUL_W_CHAIN", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "FMED3", ")", "NODE_NAME_CASE", "(", "SMED3", ")", "NODE_NAME_CASE", "(", "UMED3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "FMAD_FTZ", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RCP_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "FMUL_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMP", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "FFBH_U32", ")", "NODE_NAME_CASE", "(", "FFBH_I32", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MULHI_U24", ")", "NODE_NAME_CASE", "(", "MULHI_I24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_U24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "EXPORT_DONE", ")", "NODE_NAME_CASE", "(", "R600_EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "CVT_PKRTZ_F16_F32", ")", "NODE_NAME_CASE", "(", "FP_TO_FP16", ")", "NODE_NAME_CASE", "(", "FP16_ZEXT", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "PC_ADD_REL_OFFSET", ")", "NODE_NAME_CASE", "(", "KILL", ")", "NODE_NAME_CASE", "(", "DUMMY_CHAIN", ")", "case", "AMDGPUISD", "::", "FIRST_MEM_OPCODE_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "INIT_EXEC", ")", "NODE_NAME_CASE", "(", "INIT_EXEC_FROM_INPUT", ")", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "SENDMSGHALT", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT_X3", ")", "NODE_NAME_CASE", "(", "TBUFFER_LOAD_FORMAT", ")", "NODE_NAME_CASE", "(", "ATOMIC_CMP_SWAP", ")", "NODE_NAME_CASE", "(", "ATOMIC_INC", ")", "NODE_NAME_CASE", "(", "ATOMIC_DEC", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_FORMAT", ")", "case", "AMDGPUISD", "::", "LAST_AMDGPU_ISD_NUMBER", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "AMDGPU", "AMDGPU", "AMDGPUISD::NodeType", "AMDGPUISD::FIRST_NUMBER", "SI", "R600", "AMDGPUISD::FIRST_MEM_OPCODE_NUMBER", "AMDGPUISD::LAST_AMDGPU_ISD_NUMBER" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createAMDGPUPrintfRuntimeBinding", "(", ")", ")", ";", "addPass", "(", "createAMDGPUCtorDtorLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPropagateAttributesEarlyPass", "(", "&", "TM", ")", ")", ";", "addPass", "(", "createAMDGPULowerIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "addPass", "(", "createR600OpenCLImageTypeLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUOpenCLEnqueuedBlockLoweringPass", "(", ")", ")", ";", "if", "(", "EnableLowerModuleLDS", ")", "{", "if", "(", "EnableLDSReplaceWithPointer", ")", "addPass", "(", "createAMDGPUReplaceLDSUseWithPointerPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPULowerModuleLDSPass", "(", ")", ")", ";", "}", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInferAddressSpacesPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createAMDGPUPromoteAlloca", "(", ")", ")", ";", "if", "(", "EnableSROA", ")", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "if", "(", "isPassEnabled", "(", "EnableScalarIRPasses", ")", ")", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "if", "(", "EnableAMDGPUAliasAnalysis", ")", "{", "addPass", "(", "createAMDGPUAAWrapperPass", "(", ")", ")", ";", "addPass", "(", "createExternalAAWrapperPass", "(", "[", "]", "(", "Pass", "&", "P", ",", "Function", "&", ",", "AAResults", "&", "AAR", ")", "{", "if", "(", "auto", "*", "WrapperPass", "=", "P", ".", "getAnalysisIfAvailable", "<", "AMDGPUAAWrapperPass", ">", "(", ")", ")", "AAR", ".", "addAAResult", "(", "WrapperPass", "->", "getResult", "(", ")", ")", ";", "}", ")", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUCodeGenPreparePass", "(", ")", ")", ";", "}", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "isPassEnabled", "(", "EnableScalarIRPasses", ")", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "XCore" ]

[]

[ "<s>", "void", "X86TTI", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "UnrollingPreferences", "&", "UP", ")", "const", "{", "if", "(", "!", "UsePartialUnrolling", ")", "return", ";", "unsigned", "MaxOps", ";", "if", "(", "PartialUnrollingThreshold", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "{", "MaxOps", "=", "PartialUnrollingThreshold", ";", "}", "else", "if", "(", "ST", "->", "isAtom", "(", ")", ")", "{", "MaxOps", "=", "10", ";", "}", "else", "if", "(", "ST", "->", "hasFSGSBase", "(", ")", "&&", "ST", "->", "hasXOP", "(", ")", ")", "{", "MaxOps", "=", "40", ";", "}", "else", "if", "(", "ST", "->", "hasFMA4", "(", ")", ")", "{", "return", ";", "}", "else", "if", "(", "ST", "->", "hasAVX", "(", ")", "||", "ST", "->", "hasSSE42", "(", ")", ")", "{", "MaxOps", "=", "28", ";", "}", "else", "if", "(", "ST", "->", "hasSSSE3", "(", ")", ")", "{", "MaxOps", "=", "18", ";", "}", "else", "{", "return", ";", "}", "for", "(", "Loop", "::", "block_iterator", "I", "=", "L", "->", "block_begin", "(", ")", ",", "E", "=", "L", "->", "block_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BasicBlock", "*", "BB", "=", "*", "I", ";", "for", "(", "BasicBlock", "::", "iterator", "J", "=", "BB", "->", "begin", "(", ")", ",", "JE", "=", "BB", "->", "end", "(", ")", ";", "J", "!=", "JE", ";", "++", "J", ")", "if", "(", "isa", "<", "CallInst", ">", "(", "J", ")", "||", "isa", "<", "InvokeInst", ">", "(", "J", ")", ")", "{", "ImmutableCallSite", "CS", "(", "J", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "}", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "UP", ".", "PartialOptSizeThreshold", "=", "MaxOps", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "X86", "X86", "0", "10", "40", "28", "18" ]

[]

[ "<s>", "HOST_WIDE_INT", "riscv_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "src", ",", "dest", ";", "riscv_compute_frame_info", "(", ")", ";", "if", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "dest", "=", "cfun", "->", "machine", "->", "frame", ".", "hard_frame_pointer_offset", ";", "else", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "dest", "=", "0", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "src", "=", "cfun", "->", "machine", "->", "frame", ".", "frame_pointer_offset", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", ")", "src", "=", "cfun", "->", "machine", "->", "frame", ".", "arg_pointer_offset", ";", "else", "gcc_unreachable", "(", ")", ";", "return", "src", "-", "dest", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", ".", "FROM", "is", "either", "the", "frame", "pointer", "or", "argument", "pointer", ".", "TO", "is", "either", "the", "stack", "pointer", "or", "hard", "frame", "pointer", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "timode_scalar_chain", "::", "fix_debug_reg_uses", "(", "rtx", "reg", ")", "{", "if", "(", "!", "flag_var_tracking", ")", "return", ";", "df_ref", "ref", ",", "next", ";", "for", "(", "ref", "=", "DF_REG_USE_CHAIN", "(", "REGNO", "(", "reg", ")", ")", ";", "ref", ";", "ref", "=", "next", ")", "{", "rtx_insn", "*", "insn", "=", "DF_REF_INSN", "(", "ref", ")", ";", "next", "=", "DF_REF_NEXT_REG", "(", "ref", ")", ";", "while", "(", "next", "&&", "DF_REF_INSN", "(", "next", ")", "==", "insn", ")", "next", "=", "DF_REF_NEXT_REG", "(", "next", ")", ";", "if", "(", "DEBUG_INSN_P", "(", "insn", ")", ")", "{", "bool", "changed", "=", "false", ";", "for", "(", ";", "ref", "!=", "next", ";", "ref", "=", "DF_REF_NEXT_REG", "(", "ref", ")", ")", "{", "rtx", "*", "loc", "=", "DF_REF_LOC", "(", "ref", ")", ";", "if", "(", "REG_P", "(", "*", "loc", ")", "&&", "GET_MODE", "(", "*", "loc", ")", "==", "V1TImode", ")", "{", "*", "loc", "=", "gen_rtx_SUBREG", "(", "TImode", ",", "*", "loc", ",", "0", ")", ";", "changed", "=", "true", ";", "}", "}", "if", "(", "changed", ")", "df_insn_rescan", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Fix", "uses", "of", "converted", "REG", "in", "debug", "insns", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "NVPTXTargetMachine", "::", "registerPassBuilderCallbacks", "(", "PassBuilder", "&", "PB", ")", "{", "PB", ".", "registerPipelineParsingCallback", "(", "[", "]", "(", "StringRef", "PassName", ",", "FunctionPassManager", "&", "PM", ",", "ArrayRef", "<", "PassBuilder", "::", "PipelineElement", ">", ")", "{", "if", "(", "PassName", "==", "\"nvvm-reflect\"", ")", "{", "PM", ".", "addPass", "(", "NVVMReflectPass", "(", ")", ")", ";", "return", "true", ";", "}", "if", "(", "PassName", "==", "\"nvvm-intr-range\"", ")", "{", "PM", ".", "addPass", "(", "NVVMIntrRangePass", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", ")", ";", "PB", ".", "registerPipelineStartEPCallback", "(", "[", "this", "]", "(", "ModulePassManager", "&", "PM", ",", "PassBuilder", "::", "OptimizationLevel", "Level", ")", "{", "FunctionPassManager", "FPM", ";", "FPM", ".", "addPass", "(", "NVVMReflectPass", "(", "Subtarget", ".", "getSmVersion", "(", ")", ")", ")", ";", "PM", ".", "addPass", "(", "createModuleToFunctionPassAdaptor", "(", "std", "::", "move", "(", "FPM", ")", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Invoke", "the", "PassBuilder", "callback", "registration", "." ]

[ "NVPTX", "NVPTX", "\"nvvm-reflect\"", "\"nvvm-intr-range\"" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", ")", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "PowerPC", "PPC", "PPC", "MVT::i32", "PPC::GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "&", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "MipsDefault", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TSInfo", "(", "*", "TM", ".", "getDataLayout", "(", ")", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "TM", ",", "*", "this", ")", ")", "{", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "if", "(", "MipsArchVersion", "==", "MipsDefault", ")", "MipsArchVersion", "=", "Mips32", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "\"-mattr=+nooddspreg requires the O32 ABI.\"", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "\"FPXX is not permitted for the N32/N64 ABI's.\"", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "\"MIPS64r6\"", ":", "\"MIPS32r6\"", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "\" is not compatible with the DSP ASE\"", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "report_fatal_error", "(", "\"position-independent code requires '-mabicalls'\"", ")", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "<<", "\"\\n\"", ";", "UseSmallSection", "=", "false", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"-mattr=+nooddspreg requires the O32 ABI.\"", "\"FPXX is not permitted for the N32/N64 ABI's.\"", "Mips", "Mips", "\"MIPS64r6\"", "\"MIPS32r6\"", "\" is not compatible with the DSP ASE\"", "\"position-independent code requires '-mabicalls'\"", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "getPrefFunctionAlignment", "(", ")", "const", "{", "return", "PrefFunctionAlignment", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "function", "alignment", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "int", "arm_get_strip_length", "(", "char", "c", ")", "{", "switch", "(", "c", ")", "{", "ARM_NAME_ENCODING_LENGTHS", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "the", "length", "of", "a", "function", "name", "prefix", "that", "starts", "with", "the", "character", "'", "c", "'", "." ]

[ "arm", "0" ]

[]

[ "<s>", "bool", "toc_relative_expr_p", "(", "const_rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "!", "TARGET_TOC", ")", "return", "false", ";", "if", "(", "TARGET_CMODEL", "!=", "CMODEL_SMALL", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", "&&", "INT_REG_OK_FOR_BASE_P", "(", "XEXP", "(", "op", ",", "0", ")", ",", "strict", ")", ")", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "else", "if", "(", "strict", ")", "return", "false", ";", "}", "tocrel_base", "=", "op", ";", "tocrel_offset", "=", "const0_rtx", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", "&&", "add_cint_operand", "(", "XEXP", "(", "op", ",", "1", ")", ",", "GET_MODE", "(", "op", ")", ")", ")", "{", "tocrel_base", "=", "XEXP", "(", "op", ",", "0", ")", ";", "tocrel_offset", "=", "XEXP", "(", "op", ",", "1", ")", ";", "}", "return", "(", "GET_CODE", "(", "tocrel_base", ")", "==", "UNSPEC", "&&", "XINT", "(", "tocrel_base", ",", "1", ")", "==", "UNSPEC_TOCREL", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "toc", "pointer", "relative", "address", "(", "the", "output", "of", "create_TOC_reference", ")", ".", "If", "STRICT", ",", "do", "not", "match", "high", "part", "or", "non-split", "-mcmodel=large/medium", "toc", "pointer", "relative", "addresses", "." ]

[ "rs6000", "0", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", "&&", "EnableLowerKernelArguments", ")", "addPass", "(", "createAMDGPULowerKernelArgumentsPass", "(", ")", ")", ";", "addPass", "(", "&", "AMDGPUPerfHintAnalysisID", ")", ";", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "if", "(", "EnableLoadStoreVectorizer", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

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

[]

[ "<s>", "MCSymbol", "*", "mprocMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "mproc", "mproc", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameIndicesReplaced", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "ST", ".", "hasMAIInsts", "(", ")", "&&", "!", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "{", "Register", "VGPRForAGPRCopy", "=", "FuncInfo", "->", "getVGPRForAGPRCopy", "(", ")", ";", "Register", "UnusedLowVGPR", "=", "TRI", "->", "findUnusedRegister", "(", "MRI", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "MF", ")", ";", "if", "(", "UnusedLowVGPR", "&&", "(", "TRI", "->", "getHWRegIndex", "(", "UnusedLowVGPR", ")", "<", "TRI", "->", "getHWRegIndex", "(", "VGPRForAGPRCopy", ")", ")", ")", "{", "FuncInfo", "->", "setVGPRForAGPRCopy", "(", "UnusedLowVGPR", ")", ";", "MRI", ".", "freezeReservedRegs", "(", "MF", ")", ";", "}", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameIndicesReplaced", "-", "This", "method", "is", "called", "immediately", "before", "MO_FrameIndex", "operands", "are", "eliminated", ",", "but", "after", "the", "frame", "is", "finalized", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "uint64_t", "R600MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixup", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "HAS_NATIVE_OPERANDS", "(", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "getHWReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "R600" ]

[]

[ "<s>", "void", "AArch64TargetStreamer", "::", "emitInst", "(", "uint32_t", "Inst", ")", "{", "char", "Buffer", "[", "4", "]", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "4", ";", "++", "I", ")", "{", "Buffer", "[", "I", "]", "=", "uint8_t", "(", "Inst", ")", ";", "Inst", ">>=", "8", ";", "}", "getStreamer", "(", ")", ".", "emitBytes", "(", "StringRef", "(", "Buffer", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "AArch64", "AArch64", "4", "0", "4", "8", "4" ]

[]

[ "<s>", "void", "MipsTargetELFStreamer", "::", "finish", "(", ")", "{", "MCAssembler", "&", "MCA", "=", "getStreamer", "(", ")", ".", "getAssembler", "(", ")", ";", "const", "MCObjectFileInfo", "&", "OFI", "=", "*", "MCA", ".", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", ";", "MCSection", "&", "TextSection", "=", "*", "OFI", ".", "getTextSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "TextSection", ")", ";", "MCSection", "&", "DataSection", "=", "*", "OFI", ".", "getDataSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "DataSection", ")", ";", "MCSection", "&", "BSSSection", "=", "*", "OFI", ".", "getBSSSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "BSSSection", ")", ";", "TextSection", ".", "setAlignment", "(", "Align", "(", "std", "::", "max", "(", "16u", ",", "TextSection", ".", "getAlignment", "(", ")", ")", ")", ")", ";", "DataSection", ".", "setAlignment", "(", "Align", "(", "std", "::", "max", "(", "16u", ",", "DataSection", ".", "getAlignment", "(", ")", ")", ")", ")", ";", "BSSSection", ".", "setAlignment", "(", "Align", "(", "std", "::", "max", "(", "16u", ",", "BSSSection", ".", "getAlignment", "(", ")", ")", ")", ")", ";", "if", "(", "RoundSectionSizes", ")", "{", "MCStreamer", "&", "OS", "=", "getStreamer", "(", ")", ";", "for", "(", "MCSection", "&", "S", ":", "MCA", ")", "{", "MCSectionELF", "&", "Section", "=", "static_cast", "<", "MCSectionELF", "&", ">", "(", "S", ")", ";", "unsigned", "Alignment", "=", "Section", ".", "getAlignment", "(", ")", ";", "if", "(", "Alignment", ")", "{", "OS", ".", "SwitchSection", "(", "&", "Section", ")", ";", "if", "(", "Section", ".", "UseCodeAlign", "(", ")", ")", "OS", ".", "emitCodeAlignment", "(", "Alignment", ",", "Alignment", ")", ";", "else", "OS", ".", "emitValueToAlignment", "(", "Alignment", ",", "0", ",", "1", ",", "Alignment", ")", ";", "}", "}", "}", "const", "FeatureBitset", "&", "Features", "=", "STI", ".", "getFeatureBits", "(", ")", ";", "unsigned", "EFlags", "=", "MCA", ".", "getELFHeaderEFlags", "(", ")", ";", "if", "(", "getABI", "(", ")", ".", "IsO32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_ABI_O32", ";", "else", "if", "(", "getABI", "(", ")", ".", "IsN32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_ABI2", ";", "if", "(", "Features", "[", "Mips", "::", "FeatureGP64Bit", "]", ")", "{", "if", "(", "getABI", "(", ")", ".", "IsO32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_32BITMODE", ";", "}", "else", "if", "(", "Features", "[", "Mips", "::", "FeatureMips64r2", "]", "||", "Features", "[", "Mips", "::", "FeatureMips64", "]", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_32BITMODE", ";", "if", "(", "!", "Features", "[", "Mips", "::", "FeatureNoABICalls", "]", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_CPIC", ";", "if", "(", "Pic", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_PIC", "|", "ELF", "::", "EF_MIPS_CPIC", ";", "if", "(", "getABI", "(", ")", ".", "IsCheriPureCap", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_ABI_CHERIABI", ";", "MCA", ".", "setELFHeaderEFlags", "(", "EFlags", ")", ";", "MipsELFStreamer", "&", "MEF", "=", "static_cast", "<", "MipsELFStreamer", "&", ">", "(", "Streamer", ")", ";", "MEF", ".", "EmitMipsOptionRecords", "(", ")", ";", "emitMipsAbiFlags", "(", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "Mips", "Mips", "16u", "16u", "16u", "0", "1", "Mips::FeatureGP64Bit", "Mips::FeatureMips64r2", "Mips::FeatureMips64", "Mips::FeatureNoABICalls", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "static", "rtx", "gen_push", "(", "rtx", "arg", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "stack_pointer_rtx", ")", "m", "->", "fs", ".", "cfa_offset", "+=", "UNITS_PER_WORD", ";", "m", "->", "fs", ".", "sp_offset", "+=", "UNITS_PER_WORD", ";", "if", "(", "REG_P", "(", "arg", ")", "&&", "GET_MODE", "(", "arg", ")", "!=", "word_mode", ")", "arg", "=", "gen_rtx_REG", "(", "word_mode", ",", "REGNO", "(", "arg", ")", ")", ";", "return", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ",", "arg", ")", ";", "}", "</s>" ]

[ "Code", "to", "generate", "prologue", "and", "epilogue", "sequences" ]

[ "i386" ]

[]

[ "<s>", "static", "void", "begin_decl_field", "(", "void", ")", "{", "if", "(", "decl_offset", "==", "decl_chunk_size", ")", "fprintf", "(", "asm_out_file", ",", "\" = { \"", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\", \"", ")", ";", "}", "</s>" ]

[ "Write", "the", "necessary", "separator", "string", "to", "begin", "a", "new", "initializer", "value", "." ]

[ "nvptx", "\" = { \"", "\", \"" ]

[]

[ "<s>", "const", "TargetIntrinsicInfo", "*", "getIntrinsicInfo", "(", ")", "const", "{", "return", "&", "IntrinsicInfo", ";", "}", "</s>" ]

[ "If", "intrinsic", "information", "is", "available", ",", "return", "it", ".", "If", "not", ",", "return", "null", "." ]

[ "MBlaze" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "MI", "&&", "\"Unable to get the legal offset for nil instruction.\"", ")", ";", "StackOffset", "SaveOffset", "=", "StackOffset", "::", "getFixed", "(", "Offset", ")", ";", "return", "isAArch64FrameOffsetLegal", "(", "*", "MI", ",", "SaveOffset", ")", "&", "AArch64FrameOffsetIsLegal", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "AArch64", "AArch64", "\"Unable to get the legal offset for nil instruction.\"", "AArch64", "AArch64" ]

[]

[ "<s>", "CCAssignFn", "*", "AMDGPUCallLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "{", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "llvm_unreachable", "(", "\"kernels should not be handled here\"", ")", ";", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_HS", ":", "case", "CallingConv", "::", "AMDGPU_ES", ":", "case", "CallingConv", "::", "AMDGPU_LS", ":", "return", "CC_AMDGPU", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "return", "CC_AMDGPU_Func", ";", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "\"kernels should not be handled here\"", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "\"Unsupported calling convention.\"" ]

[]

[ "<s>", "static", "bool", "aarch64_emit_cfi_for_reg_p", "(", "unsigned", "int", "regno", ")", "{", "return", "(", "GP_REGNUM_P", "(", "regno", ")", "||", "!", "default_function_abi", ".", "clobbers_full_reg_p", "(", "regno", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "should", "emit", "CFI", "for", "register", "REGNO", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "int", "rs6000_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "int", "ret", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", "||", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", ")", "{", "reg_class_t", "rclass", "=", "from", ";", "if", "(", "!", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", ")", "rclass", "=", "to", ";", "if", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "ALTIVEC_REGS", "||", "rclass", "==", "VSX_REGS", ")", "ret", "=", "(", "rs6000_memory_move_cost", "(", "mode", ",", "rclass", ",", "false", ")", "+", "rs6000_memory_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "false", ")", ")", ";", "else", "if", "(", "rclass", "==", "CR_REGS", ")", "ret", "=", "4", ";", "else", "if", "(", "(", "rs6000_cpu", "==", "PROCESSOR_POWER6", "||", "rs6000_cpu", "==", "PROCESSOR_POWER7", "||", "rs6000_cpu", "==", "PROCESSOR_POWER8", "||", "rs6000_cpu", "==", "PROCESSOR_POWER9", ")", "&&", "reg_classes_intersect_p", "(", "rclass", ",", "LINK_OR_CTR_REGS", ")", ")", "ret", "=", "6", "*", "hard_regno_nregs", "[", "0", "]", "[", "mode", "]", ";", "else", "ret", "=", "2", "*", "hard_regno_nregs", "[", "0", "]", "[", "mode", "]", ";", "}", "else", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "VSX_REGS", ")", "&&", "reg_classes_intersect_p", "(", "from", ",", "VSX_REGS", ")", ")", "ret", "=", "2", "*", "hard_regno_nregs", "[", "32", "]", "[", "mode", "]", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "from", ")", ")", "ret", "=", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "?", "4", ":", "2", ";", "else", "ret", "=", "(", "rs6000_register_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "to", ")", "+", "rs6000_register_move_cost", "(", "mode", ",", "from", ",", "GENERAL_REGS", ")", ")", ";", "if", "(", "TARGET_DEBUG_COST", ")", "{", "if", "(", "dbg_cost_ctrl", "==", "1", ")", "fprintf", "(", "stderr", ",", "\"rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\\n\"", ",", "ret", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_class_names", "[", "from", "]", ",", "reg_class_names", "[", "to", "]", ")", ";", "dbg_cost_ctrl", "--", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expression", "returning", "the", "cost", "of", "moving", "data", "from", "a", "register", "of", "class", "CLASS1", "to", "one", "of", "CLASS2", "." ]

[ "rs6000", "4", "6", "0", "2", "0", "2", "32", "4", "2", "1", "\"rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\\n\"" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "ParseInstruction", "(", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "size_t", "Start", "=", "0", ",", "Next", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Head", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "unsigned", "PredicationCode", ";", "unsigned", "ProcessorIMod", ";", "bool", "CarrySetting", ";", "Head", "=", "SplitMnemonic", "(", "Head", ",", "PredicationCode", ",", "CarrySetting", ",", "ProcessorIMod", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateToken", "(", "Head", ",", "NameLoc", ")", ")", ";", "bool", "CanAcceptCarrySet", ",", "CanAcceptPredicationCode", ";", "GetMnemonicAcceptInfo", "(", "Head", ",", "CanAcceptCarrySet", ",", "CanAcceptPredicationCode", ")", ";", "if", "(", "CanAcceptCarrySet", ")", "{", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateCCOut", "(", "CarrySetting", "?", "ARM", "::", "CPSR", ":", "0", ",", "NameLoc", ")", ")", ";", "}", "else", "{", "}", "if", "(", "CanAcceptPredicationCode", ")", "{", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateCondCode", "(", "ARMCC", "::", "CondCodes", "(", "PredicationCode", ")", ",", "NameLoc", ")", ")", ";", "}", "else", "{", "}", "if", "(", "ProcessorIMod", ")", "{", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateImm", "(", "MCConstantExpr", "::", "Create", "(", "ProcessorIMod", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "else", "{", "}", "while", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "Start", "=", "Next", ";", "Next", "=", "Name", ".", "find", "(", "'.'", ",", "Start", "+", "1", ")", ";", "StringRef", "ExtraToken", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateToken", "(", "ExtraToken", ",", "NameLoc", ")", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Head", ")", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Head", ")", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "TokError", "(", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "ARM", "ARM", "0", "ARM", "ARM", "ARM::CPSR", "0", "ARM", "ARMCC::CondCodes", "ARM", "1", "ARM", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "FISC" ]

[]

[ "<s>", "static", "bool", "thumb_force_lr_save", "(", "void", ")", "{", "return", "!", "cfun", "->", "machine", "->", "lr_save_eliminated", "&&", "(", "!", "crtl", "->", "is_leaf", "||", "thumb_far_jump_used_p", "(", ")", "||", "df_regs_ever_live_p", "(", "LR_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "current", "function", "needs", "to", "save/restore", "LR", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "AddrMode", "=", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "unsigned", "i", "=", "0", ";", "for", "(", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "assert", "(", "i", "+", "1", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "if", "(", "AddrMode", "==", "ARMII", "::", "AddrMode4", "||", "AddrMode", "==", "ARMII", "::", "AddrMode6", ")", "return", "Offset", "==", "0", ";", "unsigned", "NumBits", "=", "0", ";", "unsigned", "Scale", "=", "1", ";", "bool", "isSigned", "=", "true", ";", "switch", "(", "AddrMode", ")", "{", "case", "ARMII", "::", "AddrModeT2_i8", ":", "case", "ARMII", "::", "AddrModeT2_i8pos", ":", "case", "ARMII", "::", "AddrModeT2_i8neg", ":", "case", "ARMII", "::", "AddrModeT2_i12", ":", "Scale", "=", "1", ";", "if", "(", "Offset", "<", "0", ")", "{", "NumBits", "=", "8", ";", "Offset", "=", "-", "Offset", ";", "}", "else", "{", "NumBits", "=", "12", ";", "}", "break", ";", "case", "ARMII", "::", "AddrMode5", ":", "NumBits", "=", "8", ";", "Scale", "=", "4", ";", "break", ";", "case", "ARMII", "::", "AddrMode_i12", ":", "case", "ARMII", "::", "AddrMode2", ":", "NumBits", "=", "12", ";", "break", ";", "case", "ARMII", "::", "AddrMode3", ":", "NumBits", "=", "8", ";", "break", ";", "case", "ARMII", "::", "AddrModeT1_s", ":", "NumBits", "=", "(", "BaseReg", "==", "ARM", "::", "SP", "?", "8", ":", "5", ")", ";", "Scale", "=", "4", ";", "isSigned", "=", "false", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported addressing mode!\"", ")", ";", "}", "Offset", "+=", "getFrameIndexInstrOffset", "(", "MI", ",", "i", ")", ";", "if", "(", "(", "Offset", "&", "(", "Scale", "-", "1", ")", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "isSigned", "&&", "Offset", "<", "0", ")", "Offset", "=", "-", "Offset", ";", "unsigned", "Mask", "=", "(", "1", "<<", "NumBits", ")", "-", "1", ";", "if", "(", "(", "unsigned", ")", "Offset", "<=", "Mask", "*", "Scale", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "ARM", "ARM", "ARMII::AddrModeMask", "0", "1", "\"Instr doesn't have FrameIndex operand!\"", "ARMII::AddrMode4", "ARMII::AddrMode6", "0", "0", "1", "ARMII::AddrModeT2_i8", "ARMII::AddrModeT2_i8pos", "ARMII::AddrModeT2_i8neg", "ARMII::AddrModeT2_i12", "1", "0", "8", "12", "ARMII::AddrMode5", "8", "4", "ARMII::AddrMode_i12", "ARMII::AddrMode2", "12", "ARMII::AddrMode3", "8", "ARMII::AddrModeT1_s", "ARM::SP", "8", "5", "4", "\"Unsupported addressing mode!\"", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "return", "getDarwinCalleeSavedRegs", "(", "MF", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AArch64_CFGuard_Check_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetWindows", "(", ")", ")", "return", "CSR_Win_AArch64_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "CSR_AArch64_AAVPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_AArch64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_AArch64_CXX_TLS_Darwin_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "pa_init_libfuncs", "(", "void", ")", "{", "if", "(", "HPUX_LONG_DOUBLE_LIBRARY", ")", "{", "set_optab_libfunc", "(", "add_optab", ",", "TFmode", ",", "\"_U_Qfadd\"", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "TFmode", ",", "\"_U_Qfsub\"", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "TFmode", ",", "\"_U_Qfmpy\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "TFmode", ",", "\"_U_Qfdiv\"", ")", ";", "set_optab_libfunc", "(", "smin_optab", ",", "TFmode", ",", "\"_U_Qmin\"", ")", ";", "set_optab_libfunc", "(", "smax_optab", ",", "TFmode", ",", "\"_U_Qfmax\"", ")", ";", "set_optab_libfunc", "(", "sqrt_optab", ",", "TFmode", ",", "\"_U_Qfsqrt\"", ")", ";", "set_optab_libfunc", "(", "abs_optab", ",", "TFmode", ",", "\"_U_Qfabs\"", ")", ";", "set_optab_libfunc", "(", "neg_optab", ",", "TFmode", ",", "\"_U_Qfneg\"", ")", ";", "set_optab_libfunc", "(", "eq_optab", ",", "TFmode", ",", "\"_U_Qfeq\"", ")", ";", "set_optab_libfunc", "(", "ne_optab", ",", "TFmode", ",", "\"_U_Qfne\"", ")", ";", "set_optab_libfunc", "(", "gt_optab", ",", "TFmode", ",", "\"_U_Qfgt\"", ")", ";", "set_optab_libfunc", "(", "ge_optab", ",", "TFmode", ",", "\"_U_Qfge\"", ")", ";", "set_optab_libfunc", "(", "lt_optab", ",", "TFmode", ",", "\"_U_Qflt\"", ")", ";", "set_optab_libfunc", "(", "le_optab", ",", "TFmode", ",", "\"_U_Qfle\"", ")", ";", "set_optab_libfunc", "(", "unord_optab", ",", "TFmode", ",", "\"_U_Qfunord\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TFmode", ",", "SFmode", ",", "\"_U_Qfcnvff_sgl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TFmode", ",", "DFmode", ",", "\"_U_Qfcnvff_dbl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SFmode", ",", "TFmode", ",", "\"_U_Qfcnvff_quad_to_sgl\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DFmode", ",", "TFmode", ",", "\"_U_Qfcnvff_quad_to_dbl\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "SImode", ",", "TFmode", ",", "TARGET_64BIT", "?", "\"__U_Qfcnvfxt_quad_to_sgl\"", ":", "\"_U_Qfcnvfxt_quad_to_sgl\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "DImode", ",", "TFmode", ",", "\"_U_Qfcnvfxt_quad_to_dbl\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "SImode", ",", "TFmode", ",", "\"_U_Qfcnvfxt_quad_to_usgl\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "DImode", ",", "TFmode", ",", "\"_U_Qfcnvfxt_quad_to_udbl\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "TFmode", ",", "SImode", ",", "\"_U_Qfcnvxf_sgl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "TFmode", ",", "DImode", ",", "\"_U_Qfcnvxf_dbl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "TFmode", ",", "SImode", ",", "\"_U_Qfcnvxf_usgl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "TFmode", ",", "DImode", ",", "\"_U_Qfcnvxf_udbl_to_quad\"", ")", ";", "}", "if", "(", "TARGET_SYNC_LIBCALL", ")", "init_sync_libfuncs", "(", "8", ")", ";", "}", "</s>" ]

[ "Initialize", "optabs", "to", "point", "to", "emulation", "routines", "." ]

[ "pa", "\"_U_Qfadd\"", "\"_U_Qfsub\"", "\"_U_Qfmpy\"", "\"_U_Qfdiv\"", "\"_U_Qmin\"", "\"_U_Qfmax\"", "\"_U_Qfsqrt\"", "\"_U_Qfabs\"", "\"_U_Qfneg\"", "\"_U_Qfeq\"", "\"_U_Qfne\"", "\"_U_Qfgt\"", "\"_U_Qfge\"", "\"_U_Qflt\"", "\"_U_Qfle\"", "\"_U_Qfunord\"", "\"_U_Qfcnvff_sgl_to_quad\"", "\"_U_Qfcnvff_dbl_to_quad\"", "\"_U_Qfcnvff_quad_to_sgl\"", "\"_U_Qfcnvff_quad_to_dbl\"", "\"__U_Qfcnvfxt_quad_to_sgl\"", "\"_U_Qfcnvfxt_quad_to_sgl\"", "\"_U_Qfcnvfxt_quad_to_dbl\"", "\"_U_Qfcnvfxt_quad_to_usgl\"", "\"_U_Qfcnvfxt_quad_to_udbl\"", "\"_U_Qfcnvxf_sgl_to_quad\"", "\"_U_Qfcnvxf_dbl_to_quad\"", "\"_U_Qfcnvxf_usgl_to_quad\"", "\"_U_Qfcnvxf_udbl_to_quad\"", "8" ]

[]

[ "<s>", "Register", "RISCVTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "RISCV", "::", "X11", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "RISCV", "RISCV", "RISCV::X11" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "if", "(", "convertAddSubFlagsOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", ";", "return", "false", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tMOVr", "&&", "!", "Subtarget", ".", "hasV6Ops", "(", ")", ")", "{", "if", "(", "!", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "!", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Non-flag-setting Thumb1 mov is v6-only\"", ";", "return", "false", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", ")", "{", "for", "(", "int", "i", "=", "2", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "i", ")", ".", "isImplicit", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "<", "ARM", "::", "R0", "||", "Reg", ">", "ARM", "::", "R7", ")", "{", "if", "(", "!", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", "&&", "Reg", "==", "ARM", "::", "LR", ")", "&&", "!", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", "&&", "Reg", "==", "ARM", "::", "PC", ")", ")", "{", "ErrInfo", "=", "\"Unsupported register in Thumb1 push/pop\"", ";", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "ARM", "ARM", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", "ARM::tMOVr", "ARM::hGPRRegClass", "0", "ARM::hGPRRegClass", "1", "\"Non-flag-setting Thumb1 mov is v6-only\"", "ARM::tPUSH", "ARM::tPOP", "ARM::tPOP_RET", "2", "ARM::R0", "ARM::R7", "ARM::tPUSH", "ARM::LR", "ARM::tPOP_RET", "ARM::PC", "\"Unsupported register in Thumb1 push/pop\"" ]

[]

[ "<s>", "static", "int", "arm_comp_type_attributes", "(", "tree", "type1", ",", "tree", "type2", ")", "{", "int", "l1", ",", "l2", ",", "s1", ",", "s2", ";", "if", "(", "TREE_CODE", "(", "type1", ")", "!=", "FUNCTION_TYPE", ")", "return", "1", ";", "l1", "=", "lookup_attribute", "(", "\"long_call\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "NULL", ";", "l2", "=", "lookup_attribute", "(", "\"long_call\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", "!=", "NULL", ";", "s1", "=", "lookup_attribute", "(", "\"short_call\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "NULL", ";", "s2", "=", "lookup_attribute", "(", "\"short_call\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", "!=", "NULL", ";", "if", "(", "l1", "|", "l2", "|", "s1", "|", "s2", ")", "{", "if", "(", "(", "l1", "!=", "l2", ")", "||", "(", "s1", "!=", "s2", ")", ")", "return", "0", ";", "if", "(", "(", "l1", "&", "s2", ")", "||", "(", "l2", "&", "s1", ")", ")", "return", "0", ";", "}", "l1", "=", "lookup_attribute", "(", "\"isr\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "NULL", ";", "if", "(", "!", "l1", ")", "l1", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "NULL", ";", "l2", "=", "lookup_attribute", "(", "\"isr\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", "!=", "NULL", ";", "if", "(", "!", "l2", ")", "l1", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", "!=", "NULL", ";", "if", "(", "l1", "!=", "l2", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "0", "if", "the", "attributes", "for", "two", "types", "are", "incompatible", ",", "1", "if", "they", "are", "compatible", ",", "and", "2", "if", "they", "are", "nearly", "compatible", "(", "which", "causes", "a", "warning", "to", "be", "generated", ")", "." ]

[ "arm", "1", "\"long_call\"", "\"long_call\"", "\"short_call\"", "\"short_call\"", "0", "0", "\"isr\"", "\"interrupt\"", "\"isr\"", "\"interrupt\"", "0", "1" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "BPFISD", "::", "RET_FLAG", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", "->", "isAggregateType", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"only integer returns supported\"", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_BPF64", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "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", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::OutputArg", "BPFISD::RET_FLAG", "16", "\"only integer returns supported\"", "MVT::Other", "BPF", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "MVT::Other" ]

[]

[ "<s>", "void", "MipsTargetStreamer", "::", "emitGPRestore", "(", "int", "Offset", ",", "SMLoc", "IDLoc", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "{", "emitLoadWithImmOffset", "(", "Mips", "::", "LW", ",", "Mips", "::", "GP", ",", "Mips", "::", "SP", ",", "Offset", ",", "Mips", "::", "GP", ",", "IDLoc", ",", "STI", ")", ";", "}", "</s>" ]

[ "Emit", "the", "$", "gp", "restore", "operation", "for", ".cprestore", "." ]

[ "Mips", "Mips", "Mips::LW", "Mips::GP", "Mips::SP", "Mips::GP" ]

[]