Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "Dcpu16", "DCPU16", "DCPU16::GR16RegClass" ]

[]

[ "<s>", "static", "rtx", "gen_rx_store_vector", "(", "unsigned", "int", "low", ",", "unsigned", "int", "high", ")", "{", "unsigned", "int", "i", ";", "unsigned", "int", "count", "=", "(", "high", "-", "low", ")", "+", "2", ";", "rtx", "vector", ";", "vector", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "XVECEXP", "(", "vector", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "gen_rtx_MINUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "(", "count", "-", "1", ")", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", "-", "1", ";", "i", "++", ")", "XVECEXP", "(", "vector", ",", "0", ",", "i", "+", "1", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_MINUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "(", "i", "+", "1", ")", "*", "UNITS_PER_WORD", ")", ")", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "high", "-", "i", ")", ")", ";", "return", "vector", ";", "}", "</s>" ]

[ "Generate", "a", "PARALLEL", "that", "will", "pass", "the", "rx_store_multiple_vector", "predicate", "." ]

[ "rx", "2", "0", "0", "1", "0", "1", "0", "1", "1" ]

[]

[ "<s>", "void", "X86MCCodeEmitter", "::", "emitPrefix", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "Opcode", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "X86II", "::", "isPseudo", "(", "TSFlags", ")", ")", "return", ";", "unsigned", "CurOp", "=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "emitPrefixImpl", "(", "CurOp", ",", "MI", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

[ "Append", "the", "prefixes", "of", "given", "instruction", "to", "the", "code", "buffer", "." ]

[ "X86", "X86", "X86II::isPseudo", "X86II::getOperandBias" ]

[]

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

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

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

[]

[ "<s>", "void", "AVRInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AVR", "::", "LDRdPtr", ":", "case", "AVR", "::", "LDRdPtrPi", ":", "case", "AVR", "::", "LDRdPtrPd", ":", "O", "<<", "\"\\tld\\t\"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "if", "(", "Opcode", "==", "AVR", "::", "LDRdPtrPd", ")", "O", "<<", "'-'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "if", "(", "Opcode", "==", "AVR", "::", "LDRdPtrPi", ")", "O", "<<", "'+'", ";", "break", ";", "case", "AVR", "::", "STPtrRr", ":", "O", "<<", "\"\\tst\\t\"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "break", ";", "case", "AVR", "::", "STPtrPiRr", ":", "case", "AVR", "::", "STPtrPdRr", ":", "O", "<<", "\"\\tst\\t\"", ";", "if", "(", "Opcode", "==", "AVR", "::", "STPtrPdRr", ")", "O", "<<", "'-'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "if", "(", "Opcode", "==", "AVR", "::", "STPtrPiRr", ")", "O", "<<", "'+'", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "2", ",", "O", ")", ";", "break", ";", "default", ":", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "Address", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "AVR", "AVR", "AVR::LDRdPtr", "AVR::LDRdPtrPi", "AVR::LDRdPtrPd", "\"\\tld\\t\"", "0", "\", \"", "AVR::LDRdPtrPd", "1", "AVR::LDRdPtrPi", "AVR::STPtrRr", "\"\\tst\\t\"", "0", "\", \"", "1", "AVR::STPtrPiRr", "AVR::STPtrPdRr", "\"\\tst\\t\"", "AVR::STPtrPdRr", "1", "AVR::STPtrPiRr", "\", \"", "2" ]

[]

[ "<s>", "static", "tree", "sparc_gimplify_va_arg", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", ")", "{", "HOST_WIDE_INT", "size", ",", "rsize", ",", "align", ";", "tree", "addr", ",", "incr", ";", "bool", "indirect", ";", "tree", "ptrtype", "=", "build_pointer_type", "(", "type", ")", ";", "if", "(", "pass_by_reference", "(", "NULL", ",", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "false", ")", ")", "{", "indirect", "=", "true", ";", "size", "=", "rsize", "=", "UNITS_PER_WORD", ";", "align", "=", "0", ";", "}", "else", "{", "indirect", "=", "false", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "rsize", "=", "ROUND_UP", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "align", "=", "0", ";", "if", "(", "TARGET_ARCH64", ")", "{", "if", "(", "TYPE_ALIGN", "(", "type", ")", ">=", "2", "*", "(", "unsigned", ")", "BITS_PER_WORD", ")", "align", "=", "2", "*", "UNITS_PER_WORD", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "size", "==", "0", ")", "size", "=", "rsize", "=", "UNITS_PER_WORD", ";", "else", "size", "=", "rsize", ";", "}", "}", "}", "incr", "=", "valist", ";", "if", "(", "align", ")", "{", "incr", "=", "fold_build_pointer_plus_hwi", "(", "incr", ",", "align", "-", "1", ")", ";", "incr", "=", "fold_convert", "(", "sizetype", ",", "incr", ")", ";", "incr", "=", "fold_build2", "(", "BIT_AND_EXPR", ",", "sizetype", ",", "incr", ",", "size_int", "(", "-", "align", ")", ")", ";", "incr", "=", "fold_convert", "(", "ptr_type_node", ",", "incr", ")", ";", "}", "gimplify_expr", "(", "&", "incr", ",", "pre_p", ",", "post_p", ",", "is_gimple_val", ",", "fb_rvalue", ")", ";", "addr", "=", "incr", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "size", "<", "rsize", ")", "addr", "=", "fold_build_pointer_plus_hwi", "(", "incr", ",", "rsize", "-", "size", ")", ";", "if", "(", "indirect", ")", "{", "addr", "=", "fold_convert", "(", "build_pointer_type", "(", "ptrtype", ")", ",", "addr", ")", ";", "addr", "=", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "else", "if", "(", "align", "==", "0", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "BITS_PER_WORD", ")", "{", "tree", "tmp", "=", "create_tmp_var", "(", "type", ",", "\"va_arg_tmp\"", ")", ";", "tree", "dest_addr", "=", "build_fold_addr_expr", "(", "tmp", ")", ";", "tree", "copy", "=", "build_call_expr", "(", "builtin_decl_implicit", "(", "BUILT_IN_MEMCPY", ")", ",", "3", ",", "dest_addr", ",", "addr", ",", "size_int", "(", "rsize", ")", ")", ";", "TREE_ADDRESSABLE", "(", "tmp", ")", "=", "1", ";", "gimplify_and_add", "(", "copy", ",", "pre_p", ")", ";", "addr", "=", "dest_addr", ";", "}", "else", "addr", "=", "fold_convert", "(", "ptrtype", ",", "addr", ")", ";", "incr", "=", "fold_build_pointer_plus_hwi", "(", "incr", ",", "rsize", ")", ";", "gimplify_assign", "(", "valist", ",", "incr", ",", "post_p", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "</s>" ]

[ "Implement", "`", "va_arg", "'", "for", "stdarg", "." ]

[ "sparc", "0", "0", "2", "2", "0", "1", "0", "\"va_arg_tmp\"", "3", "1" ]

[]

[ "<s>", "static", "SDValue", "matchBinOpReduction", "(", "SDNode", "*", "Extract", ",", "unsigned", "&", "BinOp", ",", "ArrayRef", "<", "ISD", "::", "NodeType", ">", "CandidateBinOps", ")", "{", "if", "(", "(", "Extract", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "||", "!", "isNullConstant", "(", "Extract", "->", "getOperand", "(", "1", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Op", "=", "Extract", "->", "getOperand", "(", "0", ")", ";", "unsigned", "Stages", "=", "Log2_32", "(", "Op", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ")", ";", "if", "(", "llvm", "::", "none_of", "(", "CandidateBinOps", ",", "[", "Op", "]", "(", "ISD", "::", "NodeType", "BinOp", ")", "{", "return", "Op", ".", "getOpcode", "(", ")", "==", "BinOp", ";", "}", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "CandidateBinOp", "=", "Op", ".", "getOpcode", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Stages", ";", "++", "i", ")", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "!=", "CandidateBinOp", ")", "return", "SDValue", "(", ")", ";", "ShuffleVectorSDNode", "*", "Shuffle", "=", "dyn_cast", "<", "ShuffleVectorSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ".", "getNode", "(", ")", ")", ";", "if", "(", "Shuffle", ")", "{", "Op", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "}", "else", "{", "Shuffle", "=", "dyn_cast", "<", "ShuffleVectorSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ".", "getNode", "(", ")", ")", ";", "Op", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "}", "if", "(", "!", "Shuffle", "||", "Shuffle", "->", "getOperand", "(", "0", ")", "!=", "Op", ")", "return", "SDValue", "(", ")", ";", "for", "(", "int", "Index", "=", "0", ",", "MaskEnd", "=", "1", "<<", "i", ";", "Index", "<", "MaskEnd", ";", "++", "Index", ")", "if", "(", "Shuffle", "->", "getMaskElt", "(", "Index", ")", "!=", "MaskEnd", "+", "Index", ")", "return", "SDValue", "(", ")", ";", "}", "BinOp", "=", "CandidateBinOp", ";", "return", "Op", ";", "}", "</s>" ]

[ "Match", "a", "binop", "+", "shuffle", "pyramid", "that", "represents", "a", "horizontal", "reduction", "over", "the", "elements", "of", "a", "vector", "starting", "from", "the", "EXTRACT_VECTOR_ELT", "node", "/p", "Extract", "." ]

[ "X86", "ISD::NodeType", "ISD::EXTRACT_VECTOR_ELT", "1", "0", "ISD::NodeType", "0", "0", "1", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "split_addsi", "(", "rtx", "*", "operands", ")", "{", "int", "val", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "val", ">", "127", "&&", "val", "<=", "255", "&&", "arc_check_short_reg_p", "(", "operands", "[", "0", "]", ")", ")", "{", "operands", "[", "3", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "}", "else", "{", "operands", "[", "3", "]", "=", "operands", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "}", "}", "</s>" ]

[ "Operands", "0", "..", "2", "are", "the", "operands", "of", "a", "addsi", "which", "uses", "a", "12", "bit", "constant", "in", "operand", "2", ",", "but", "which", "would", "require", "a", "LIMM", "because", "of", "operand", "mismatch", ".", "operands", "3", "and", "4", "are", "new", "SET_SRCs", "for", "operands", "0", "." ]

[ "arc", "2", "127", "255", "0", "3", "2", "4", "0", "1", "3", "1", "4", "0", "2" ]

[]

[ "<s>", "bool", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "void", "nds32_emit_stack_v3pop", "(", "unsigned", "Rb", ",", "unsigned", "Re", ",", "unsigned", "imm8u", ")", "{", "unsigned", "regno", ";", "int", "num_use_regs", ";", "int", "par_index", ";", "int", "offset", ";", "rtx", "reg", ";", "rtx", "mem", ";", "rtx", "pop_rtx", ";", "rtx", "adjust_sp_rtx", ";", "rtx", "parallel_insn", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "num_use_regs", "=", "Re", "-", "Rb", "+", "1", "+", "3", ";", "parallel_insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_use_regs", "+", "1", ")", ")", ";", "par_index", "=", "0", ";", "offset", "=", "0", ";", "for", "(", "regno", "=", "Rb", ";", "regno", "<=", "Re", ";", "regno", "++", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "pop_rtx", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "pop_rtx", ";", "RTX_FRAME_RELATED_P", "(", "pop_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "}", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "FP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "pop_rtx", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "pop_rtx", ";", "RTX_FRAME_RELATED_P", "(", "pop_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "GP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "pop_rtx", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "pop_rtx", ";", "RTX_FRAME_RELATED_P", "(", "pop_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "LP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "pop_rtx", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "pop_rtx", ";", "RTX_FRAME_RELATED_P", "(", "pop_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "adjust_sp_rtx", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", "+", "imm8u", ")", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "adjust_sp_rtx", ";", "if", "(", "frame_pointer_needed", ")", "{", "rtx", "cfa_adjust_rtx", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "const0_rtx", ")", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "cfa_adjust_rtx", ",", "dwarf", ")", ";", "}", "else", "{", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_ADJUST_CFA", ",", "copy_rtx", "(", "adjust_sp_rtx", ")", ",", "dwarf", ")", ";", "}", "parallel_insn", "=", "emit_insn", "(", "parallel_insn", ")", ";", "RTX_FRAME_RELATED_P", "(", "parallel_insn", ")", "=", "1", ";", "REG_NOTES", "(", "parallel_insn", ")", "=", "dwarf", ";", "}", "</s>" ]

[ "Function", "to", "create", "a", "parallel", "rtx", "pattern", "which", "presents", "stack", "v3pop", "behavior", ".", "The", "overall", "concept", "are", ":", "``", "pop", "registers", "from", "memory", "''", ",", "``", "adjust", "stack", "pointer", "''", "." ]

[ "nds32", "1", "3", "1", "0", "0", "0", "1", "4", "0", "1", "4", "0", "1", "4", "0", "1", "4", "0", "1" ]

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "return", "32", "-", "1", "-", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "-", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getNumXRegisterReserved", "(", ")", "-", "hasBasePointer", "(", "MF", ")", ";", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "FPR64_loRegClassID", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AArch64", "AArch64", "AArch64", "0", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR32commonRegClassID", "AArch64::GPR64commonRegClassID", "32", "1", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "32", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "32", "AArch64::FPR128_loRegClassID", "AArch64::FPR64_loRegClassID", "16" ]

[]

[ "<s>", "static", "int", "nvptx_dim_limit", "(", "int", "axis", ")", "{", "switch", "(", "axis", ")", "{", "case", "GOMP_DIM_VECTOR", ":", "return", "PTX_MAX_VECTOR_LENGTH", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "maximum", "dimension", "size", ",", "or", "zero", "for", "unbounded", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "static", "void", "emit_insr", "(", "rtx", "target", ",", "rtx", "elem", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "scalar_mode", "elem_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "elem", "=", "force_reg", "(", "elem_mode", ",", "elem", ")", ";", "insn_code", "icode", "=", "optab_handler", "(", "vec_shl_insert_optab", ",", "mode", ")", ";", "gcc_assert", "(", "icode", "!=", "CODE_FOR_nothing", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "target", ",", "elem", ")", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "corresponding", "to", ":", "insr", "TARGET", ",", "ELEM", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "loongarch_split_move_insn_p", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "return", "loongarch_split_move_p", "(", "dest", ",", "src", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "move", "from", "SRC", "to", "DEST", "in", "INSN", "should", "be", "split", "." ]

[ "loongarch" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "FI", "->", "setMustSaveLR", "(", "MustSaveLR", "(", "MF", ",", "LR", ")", ")", ";", "SavedRegs", ".", "reset", "(", "LR", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "const", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "FPSI", "&&", "needsFP", "(", "MF", ")", ")", "{", "int", "FPOffset", "=", "getFramePointerSaveOffset", "(", ")", ";", "FPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "FPOffset", ",", "true", ")", ";", "FI", "->", "setFramePointerSaveIndex", "(", "FPSI", ")", ";", "}", "int", "BPSI", "=", "FI", "->", "getBasePointerSaveIndex", "(", ")", ";", "if", "(", "!", "BPSI", "&&", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "int", "BPOffset", "=", "getBasePointerSaveOffset", "(", ")", ";", "BPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "BPOffset", ",", "true", ")", ";", "FI", "->", "setBasePointerSaveIndex", "(", "BPSI", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "{", "int", "PBPSI", "=", "MFI", ".", "CreateFixedObject", "(", "4", ",", "-", "8", ",", "true", ")", ";", "FI", "->", "setPICBasePointerSaveIndex", "(", "PBPSI", ")", ";", "}", "if", "(", "needsFP", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "isPPC64", "?", "PPC", "::", "X31", ":", "PPC", "::", "R31", ")", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "RegInfo", "->", "getBaseRegister", "(", "MF", ")", ")", ";", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "SavedRegs", ".", "reset", "(", "PPC", "::", "R30", ")", ";", "int", "TCSPDelta", "=", "0", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "(", "TCSPDelta", "=", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "<", "0", ")", "{", "MFI", ".", "CreateFixedObject", "(", "-", "1", "*", "TCSPDelta", ",", "TCSPDelta", ",", "true", ")", ";", "}", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", "&&", "(", "SavedRegs", ".", "test", "(", "PPC", "::", "CR2", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR3", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR4", ")", ")", ")", "{", "int", "FrameIdx", "=", "MFI", ".", "CreateFixedObject", "(", "(", "uint64_t", ")", "4", ",", "(", "int64_t", ")", "-", "4", ",", "true", ")", ";", "FI", "->", "setCRSpillFrameIndex", "(", "FrameIdx", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "8", "4", "PPC", "8", "4", "4", "8", "PPC", "PPC::X31", "PPC::R31", "PPC::R30", "0", "0", "1", "PPC::CR2", "PPC::CR3", "PPC::CR4", "4", "4" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_v4hi_5", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "char", "perm2", "[", "4", "]", ";", "rtx", "rmask", "[", "4", "]", ";", "unsigned", "i", ";", "rtx", "t0", ",", "t1", ",", "mask", ",", "x", ";", "bool", "ok", ";", "if", "(", "d", "->", "vmode", "!=", "V4HImode", "||", "d", "->", "one_operand_p", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "{", "perm2", "[", "i", "]", "=", "d", "->", "perm", "[", "i", "]", "&", "3", ";", "rmask", "[", "i", "]", "=", "(", "d", "->", "perm", "[", "i", "]", "&", "4", "?", "const0_rtx", ":", "constm1_rtx", ")", ";", "}", "mask", "=", "gen_rtx_CONST_VECTOR", "(", "V4HImode", ",", "gen_rtvec_v", "(", "4", ",", "rmask", ")", ")", ";", "mask", "=", "force_reg", "(", "V4HImode", ",", "mask", ")", ";", "t0", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "t1", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "ok", "=", "expand_vselect", "(", "t0", ",", "d", "->", "op0", ",", "perm2", ",", "4", ")", ";", "gcc_assert", "(", "ok", ")", ";", "ok", "=", "expand_vselect", "(", "t1", ",", "d", "->", "op1", ",", "perm2", ",", "4", ")", ";", "gcc_assert", "(", "ok", ")", ";", "x", "=", "gen_rtx_AND", "(", "V4HImode", ",", "mask", ",", "t0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "t0", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "V4HImode", ",", "mask", ")", ";", "x", "=", "gen_rtx_AND", "(", "V4HImode", ",", "x", ",", "t1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "t1", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_IOR", "(", "V4HImode", ",", "t0", ",", "t1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "d", "->", "target", ",", "x", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ia64_expand_vec_perm_const_1", ".", "Emit", "a", "full", "V4HImode", "constant", "permutation", "via", "two", "mux2", "and", "a", "merge", "." ]

[ "ia64", "4", "4", "0", "4", "3", "4", "4", "4", "4" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::AND", "ISD::BRCOND", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::FP_TO_SINT", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::OR", "ISD::SELECT", "ISD::SETCC", "ISD::VASTART" ]

[]

[ "<s>", "static", "bool", "arc_check_short_reg_p", "(", "rtx", "op", ")", "{", "if", "(", "!", "REG_P", "(", "op", ")", ")", "return", "false", ";", "if", "(", "IN_RANGE", "(", "REGNO", "(", "op", ")", "^", "4", ",", "4", ",", "11", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "reg", "is", "ok", "for", "short", "instrcutions", "." ]

[ "arc", "4", "4", "11" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "DebugLoc", "dl", "=", "Old", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "unsigned", "Opc", "=", "Old", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "this", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "this", ",", "Amount", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "ARM", "0", "0", "1", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isCheapToSpeculateCttz", "(", ")", "const", "{", "return", "Subtarget", ".", "hasBMI", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "cttz", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "MipsTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'c'", ":", "case", "'l'", ":", "case", "'x'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "if", "(", "isa", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "int", "m32c_legitimate_constant_p", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "1", ";", "}", "</s>" ]

[ "Implements", "LEGITIMATE_CONSTANT_P", ".", "We", "split", "large", "constants", "anyway", ",", "so", "we", "can", "allow", "anything", "." ]

[ "m32c", "1" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "assert", "(", "allSGPRSpillsAreDead", "(", "MFI", ",", "None", ")", "&&", "\"SGPR spill should have been removed in SILowerSGPRSpills\"", ")", ";", "if", "(", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateFixedObject", "(", "TRI", "->", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "0", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "else", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "TRI", "->", "getSpillAlignment", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "\"SGPR spill should have been removed in SILowerSGPRSpills\"", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "0", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "bool", "LM32TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "return", "VT", "!=", "MVT", "::", "f32", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "LM32", "LM32", "MVT::f32" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "FISCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "FISC", "::", "GRRegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "FISC", "::", "X19", ",", "&", "FISC", "::", "GRRegsRegClass", ")", ";", "assert", "(", "\"Unexpected type.\"", ")", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", ";", "R", "=", "parseRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "second", ")", "return", "R", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "FISC", "FISC", "1", "0", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "0U", "FISC::GRRegsRegClass", "0u", "0", "MVT::i64", "FISC::X19", "FISC::GRRegsRegClass", "\"Unexpected type.\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "PatmosRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "Patmos", "Patmos", "\"Unimplemented\"" ]

[]

[ "<s>", "SUnit", "*", "ConvergingVLIWScheduler", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "DAG", "->", "top", "(", ")", "==", "DAG", "->", "bottom", "(", ")", ")", "{", "assert", "(", "Top", ".", "Available", ".", "empty", "(", ")", "&&", "Top", ".", "Pending", ".", "empty", "(", ")", "&&", "Bot", ".", "Available", ".", "empty", "(", ")", "&&", "Bot", ".", "Pending", ".", "empty", "(", ")", "&&", "\"ReadyQ garbage\"", ")", ";", "return", "nullptr", ";", "}", "SUnit", "*", "SU", ";", "if", "(", "ForceTopDown", ")", "{", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "TopResult", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "ForceBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "BotResult", ";", "SU", "=", "BotCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "}", "else", "{", "SU", "=", "pickNodeBidrectional", "(", "IsTopNode", ")", ";", "}", "if", "(", "SU", "->", "isTopReady", "(", ")", ")", "Top", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "SU", "->", "isBottomReady", "(", ")", ")", "Bot", ".", "removeReady", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "(", "IsTopNode", "?", "\"Top\"", ":", "\"Bottom\"", ")", "<<", "\" Scheduling instruction in cycle \"", "<<", "(", "IsTopNode", "?", "Top", ".", "CurrCycle", ":", "Bot", ".", "CurrCycle", ")", "<<", "\" (\"", "<<", "reportPackets", "(", ")", "<<", "\")\\n\"", ";", "SU", "->", "dump", "(", "DAG", ")", ")", ";", "return", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "Hexagon", "\"ReadyQ garbage\"", "\"failed to find the first candidate\"", "\"failed to find the first candidate\"", "\"*** \"", "\"Top\"", "\"Bottom\"", "\" Scheduling instruction in cycle \"", "\" (\"", "\")\\n\"" ]

[]

[ "<s>", "BitVector", "DCPU16RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "DCPU16", "::", "EX", ")", ";", "Reserved", ".", "set", "(", "DCPU16", "::", "SP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "DCPU16", "::", "J", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Dcpu16", "DCPU16", "DCPU16::EX", "DCPU16::SP", "DCPU16::J" ]

[]

[ "<s>", "unsigned", "AArch64MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "llvm_unreachable", "(", "\"Unable to encode MCOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Unable to encode MCOperand!\"", "0" ]

[]

[ "<s>", "SDValue", "F2003fTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_F2003f", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "F2003f", "F2003f", "ISD::InputArg", "16", "F2003f", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "X86LoadValueInjectionLoadHardeningPass", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "tree", "ix86_build_builtin_va_list", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "sysv_va_list_type_node", "=", "ix86_build_builtin_va_list_64", "(", ")", ";", "tree", "char_ptr_type", "=", "build_pointer_type", "(", "char_type_node", ")", ";", "tree", "attr", "=", "tree_cons", "(", "get_identifier", "(", "\"ms_abi va_list\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "char_ptr_type", ")", ")", ";", "ms_va_list_type_node", "=", "build_type_attribute_variant", "(", "char_ptr_type", ",", "attr", ")", ";", "return", "(", "(", "ix86_abi", "==", "MS_ABI", ")", "?", "ms_va_list_type_node", ":", "sysv_va_list_type_node", ")", ";", "}", "else", "{", "return", "build_pointer_type", "(", "char_type_node", ")", ";", "}", "}", "</s>" ]

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

[ "i386", "\"ms_abi va_list\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MVE lane interleaving\"", ";", "}", "</s>" ]

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

[ "ARM", "\"MVE lane interleaving\"" ]

[]

[ "<s>", "int", "rl78_force_nonfar_3", "(", "rtx", "*", "operands", ",", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", "{", "int", "did", "=", "0", ";", "rtx", "temp_reg", "=", "NULL", ";", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", "&&", "!", "MEM_P", "(", "operands", "[", "2", "]", ")", ")", "return", "0", ";", "if", "(", "rl78_far_p", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "temp_reg", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "operands", "[", "1", "]", ")", ")", ";", "emit_move_insn", "(", "temp_reg", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "temp_reg", ";", "did", "=", "1", ";", "}", "if", "(", "rl78_far_p", "(", "operands", "[", "0", "]", ")", ")", "{", "temp_reg", "=", "operands", "[", "0", "]", ";", "operands", "[", "0", "]", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", ";", "did", "=", "1", ";", "}", "if", "(", "!", "did", ")", "return", "0", ";", "emit_insn", "(", "gen", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "if", "(", "temp_reg", ")", "emit_move_insn", "(", "temp_reg", ",", "operands", "[", "0", "]", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "for", "three-operand", "expanders", "." ]

[ "rl78", "0", "0", "1", "2", "0", "1", "1", "1", "1", "1", "0", "0", "0", "0", "1", "0", "0", "1", "2", "0", "1" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "hasLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineMemOperand", "*", "&", "MMO", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", ".", "getIterator", "(", ")", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "if", "(", "TargetInstrInfo", "::", "hasLoadFromStackSlot", "(", "*", "MII", ",", "MMO", ",", "FrameIndex", ")", ")", "return", "true", ";", "return", "false", ";", "}", "return", "TargetInstrInfo", "::", "hasLoadFromStackSlot", "(", "MI", ",", "MMO", ",", "FrameIndex", ")", ";", "}", "</s>" ]

[ "If", "the", "specified", "machine", "instruction", "has", "a", "load", "from", "a", "stack", "slot", ",", "return", "true", "along", "with", "the", "FrameIndices", "of", "the", "loaded", "stack", "slot", "and", "the", "machine", "mem", "operands", "containing", "the", "reference", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "int", "SIInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "renamedInGFX9", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "if", "(", "ST", ".", "hasUnpackedD16VMem", "(", ")", "&&", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "D16Buf", ")", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX80", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "{", "switch", "(", "ST", ".", "getGeneration", "(", ")", ")", "{", "default", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX9", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA9", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX10", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA10", ";", "break", ";", "}", "}", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "{", "uint16_t", "NMCOp", "=", "(", "uint16_t", ")", "-", "1", ";", "NMCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "SIEncodingFamily", "::", "GFX90A", ")", ";", "if", "(", "NMCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "NMCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "SIEncodingFamily", "::", "GFX9", ")", ";", "if", "(", "NMCOp", "!=", "(", "uint16_t", ")", "-", "1", ")", "MCOp", "=", "NMCOp", ";", "}", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "if", "(", "isAsmOnlyOpcode", "(", "MCOp", ")", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "AMDGPU", "SI", "SI", "SIInstrFlags::renamedInGFX9", "0", "AMDGPU", "SIEncodingFamily::GFX9", "SIInstrFlags::D16Buf", "SIEncodingFamily::GFX80", "SIInstrFlags::SDWA", "SIEncodingFamily::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "AMDGPU", "SIEncodingFamily::SDWA10", "AMDGPU::getMCOpcode", "1", "1", "AMDGPU::getMCOpcode", "SIEncodingFamily::GFX90A", "1", "AMDGPU::getMCOpcode", "SIEncodingFamily::GFX9", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "bfin_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "arg", ".", "type", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "arg", ".", "type", ")", ")", "!=", "INTEGER_CST", ";", "}", "</s>" ]

[ "Variable", "sized", "types", "are", "passed", "by", "reference", "." ]

[ "bfin" ]

[]

[ "<s>", "bool", "WebAssemblyFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "llvm_unreachable", "(", "\"TODO: implement hasFP\"", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "WebAssembly", "WebAssembly", "\"TODO: implement hasFP\"" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "bool", "AfterFPPop", "=", "Opc", "==", "X86", "::", "TAILJMPm64", "||", "Opc", "==", "X86", "::", "TAILJMPm", ";", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "TFI", "->", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "X86::TAILJMPm64", "X86::TAILJMPm", "0", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "3", "3", "3" ]

[]

[ "<s>", "bool", "ThumbDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ")", "const", "{", "unsigned", "insn", "=", "0", ";", "uint16_t", "insn1", "=", "0", ";", "uint8_t", "bytes", "[", "2", "]", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "2", ",", "(", "uint8_t", "*", ")", "bytes", ",", "NULL", ")", "==", "-", "1", ")", "return", "false", ";", "insn", "=", "(", "bytes", "[", "1", "]", "<<", "8", ")", "|", "bytes", "[", "0", "]", ";", "unsigned", "bits15_11", "=", "slice", "(", "insn", ",", "15", ",", "11", ")", ";", "bool", "IsThumb2", "=", "false", ";", "if", "(", "bits15_11", "==", "0x1D", "||", "bits15_11", "==", "0x1E", "||", "bits15_11", "==", "0x1F", ")", "{", "IsThumb2", "=", "true", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", "+", "2", ",", "2", ",", "(", "uint8_t", "*", ")", "bytes", ",", "NULL", ")", "==", "-", "1", ")", "return", "false", ";", "insn1", "=", "(", "bytes", "[", "1", "]", "<<", "8", ")", "|", "bytes", "[", "0", "]", ";", "insn", "=", "(", "insn", "<<", "16", "|", "insn1", ")", ";", "}", "unsigned", "Opcode", "=", "decodeThumbSideEffect", "(", "IsThumb2", ",", "insn", ")", ";", "if", "(", "Thumb2PreloadOpcodeNoPCI", "(", "Opcode", ")", "&&", "slice", "(", "insn", ",", "19", ",", "16", ")", "==", "15", ")", "Opcode", "=", "T2Morph2Preload2PCI", "(", "Opcode", ")", ";", "ARMFormat", "Format", "=", "ARMFormats", "[", "Opcode", "]", ";", "Size", "=", "IsThumb2", "?", "4", ":", "2", ";", "DEBUG", "(", "{", "errs", "(", ")", "<<", "\"Opcode=\"", "<<", "Opcode", "<<", "\" Name=\"", "<<", "ARMUtils", "::", "OpcodeName", "(", "Opcode", ")", "<<", "\" Format=\"", "<<", "stringForARMFormat", "(", "Format", ")", "<<", "'('", "<<", "(", "int", ")", "Format", "<<", "\")\\n\"", ";", "showBitVector", "(", "errs", "(", ")", ",", "insn", ")", ";", "}", ")", ";", "ARMBasicMCBuilder", "*", "Builder", "=", "CreateMCBuilder", "(", "Opcode", ",", "Format", ")", ";", "if", "(", "!", "Builder", ")", "return", "false", ";", "Builder", "->", "SetSession", "(", "const_cast", "<", "Session", "*", ">", "(", "&", "SO", ")", ")", ";", "if", "(", "!", "Builder", "->", "Build", "(", "MI", ",", "insn", ")", ")", "return", "false", ";", "delete", "Builder", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "ARM", "0", "0", "2", "2", "1", "1", "8", "0", "15", "11", "0x1D", "0x1E", "0x1F", "2", "2", "1", "1", "8", "0", "16", "19", "16", "15", "ARM", "ARM", "4", "2", "\"Opcode=\"", "\" Name=\"", "ARMUtils::OpcodeName", "\" Format=\"", "ARM", "\")\\n\"", "ARM" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitLinkage", "(", "const", "GlobalValue", "*", "GV", ",", "MCSymbol", "*", "GVSym", ")", "const", "{", "assert", "(", "MAI", "->", "hasVisibilityOnlyWithLinkage", "(", ")", "&&", "\"AIX's linkage directives take a visibility setting.\"", ")", ";", "MCSymbolAttr", "LinkageAttr", "=", "MCSA_Invalid", ";", "switch", "(", "GV", "->", "getLinkage", "(", ")", ")", "{", "case", "GlobalValue", "::", "ExternalLinkage", ":", "LinkageAttr", "=", "GV", "->", "isDeclaration", "(", ")", "?", "MCSA_Extern", ":", "MCSA_Global", ";", "break", ";", "case", "GlobalValue", "::", "LinkOnceAnyLinkage", ":", "case", "GlobalValue", "::", "LinkOnceODRLinkage", ":", "case", "GlobalValue", "::", "WeakAnyLinkage", ":", "case", "GlobalValue", "::", "WeakODRLinkage", ":", "case", "GlobalValue", "::", "ExternalWeakLinkage", ":", "LinkageAttr", "=", "MCSA_Weak", ";", "break", ";", "case", "GlobalValue", "::", "AvailableExternallyLinkage", ":", "LinkageAttr", "=", "MCSA_Extern", ";", "break", ";", "case", "GlobalValue", "::", "PrivateLinkage", ":", "return", ";", "case", "GlobalValue", "::", "InternalLinkage", ":", "OutStreamer", "->", "emitSymbolAttribute", "(", "GVSym", ",", "MCSA_LGlobal", ")", ";", "return", ";", "case", "GlobalValue", "::", "AppendingLinkage", ":", "llvm_unreachable", "(", "\"Should never emit this\"", ")", ";", "case", "GlobalValue", "::", "CommonLinkage", ":", "llvm_unreachable", "(", "\"CommonLinkage of XCOFF should not come to this path\"", ")", ";", "}", "assert", "(", "LinkageAttr", "!=", "MCSA_Invalid", "&&", "\"LinkageAttr should not MCSA_Invalid.\"", ")", ";", "MCSymbolAttr", "VisibilityAttr", "=", "MCSA_Invalid", ";", "switch", "(", "GV", "->", "getVisibility", "(", ")", ")", "{", "case", "GlobalValue", "::", "DefaultVisibility", ":", "break", ";", "case", "GlobalValue", "::", "HiddenVisibility", ":", "VisibilityAttr", "=", "MAI", "->", "getHiddenVisibilityAttr", "(", ")", ";", "break", ";", "case", "GlobalValue", "::", "ProtectedVisibility", ":", "VisibilityAttr", "=", "MAI", "->", "getProtectedVisibilityAttr", "(", ")", ";", "break", ";", "}", "OutStreamer", "->", "emitXCOFFSymbolLinkageWithVisibility", "(", "GVSym", ",", "LinkageAttr", ",", "VisibilityAttr", ")", ";", "}", "</s>" ]

[ "This", "emits", "linkage", "information", "about", "GVSym", "based", "on", "GV", ",", "if", "this", "is", "supported", "by", "the", "target", "." ]

[ "PowerPC", "PPC", "\"AIX's linkage directives take a visibility setting.\"", "\"Should never emit this\"", "\"CommonLinkage of XCOFF should not come to this path\"", "\"LinkageAttr should not MCSA_Invalid.\"" ]

[]

[ "<s>", "unsigned", "X86AsmBackend", "::", "getMaximumNopSize", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "STI", ".", "hasFeature", "(", "X86", "::", "Mode16Bit", ")", ")", "return", "4", ";", "if", "(", "!", "STI", ".", "hasFeature", "(", "X86", "::", "FeatureNOPL", ")", "&&", "!", "STI", ".", "hasFeature", "(", "X86", "::", "Mode64Bit", ")", ")", "return", "1", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast7ByteNOP", "]", ")", "return", "7", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast15ByteNOP", "]", ")", "return", "15", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast11ByteNOP", "]", ")", "return", "11", ";", "return", "10", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "size", "of", "a", "nop", "in", "bytes", "on", "this", "target", "." ]

[ "X86", "X86", "X86::Mode16Bit", "4", "X86::FeatureNOPL", "X86::Mode64Bit", "1", "X86::TuningFast7ByteNOP", "7", "X86::TuningFast15ByteNOP", "15", "X86::TuningFast11ByteNOP", "11", "10" ]

[]

[ "<s>", "void", "LEGInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "LEG", "LEG" ]

[]

[ "<s>", "static", "int", "loongarch_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "generic_arg", ")", "{", "struct", "loongarch_arg_info", "arg", ";", "loongarch_get_arg_info", "(", "&", "arg", ",", "get_cumulative_args", "(", "cum", ")", ",", "generic_arg", ".", "mode", ",", "generic_arg", ".", "type", ",", "generic_arg", ".", "named", ",", "false", ")", ";", "return", "arg", ".", "stack_p", "?", "arg", ".", "num_gprs", "*", "UNITS_PER_WORD", ":", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ARG_PARTIAL_BYTES", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "bool", "RISCVAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "RISCVInstPrinter", "::", "printAddress", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "getImm", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "RISCV", "RISCV", "RISCV", "1" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "ProcessInstruction", "(", "Inst", ",", "Operands", ")", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "PPCOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"instruction use requires an option to be enabled\"", "\"unrecognized instruction mnemonic\"", "0U", "\"too few operands for instruction\"", "PPC", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "TargetTransformInfo", "AArch64TargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "AArch64TTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

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

[]

[ "<s>", "static", "rtx", "move_to_hl", "(", "int", "opno", ",", "rtx", "before", ")", "{", "rtx", "src", "=", "OP", "(", "opno", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "rtx", "reg", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "recog_data", ".", "operand_mode", "[", "opno", "]", ";", "reg", "=", "(", "mode", "==", "QImode", ")", "?", "L", ":", "HL", ";", "if", "(", "mode", "==", "QImode", "||", "!", "is_virtual_register", "(", "OP", "(", "opno", ")", ")", ")", "{", "OP", "(", "opno", ")", "=", "move_to_acc", "(", "opno", ",", "before", ")", ";", "OP", "(", "opno", ")", "=", "move_acc_to_reg", "(", "OP", "(", "opno", ")", ",", "L_REG", ",", "before", ")", ";", "return", "reg", ";", "}", "return", "gen_and_emit_move", "(", "reg", ",", "src", ",", "before", ",", "true", ")", ";", "}", "</s>" ]

[ "Copy", "OP", "(", "opno", ")", "to", "H", "or", "HL", ",", "placing", "any", "generated", "insns", "before", "BEFORE", ".", "Returns", "H/HL", "RTX", "." ]

[ "rl78" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "enum", "reg_class", "rs6000_secondary_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "rtx", "in", ")", "{", "int", "regno", ";", "if", "(", "TARGET_ELF", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "MACHOPIC_INDIRECT", ")", ")", "{", "if", "(", "rclass", "!=", "BASE_REGS", "&&", "(", "SYMBOL_REF_P", "(", "in", ")", "||", "GET_CODE", "(", "in", ")", "==", "HIGH", "||", "GET_CODE", "(", "in", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "in", ")", "==", "CONST", ")", ")", "return", "BASE_REGS", ";", "}", "if", "(", "REG_P", "(", "in", ")", ")", "{", "regno", "=", "REGNO", "(", "in", ")", ";", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "regno", "=", "-", "1", ";", "}", "}", "else", "if", "(", "SUBREG_P", "(", "in", ")", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "regno", "=", "-", "1", ";", "}", "else", "regno", "=", "-", "1", ";", "if", "(", "TARGET_VSX", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "16", "&&", "!", "mode_supports_vmx_dform", "(", "mode", ")", "&&", "(", "(", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", ")", "&&", "(", "regno", ">=", "0", "&&", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", ")", "||", "(", "(", "rclass", "==", "VSX_REGS", "||", "rclass", "==", "ALTIVEC_REGS", ")", "&&", "(", "regno", ">=", "0", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", ")", ")", "return", "FLOAT_REGS", ";", "if", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", "||", "(", "regno", ">=", "0", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "rclass", "==", "VSX_REGS", "&&", "(", "regno", "==", "-", "1", "||", "VSX_REGNO_P", "(", "regno", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "(", "regno", "==", "-", "1", "||", "FP_REGNO_P", "(", "regno", ")", ")", "&&", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "GEN_OR_FLOAT_REGS", ")", ")", "return", "(", "mode", "!=", "SDmode", "||", "lra_in_progress", ")", "?", "NO_REGS", ":", "GENERAL_REGS", ";", "if", "(", "(", "regno", "==", "-", "1", "||", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "&&", "rclass", "==", "ALTIVEC_REGS", ")", "return", "NO_REGS", ";", "if", "(", "(", "rclass", "==", "CR_REGS", "||", "rclass", "==", "CR0_REGS", ")", "&&", "regno", ">=", "0", "&&", "CR_REGNO_P", "(", "regno", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "of", "a", "scratch", "register", "needed", "to", "copy", "IN", "into", "or", "out", "of", "a", "register", "in", "RCLASS", "in", "MODE", ".", "If", "it", "can", "be", "done", "directly", ",", "NO_REGS", "is", "returned", "." ]

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

[]

[ "<s>", "bool", "FixAllFDIVSQRT", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "for", "(", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "MI", ".", "isInlineAsm", "(", ")", ")", "{", "std", "::", "string", "AsmString", "(", "MI", ".", "getOperand", "(", "InlineAsm", "::", "MIOp_AsmString", ")", ".", "getSymbolName", "(", ")", ")", ";", "std", "::", "string", "FSQRTDOpCode", "(", "\"fsqrtd\"", ")", ";", "std", "::", "string", "FDIVDOpCode", "(", "\"fdivd\"", ")", ";", "std", "::", "transform", "(", "AsmString", ".", "begin", "(", ")", ",", "AsmString", ".", "end", "(", ")", ",", "AsmString", ".", "begin", "(", ")", ",", "::", "tolower", ")", ";", "if", "(", "AsmString", ".", "find", "(", "FSQRTDOpCode", ")", "==", "0", ")", "{", "Opcode", "=", "SP", "::", "FSQRTD", ";", "}", "else", "if", "(", "AsmString", ".", "find", "(", "FDIVDOpCode", ")", "==", "0", ")", "{", "Opcode", "=", "SP", "::", "FDIVD", ";", "}", "}", "if", "(", "Opcode", "==", "SP", "::", "FSQRTD", "||", "Opcode", "==", "SP", "::", "FDIVD", ")", "{", "for", "(", "int", "InsertedCount", "=", "0", ";", "InsertedCount", "<", "5", ";", "InsertedCount", "++", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "SP", "::", "NOP", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "NMBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "for", "(", "int", "InsertedCount", "=", "0", ";", "InsertedCount", "<", "28", ";", "InsertedCount", "++", ")", "BuildMI", "(", "MBB", ",", "NMBBI", ",", "DL", ",", "TII", ".", "get", "(", "SP", "::", "NOP", ")", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"fsqrtd\"", "\"fdivd\"", "0", "SP::FSQRTD", "0", "SP::FDIVD", "SP::FSQRTD", "SP::FDIVD", "0", "5", "SP::NOP", "0", "28", "SP::NOP" ]

[]

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

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "UPT", "UPT" ]

[]

[ "<s>", "static", "SDValue", "getTargetNode", "(", "ExternalSymbolSDNode", "*", "N", ",", "SDLoc", "DL", ",", "EVT", "Ty", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flags", ")", "{", "return", "DAG", ".", "getTargetExternalSymbol", "(", "N", "->", "getSymbol", "(", ")", ",", "Ty", ",", "Flags", ")", ";", "}", "</s>" ]

[ "Retrieve", "the", "target", "node", "this", "edge", "connects", "to", "." ]

[ "RISCV" ]

[]

[ "<s>", "SDValue", "PTXTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isVarArg", ")", "llvm_unreachable", "(", "\"PTX does not support varargs\"", ")", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention.\"", ")", ";", "case", "CallingConv", "::", "PTX_Kernel", ":", "assert", "(", "Outs", ".", "size", "(", ")", "==", "0", "&&", "\"Kernel must return void.\"", ")", ";", "return", "DAG", ".", "getNode", "(", "PTXISD", "::", "EXIT", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "case", "CallingConv", "::", "PTX_Device", ":", "assert", "(", "Outs", ".", "size", "(", ")", "<=", "1", "&&", "\"Can at most return one value.\"", ")", ";", "break", ";", "}", "if", "(", "Outs", ".", "size", "(", ")", "==", "0", ")", "return", "DAG", ".", "getNode", "(", "PTXISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SDValue", "Flag", ";", "unsigned", "reg", ";", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "i16", ")", "{", "reg", "=", "PTX", "::", "RH0", ";", "}", "else", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "i32", ")", "{", "reg", "=", "PTX", "::", "R0", ";", "}", "else", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "i64", ")", "{", "reg", "=", "PTX", "::", "RD0", ";", "}", "else", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "f32", ")", "{", "reg", "=", "PTX", "::", "F0", ";", "}", "else", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "f64", ")", "{", "reg", "=", "PTX", "::", "FD0", ";", "}", "else", "{", "assert", "(", "false", "&&", "\"Can return only basic types\"", ")", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "PTXMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "PTXMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setRetReg", "(", "reg", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "reg", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "reg", ",", "OutVals", "[", "0", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "return", "DAG", ".", "getNode", "(", "PTXISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "ISD::OutputArg", "\"PTX does not support varargs\"", "\"Unsupported calling convention.\"", "PTX", "0", "\"Kernel must return void.\"", "PTXISD::EXIT", "MVT::Other", "PTX", "1", "\"Can at most return one value.\"", "0", "PTXISD::RET", "MVT::Other", "0", "MVT::i16", "PTX::RH0", "0", "MVT::i32", "PTX::R0", "0", "MVT::i64", "PTX::RD0", "0", "MVT::f32", "PTX::F0", "0", "MVT::f64", "PTX::FD0", "\"Can return only basic types\"", "PTX", "PTX", "0", "1", "PTXISD::RET", "MVT::Other" ]

[]

[ "<s>", "auto", "HexagonVectorCombine", "::", "getSizeOf", "(", "const", "Type", "*", "Ty", ")", "const", "->", "int", "{", "return", "DL", ".", "getTypeStoreSize", "(", "const_cast", "<", "Type", "*", ">", "(", "Ty", ")", ")", ".", "getFixedValue", "(", ")", ";", "}", "</s>" ]

[ "getSizeOf", "constant", "expr", "-", "computes", "the", "(", "alloc", ")", "size", "of", "a", "type", "(", "in", "address-units", ",", "not", "bits", ")", "in", "a", "target", "independent", "way", "(", "Note", ":", "the", "return", "type", "is", "an", "i64", ")", "." ]

[ "Hexagon", "HexagonVectorCombine::getSizeOf" ]

[]

[ "<s>", "enum", "reg_class", "coproc_secondary_reload_class", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "wb", ")", "{", "if", "(", "mode", "==", "HFmode", ")", "{", "if", "(", "!", "TARGET_NEON_FP16", ")", "return", "GENERAL_REGS", ";", "if", "(", "s_register_operand", "(", "x", ",", "mode", ")", "||", "neon_vector_mem_operand", "(", "x", ",", "2", ",", "true", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "if", "(", "TARGET_NEON", "&&", "(", "MEM_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "&&", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", "||", "VALID_NEON_STRUCT_MODE", "(", "mode", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "arm_coproc_mem_operand", "(", "x", ",", "wb", ")", "||", "s_register_operand", "(", "x", ",", "mode", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "GENERAL_REGS", "if", "a", "scratch", "register", "required", "to", "reload", "x", "to/from", "coprocessor", "registers", ".", "Otherwise", "return", "NO_REGS", "." ]

[ "arm", "2" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "RTB", "=", "DAG", ".", "getNode", "(", "PPCISD", "::", "READ_TIME_BASE", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "RTB", ")", ";", "Results", ".", "push_back", "(", "RTB", ".", "getValue", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "RTB", ".", "getValue", "(", "2", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", "!=", "Intrinsic", "::", "ppc_is_decremented_ctr_nonzero", ")", "break", ";", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", "&&", "\"Unexpected result type for CTR decrement intrinsic\"", ")", ";", "EVT", "SVT", "=", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "N", "->", "getValueType", "(", "0", ")", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "SVT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "NewInt", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i1", ",", "NewInt", ")", ")", ";", "Results", ".", "push_back", "(", "NewInt", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "VAARG", ":", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "{", "SDValue", "NewNode", "=", "LowerVAARG", "(", "SDValue", "(", "N", ",", "1", ")", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "NewNode", ")", ";", "Results", ".", "push_back", "(", "NewNode", ".", "getValue", "(", "1", ")", ")", ";", "}", "return", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "ppcf128", ")", "return", ";", "Results", ".", "push_back", "(", "LowerFP_TO_INT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "dl", ")", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Do not know how to custom type legalize this operation!\"", "ISD::READCYCLECOUNTER", "MVT::i32", "MVT::i32", "MVT::Other", "PPCISD::READ_TIME_BASE", "0", "1", "2", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ppc_is_decremented_ctr_nonzero", "0", "MVT::i1", "\"Unexpected result type for CTR decrement intrinsic\"", "0", "MVT::Other", "0", "1", "ISD::TRUNCATE", "MVT::i1", "1", "ISD::VAARG", "PPC", "0", "MVT::i64", "1", "1", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "0", "MVT::ppcf128", "0" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getNumMicroOps", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "1", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "Class", "=", "Desc", ".", "getSchedClass", "(", ")", ";", "unsigned", "UOps", "=", "ItinData", "->", "Itineraries", "[", "Class", "]", ".", "NumMicroOps", ";", "if", "(", "UOps", ")", "return", "UOps", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected multi-uops instruction!\"", ")", ";", "case", "ARM", "::", "VLDMQIA", ":", "case", "ARM", "::", "VSTMQIA", ":", "return", "2", ";", "case", "ARM", "::", "VLDMDIA", ":", "case", "ARM", "::", "VLDMDIA_UPD", ":", "case", "ARM", "::", "VLDMDDB_UPD", ":", "case", "ARM", "::", "VLDMSIA", ":", "case", "ARM", "::", "VLDMSIA_UPD", ":", "case", "ARM", "::", "VLDMSDB_UPD", ":", "case", "ARM", "::", "VSTMDIA", ":", "case", "ARM", "::", "VSTMDIA_UPD", ":", "case", "ARM", "::", "VSTMDDB_UPD", ":", "case", "ARM", "::", "VSTMSIA", ":", "case", "ARM", "::", "VSTMSIA_UPD", ":", "case", "ARM", "::", "VSTMSDB_UPD", ":", "{", "unsigned", "NumRegs", "=", "MI", "->", "getNumOperands", "(", ")", "-", "Desc", ".", "getNumOperands", "(", ")", ";", "return", "(", "NumRegs", "/", "2", ")", "+", "(", "NumRegs", "%", "2", ")", "+", "1", ";", "}", "case", "ARM", "::", "LDMIA_RET", ":", "case", "ARM", "::", "LDMIA", ":", "case", "ARM", "::", "LDMDA", ":", "case", "ARM", "::", "LDMDB", ":", "case", "ARM", "::", "LDMIB", ":", "case", "ARM", "::", "LDMIA_UPD", ":", "case", "ARM", "::", "LDMDA_UPD", ":", "case", "ARM", "::", "LDMDB_UPD", ":", "case", "ARM", "::", "LDMIB_UPD", ":", "case", "ARM", "::", "STMIA", ":", "case", "ARM", "::", "STMDA", ":", "case", "ARM", "::", "STMDB", ":", "case", "ARM", "::", "STMIB", ":", "case", "ARM", "::", "STMIA_UPD", ":", "case", "ARM", "::", "STMDA_UPD", ":", "case", "ARM", "::", "STMDB_UPD", ":", "case", "ARM", "::", "STMIB_UPD", ":", "case", "ARM", "::", "tLDMIA", ":", "case", "ARM", "::", "tLDMIA_UPD", ":", "case", "ARM", "::", "tSTMIA_UPD", ":", "case", "ARM", "::", "tPOP_RET", ":", "case", "ARM", "::", "tPOP", ":", "case", "ARM", "::", "tPUSH", ":", "case", "ARM", "::", "t2LDMIA_RET", ":", "case", "ARM", "::", "t2LDMIA", ":", "case", "ARM", "::", "t2LDMDB", ":", "case", "ARM", "::", "t2LDMIA_UPD", ":", "case", "ARM", "::", "t2LDMDB_UPD", ":", "case", "ARM", "::", "t2STMIA", ":", "case", "ARM", "::", "t2STMDB", ":", "case", "ARM", "::", "t2STMIA_UPD", ":", "case", "ARM", "::", "t2STMDB_UPD", ":", "{", "unsigned", "NumRegs", "=", "MI", "->", "getNumOperands", "(", ")", "-", "Desc", ".", "getNumOperands", "(", ")", "+", "1", ";", "if", "(", "Subtarget", ".", "isCortexA8", "(", ")", ")", "{", "if", "(", "NumRegs", "<", "4", ")", "return", "2", ";", "UOps", "=", "(", "NumRegs", "/", "2", ")", ";", "if", "(", "NumRegs", "%", "2", ")", "++", "UOps", ";", "return", "UOps", ";", "}", "else", "if", "(", "Subtarget", ".", "isCortexA9", "(", ")", ")", "{", "UOps", "=", "(", "NumRegs", "/", "2", ")", ";", "if", "(", "(", "NumRegs", "%", "2", ")", "||", "!", "MI", "->", "hasOneMemOperand", "(", ")", "||", "(", "*", "MI", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", "<", "8", ")", "++", "UOps", ";", "return", "UOps", ";", "}", "else", "{", "return", "NumRegs", ";", "}", "}", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "issue", "slots", "required", "for", "this", "MI", "." ]

[ "ARM", "ARM", "1", "\"Unexpected multi-uops instruction!\"", "ARM::VLDMQIA", "ARM::VSTMQIA", "2", "ARM::VLDMDIA", "ARM::VLDMDIA_UPD", "ARM::VLDMDDB_UPD", "ARM::VLDMSIA", "ARM::VLDMSIA_UPD", "ARM::VLDMSDB_UPD", "ARM::VSTMDIA", "ARM::VSTMDIA_UPD", "ARM::VSTMDDB_UPD", "ARM::VSTMSIA", "ARM::VSTMSIA_UPD", "ARM::VSTMSDB_UPD", "2", "2", "1", "ARM::LDMIA_RET", "ARM::LDMIA", "ARM::LDMDA", "ARM::LDMDB", "ARM::LDMIB", "ARM::LDMIA_UPD", "ARM::LDMDA_UPD", "ARM::LDMDB_UPD", "ARM::LDMIB_UPD", "ARM::STMIA", "ARM::STMDA", "ARM::STMDB", "ARM::STMIB", "ARM::STMIA_UPD", "ARM::STMDA_UPD", "ARM::STMDB_UPD", "ARM::STMIB_UPD", "ARM::tLDMIA", "ARM::tLDMIA_UPD", "ARM::tSTMIA_UPD", "ARM::tPOP_RET", "ARM::tPOP", "ARM::tPUSH", "ARM::t2LDMIA_RET", "ARM::t2LDMIA", "ARM::t2LDMDB", "ARM::t2LDMIA_UPD", "ARM::t2LDMDB_UPD", "ARM::t2STMIA", "ARM::t2STMDB", "ARM::t2STMIA_UPD", "ARM::t2STMDB_UPD", "1", "4", "2", "2", "2", "2", "2", "8" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARMOperand", "&", "Op", "=", "static_cast", "<", "ARMOperand", "&", ">", "(", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK__35_0", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "0", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK_ModImm", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "const", "MCExpr", "*", "SOExpr", "=", "Op", ".", "getImm", "(", ")", ";", "int64_t", "Value", ";", "if", "(", "!", "SOExpr", "->", "evaluateAsAbsolute", "(", "Value", ")", ")", "return", "Match_Success", ";", "assert", "(", "(", "Value", ">=", "INT32_MIN", "&&", "Value", "<=", "UINT32_MAX", ")", "&&", "\"expression value must be representable in 32 bits\"", ")", ";", "}", "break", ";", "case", "MCK_rGPR", ":", "if", "(", "hasV8Ops", "(", ")", "&&", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK_GPRPair", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "MRI", "->", "getRegClass", "(", "ARM", "::", "GPRRegClassID", ")", ".", "contains", "(", "Op", ".", "getReg", "(", ")", ")", ")", "return", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "\"expression value must be representable in 32 bits\"", "ARM::SP", "ARM::GPRRegClassID" ]

[]

[ "<s>", "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "AArch64" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "OR1KTargetMachine", "*", "TM", "=", "static_cast", "<", "const", "OR1KTargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "if", "(", "TM", "->", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "false", ";", "OR1KMachineFunctionInfo", "*", "OR1KFI", "=", "MF", ".", "getInfo", "<", "OR1KMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "OR1KFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "OR1KInstrInfo", "*", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "unsigned", "Scratch1", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "OR1K", "::", "GPRRegClass", ")", ";", "unsigned", "Scratch2", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "OR1K", "::", "GPRRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "OR1K", "::", "GETPC", ")", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "OR1K", "::", "MOVHI", ")", ",", "Scratch1", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "OR1KII", "::", "MO_GOTPCHI", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "OR1K", "::", "ORI", ")", ",", "Scratch2", ")", ".", "addReg", "(", "Scratch1", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "OR1KII", "::", "MO_GOTPCLO", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "OR1K", "::", "ADD", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "OR1K", "::", "R9", ")", ".", "addReg", "(", "Scratch2", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K", "OR1K", "OR1K", "OR1K", "OR1K", "0", "OR1K", "OR1K::GPRRegClass", "OR1K::GPRRegClass", "OR1K::GETPC", "0", "OR1K::MOVHI", "\"_GLOBAL_OFFSET_TABLE_\"", "OR1KII::MO_GOTPCHI", "OR1K::ORI", "\"_GLOBAL_OFFSET_TABLE_\"", "OR1KII::MO_GOTPCLO", "OR1K::ADD", "OR1K::R9" ]

[]

[ "<s>", "bool", "ARM64PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createARM64ISelDag", "(", "getARM64TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "TM", "->", "getSubtarget", "<", "ARM64Subtarget", ">", "(", ")", ".", "isTargetELF", "(", ")", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARM64CleanupLocalDynamicTLSPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "ARM64", "ARM64", "ARM64", "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "static", "bool", "loongarch_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "args", ";", "cumulative_args_t", "cum", "=", "pack_cumulative_args", "(", "&", "args", ")", ";", "memset", "(", "&", "args", ",", "0", ",", "sizeof", "(", "args", ")", ")", ";", "function_arg_info", "arg", "(", "const_cast", "<", "tree", ">", "(", "type", ")", ",", "true", ")", ";", "return", "loongarch_pass_by_reference", "(", "cum", ",", "arg", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_RETURN_IN_MEMORY", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "static", "reg_class_t", "c6x_preferred_rename_class", "(", "reg_class_t", "cl", ")", "{", "if", "(", "cl", "==", "A_REGS", ")", "return", "NONPREDICATE_A_REGS", ";", "if", "(", "cl", "==", "B_REGS", ")", "return", "NONPREDICATE_B_REGS", ";", "if", "(", "cl", "==", "ALL_REGS", "||", "cl", "==", "GENERAL_REGS", ")", "return", "NONPREDICATE_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implements", "TARGET_PREFERRED_RENAME_CLASS", "." ]

[ "c6x" ]

[]

[ "<s>", "bool", "SPUTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "const", "Type", "*", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "AM", ".", "BaseOffs", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "BaseGV", "==", "0", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "isInt", "<", "14", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "true", ";", "if", "(", "AM", ".", "BaseGV", "==", "0", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "BaseOffs", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "CellSPU", "SPU", "0", "0", "0", "0", "14", "0", "1", "0" ]

[]

[ "<s>", "SDValue", "Z80oldTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "getRetCCAssignFn", "(", "CallConv", ")", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "RVLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "I", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "I", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Z80old", "Z80old", "ISD::InputArg", "16", "0", "1", "2", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_reads_global_state_p", "(", "unsigned", "int", "f", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "flags", "=", "aarch64_call_properties", "(", "f", ",", "mode", ")", ";", "if", "(", "flags", "&", "FLAG_READ_FPCR", ")", "return", "true", ";", "return", "flags", "&", "FLAG_READ_MEMORY", ";", "}", "</s>" ]

[ "Return", "true", "if", "calls", "to", "the", "function", "could", "read", "some", "form", "of", "global", "state", "." ]

[ "aarch64" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86InstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "TargetCostInfo", "&", "TCI", ")", "const", "{", "if", "(", "TCI", ".", "CallConstructionID", "==", "MachineOutlinerTailCall", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "}", "else", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "X86", "::", "CALL64pcrel32", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "}", "return", "It", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

[ "X86", "X86", "X86::JMP_1", "X86::CALL64pcrel32" ]

[]

[ "<s>", "bool", "TPCRegisterInfo", "::", "isConstantPhysReg", "(", "unsigned", "PhysReg", ")", "const", "{", "return", "PhysReg", "==", "TPC", "::", "SP0", "||", "PhysReg", "==", "TPC", "::", "VP0", "||", "PhysReg", "==", "TPC", "::", "V_LANE_ID_32", "||", "PhysReg", "==", "TPC", "::", "V_LANE_ID_16", "||", "PhysReg", "==", "TPC", "::", "V_LANE_ID_8", ";", "}", "</s>" ]

[ "Returns", "true", "if", "PhysReg", "is", "unallocatable", "and", "constant", "throughout", "the", "function", "." ]

[ "TPC", "TPC", "TPC::SP0", "TPC::VP0", "TPC::V_LANE_ID_32", "TPC::V_LANE_ID_16", "TPC::V_LANE_ID_8" ]

[]

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

[ "Do", "not", "merge", "vector", "stores", "after", "legalization", "because", "that", "may", "conflict", "with", "x86-specific", "store", "splitting", "optimizations", "." ]

[ "X86" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_RegMask", ";", "else", "return", "CSR_AArch64_AAPCS_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

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

[]

[ "<s>", "int", "ARMBaseRegisterInfo", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "return", "ResolveFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ",", "0", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

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

[]

[ "<s>", "int", "neon_vector_mem_operand", "(", "rtx", "op", ",", "int", "type", ",", "bool", "strict", ")", "{", "rtx", "ind", ";", "if", "(", "strict", "&&", "!", "(", "reload_in_progress", "||", "reload_completed", ")", "&&", "(", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "arg_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_incoming_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_outgoing_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_dynamic_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_vars_rtx", ",", "op", ")", ")", ")", "return", "FALSE", ";", "if", "(", "!", "MEM_P", "(", "op", ")", ")", "return", "FALSE", ";", "ind", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "reload_completed", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "ind", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "TRUE", ";", "if", "(", "REG_P", "(", "ind", ")", ")", "return", "arm_address_register_rtx_p", "(", "ind", ",", "0", ")", ";", "if", "(", "(", "type", "!=", "1", "&&", "GET_CODE", "(", "ind", ")", "==", "POST_INC", ")", "||", "(", "type", "==", "0", "&&", "GET_CODE", "(", "ind", ")", "==", "PRE_DEC", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ";", "if", "(", "type", "==", "2", "&&", "GET_CODE", "(", "ind", ")", "==", "POST_MODIFY", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "1", ")", ",", "1", ")", ")", ")", "return", "true", ";", "if", "(", "type", "==", "0", "&&", "GET_CODE", "(", "ind", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "&&", "REG_MODE_OK_FOR_BASE_P", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "VOIDmode", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", ">", "-", "1024", "&&", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "<", "(", "VALID_NEON_QREG_MODE", "(", "GET_MODE", "(", "op", ")", ")", "?", "1016", ":", "1024", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "&", "3", ")", "==", "0", ")", "return", "TRUE", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "a", "memory", "operand", "which", "we", "can", "load", "or", "store", "a", "vector", "to/from", ".", "TYPE", "is", "one", "of", "the", "following", "values", ":", "0", "-", "Vector", "load/stor", "(", "vldr", ")", "1", "-", "Core", "registers", "(", "ldm", ")", "2", "-", "Element/structure", "loads", "(", "vld1", ")" ]

[ "arm", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "0", "2", "1", "1", "1", "0", "0", "0", "1", "1", "1024", "1", "1016", "1024", "1", "3", "0" ]

[]

[ "<s>", "unsigned", "postOffset", "(", "unsigned", "LogAlign", "=", "0", ")", "const", "{", "unsigned", "PO", "=", "Offset", "+", "Size", ";", "unsigned", "LA", "=", "std", "::", "max", "(", "unsigned", "(", "PostAlign", ")", ",", "LogAlign", ")", ";", "if", "(", "!", "LA", ")", "return", "PO", ";", "return", "PO", "+", "UnknownPadding", "(", "LA", ",", "internalKnownBits", "(", ")", ")", ";", "}", "</s>" ]

[ "Compute", "the", "offset", "immediately", "following", "this", "block", "." ]

[ "ARM", "0" ]

[]

[ "<s>", "unsigned", "AArch64FastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "const", "auto", "*", "CPN", "=", "dyn_cast", "<", "ConstantPointerNull", ">", "(", "C", ")", ")", "{", "(", "void", ")", "CPN", ";", "assert", "(", "CPN", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", "==", "0", "&&", "\"Unexpected address space\"", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Expected 64-bit pointers\"", ")", ";", "return", "materializeInt", "(", "ConstantInt", "::", "get", "(", "Type", "::", "getInt64Ty", "(", "*", "Context", ")", ",", "0", ")", ",", "VT", ")", ";", "}", "if", "(", "const", "auto", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "materializeInt", "(", "CI", ",", "VT", ")", ";", "else", "if", "(", "const", "ConstantFP", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "materializeFP", "(", "CFP", ",", "VT", ")", ";", "else", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "materializeGV", "(", "GV", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Emit", "a", "constant", "in", "a", "register", "using", "target-specific", "logic", ",", "such", "as", "constant", "pool", "loads", "." ]

[ "AArch64", "AArch64", "0", "0", "\"Unexpected address space\"", "MVT::i64", "\"Expected 64-bit pointers\"", "0", "0" ]

[]

[ "<s>", "static", "enum", "attr_type", "s390_safe_attr_type", "(", "rtx", "insn", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "return", "get_attr_type", "(", "insn", ")", ";", "else", "return", "TYPE_NONE", ";", "}", "</s>" ]

[ "Return", "attribute", "type", "of", "insn", "." ]

[ "s390", "0" ]

[]

[ "<s>", "bool", "HexagonPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "FailsVerification", ")", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "HII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "*", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "auto", "*", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "if", "(", "EnableGenAllInsnClass", ")", "HII", "->", "genAllInsnTimingClasses", "(", "MF", ")", ";", "bool", "MinOnly", "=", "Minimal", "||", "DisablePacketizer", "||", "!", "HST", ".", "usePackets", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "HexagonPacketizerList", "Packetizer", "(", "MF", ",", "MLI", ",", "AA", ",", "MBPI", ",", "MinOnly", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineBasicBlock", "&", "MB", ":", "MF", ")", "{", "auto", "End", "=", "MB", ".", "end", "(", ")", ";", "auto", "MI", "=", "MB", ".", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "auto", "NextI", "=", "std", "::", "next", "(", "MI", ")", ";", "if", "(", "MI", "->", "isKill", "(", ")", ")", "{", "MB", ".", "erase", "(", "MI", ")", ";", "End", "=", "MB", ".", "end", "(", ")", ";", "}", "MI", "=", "NextI", ";", "}", "}", "if", "(", "HST", ".", "isTinyCoreWithDuplex", "(", ")", ")", "HII", "->", "translateInstrsForDup", "(", "MF", ",", "true", ")", ";", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "Begin", "=", "MB", ".", "begin", "(", ")", ",", "End", "=", "MB", ".", "end", "(", ")", ";", "while", "(", "Begin", "!=", "End", ")", "{", "MachineBasicBlock", "::", "iterator", "RB", "=", "Begin", ";", "while", "(", "RB", "!=", "End", "&&", "HII", "->", "isSchedulingBoundary", "(", "*", "RB", ",", "&", "MB", ",", "MF", ")", ")", "++", "RB", ";", "MachineBasicBlock", "::", "iterator", "RE", "=", "RB", ";", "while", "(", "RE", "!=", "End", "&&", "!", "HII", "->", "isSchedulingBoundary", "(", "*", "RE", ",", "&", "MB", ",", "MF", ")", ")", "++", "RE", ";", "if", "(", "RE", "!=", "End", ")", "++", "RE", ";", "if", "(", "RB", "!=", "End", ")", "Packetizer", ".", "PacketizeMIs", "(", "&", "MB", ",", "RB", ",", "RE", ")", ";", "Begin", "=", "RE", ";", "}", "}", "if", "(", "HST", ".", "isTinyCoreWithDuplex", "(", ")", ")", "HII", "->", "translateInstrsForDup", "(", "MF", ",", "false", ")", ";", "Packetizer", ".", "unpacketizeSoloInstrs", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Empty DFA table!\"" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "REG_P", "(", "x", ")", ")", "fprintf", "(", "file", ",", "\"0(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "else", "if", "(", "SYMBOL_REF_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "output_addr_const", "(", "file", ",", "x", ")", ";", "if", "(", "small_data_operand", "(", "x", ",", "GET_MODE", "(", "x", ")", ")", ")", "fprintf", "(", "file", ",", "\"@%s(%s)\"", ",", "SMALL_DATA_RELOC", ",", "reg_names", "[", "SMALL_DATA_REG", "]", ")", ";", "else", "gcc_assert", "(", "!", "TARGET_TOC", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "if", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "0", ")", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "1", ")", ")", "]", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "1", ")", ")", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"(%s)\"", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "fprintf", "(", "file", ",", "\"lo16(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\")(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\"@l(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "if", "(", "toc_relative_expr_p", "(", "x", ",", "false", ",", "&", "tocrel_base_oac", ",", "&", "tocrel_offset_oac", ")", ")", "{", "output_addr_const", "(", "file", ",", "CONST_CAST_RTX", "(", "tocrel_base_oac", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "fprintf", "(", "file", ",", "\"@l(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XVECEXP", "(", "tocrel_base_oac", ",", "0", ",", "1", ")", ")", "]", ")", ";", "}", "else", "output_addr_const", "(", "file", ",", "x", ")", ";", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "rs6000", "\"0(%s)\"", "\"@%s(%s)\"", "0", "1", "0", "0", "\"%s,%s\"", "1", "0", "\"%s,%s\"", "0", "1", "0", "1", "\"(%s)\"", "1", "0", "0", "1", "\"lo16(\"", "1", "\")(%s)\"", "0", "0", "1", "1", "\"@l(%s)\"", "0", "\"@l(%s)\"", "0", "\"(%s)\"", "0", "1" ]

[]

[ "<s>", "void", "aarch64_expand_mov_immediate", "(", "rtx", "dest", ",", "rtx", "imm", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", ";", "if", "(", "GET_CODE", "(", "imm", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "imm", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "imm", ")", "==", "CONST", ")", "{", "rtx", "mem", ",", "base", ",", "offset", ";", "enum", "aarch64_symbol_type", "sty", ";", "split_const", "(", "imm", ",", "&", "base", ",", "&", "offset", ")", ";", "sty", "=", "aarch64_classify_symbol", "(", "base", ",", "offset", ")", ";", "switch", "(", "sty", ")", "{", "case", "SYMBOL_FORCE_TO_MEM", ":", "if", "(", "offset", "!=", "const0_rtx", "&&", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "imm", ")", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "base", "=", "aarch64_force_temporary", "(", "mode", ",", "dest", ",", "base", ")", ";", "base", "=", "aarch64_add_offset", "(", "mode", ",", "NULL", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "aarch64_emit_move", "(", "dest", ",", "base", ")", ";", "return", ";", "}", "mem", "=", "force_const_mem", "(", "ptr_mode", ",", "imm", ")", ";", "gcc_assert", "(", "mem", ")", ";", "if", "(", "!", "aarch64_pcrelative_literal_loads", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "base", "=", "gen_reg_rtx", "(", "ptr_mode", ")", ";", "aarch64_expand_mov_immediate", "(", "base", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "ptr_mode", ",", "base", ")", ";", "}", "if", "(", "mode", "!=", "ptr_mode", ")", "mem", "=", "gen_rtx_ZERO_EXTEND", "(", "mode", ",", "mem", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "mem", ")", ")", ";", "return", ";", "case", "SYMBOL_SMALL_TLSGD", ":", "case", "SYMBOL_SMALL_TLSDESC", ":", "case", "SYMBOL_SMALL_TLSIE", ":", "case", "SYMBOL_SMALL_GOT_28K", ":", "case", "SYMBOL_SMALL_GOT_4G", ":", "case", "SYMBOL_TINY_GOT", ":", "case", "SYMBOL_TINY_TLSIE", ":", "if", "(", "offset", "!=", "const0_rtx", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "base", "=", "aarch64_force_temporary", "(", "mode", ",", "dest", ",", "base", ")", ";", "base", "=", "aarch64_add_offset", "(", "mode", ",", "NULL", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "aarch64_emit_move", "(", "dest", ",", "base", ")", ";", "return", ";", "}", "case", "SYMBOL_SMALL_ABSOLUTE", ":", "case", "SYMBOL_TINY_ABSOLUTE", ":", "case", "SYMBOL_TLSLE12", ":", "case", "SYMBOL_TLSLE24", ":", "case", "SYMBOL_TLSLE32", ":", "case", "SYMBOL_TLSLE48", ":", "aarch64_load_symref_appropriately", "(", "dest", ",", "imm", ",", "sty", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "!", "CONST_INT_P", "(", "imm", ")", ")", "{", "if", "(", "GET_CODE", "(", "imm", ")", "==", "HIGH", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "imm", ")", ")", ";", "else", "{", "rtx", "mem", "=", "force_const_mem", "(", "mode", ",", "imm", ")", ";", "gcc_assert", "(", "mem", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "mem", ")", ")", ";", "}", "return", ";", "}", "aarch64_internal_mov_immediate", "(", "dest", ",", "imm", ",", "true", ",", "GET_MODE", "(", "dest", ")", ")", ";", "}", "</s>" ]

[ "Set", "DEST", "to", "immediate", "IMM", ".", "For", "SVE", "vector", "modes", ",", "GEN_VEC_DUPLICATE", "is", "a", "pattern", "that", "can", "be", "used", "to", "set", "DEST", "to", "a", "replicated", "scalar", "element", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDValue", "Callee", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Hexagon", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Hexagon", "Hexagon", "ISD::InputArg", "16", "Hexagon", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "ARM", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "Register", "::", "isVirtualRegister", "(", "DestReg", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "DestReg", ",", "&", "ARM", "::", "GPRPairnospRegClass", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_0", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_1", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "if", "(", "Register", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "ARM", "ARM::GPRRegClass", "ARM::t2LDRi12", "0", "ARMCC::AL", "ARM::GPRPairRegClass", "ARM::GPRPairnospRegClass", "ARM::t2LDRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "ARMCC::AL", "ARM" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "removeDeadCode", "(", ")", "{", "ValueVect", "BO", ";", "BO", ".", "push_back", "(", "&", "Fn", "->", "front", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "BO", ".", "size", "(", ")", ";", "++", "i", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "BO", "[", "i", "]", ")", ";", "for", "(", "auto", "DTN", ":", "children", "<", "DomTreeNode", "*", ">", "(", "DT", "->", "getNode", "(", "B", ")", ")", ")", "BO", ".", "push_back", "(", "DTN", "->", "getBlock", "(", ")", ")", ";", "}", "for", "(", "Value", "*", "V", ":", "llvm", "::", "reverse", "(", "BO", ")", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "V", ")", ";", "ValueVect", "Ins", ";", "for", "(", "Instruction", "&", "I", ":", "llvm", "::", "reverse", "(", "*", "B", ")", ")", "Ins", ".", "push_back", "(", "&", "I", ")", ";", "for", "(", "ValueVect", "::", "iterator", "I", "=", "Ins", ".", "begin", "(", ")", ",", "E", "=", "Ins", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Instruction", "*", "In", "=", "cast", "<", "Instruction", ">", "(", "*", "I", ")", ";", "if", "(", "isInstructionTriviallyDead", "(", "In", ")", ")", "In", "->", "eraseFromParent", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

[ "Hexagon", "Hexagon", "0" ]

[]

[ "<s>", "void", "rs6000_output_function_entry", "(", "FILE", "*", "file", ",", "const", "char", "*", "fname", ")", "{", "if", "(", "fname", "[", "0", "]", "!=", "'.'", ")", "{", "switch", "(", "DEFAULT_ABI", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ABI_AIX", ":", "if", "(", "DOT_SYMBOLS", ")", "putc", "(", "'.'", ",", "file", ")", ";", "else", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "file", ",", "\"L.\"", ")", ";", "break", ";", "case", "ABI_ELFv2", ":", "case", "ABI_V4", ":", "case", "ABI_DARWIN", ":", "break", ";", "}", "}", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "fname", ")", ";", "}", "</s>" ]

[ "Write", "out", "a", "function", "code", "label", "." ]

[ "powerpcspe", "0", "\"L.\"" ]

[]

[ "<s>", "bool", "ThumbRegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "isThumb1Only", "(", ")", ")", "return", "ARMBaseRegisterInfo", "::", "saveScavengerRegister", "(", "MBB", ",", "I", ",", "UseMI", ",", "RC", ",", "Reg", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "bool", "done", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "I", ";", "!", "done", "&&", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugValue", "(", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "II", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "R12", ")", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isUndef", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "R12", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "}", "}", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::tMOVr", "ARM::R12", "ARMCC::AL", "0", "ARM::R12", "ARM::R12", "ARM::tMOVr", "ARM::R12", "ARMCC::AL" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOpWithMove", "(", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "RCID", "=", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpIdx", "]", ".", "RegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "unsigned", "Size", "=", "RI", ".", "getRegSizeInBits", "(", "*", "RC", ")", ";", "unsigned", "Opcode", "=", "(", "Size", "==", "64", ")", "?", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "AMDGPU", "::", "V_MOV_B32_e32", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "Opcode", "=", "AMDGPU", "::", "COPY", ";", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "Opcode", "=", "(", "Size", "==", "64", ")", "?", "AMDGPU", "::", "S_MOV_B64", ":", "AMDGPU", "::", "S_MOV_B32", ";", "const", "TargetRegisterClass", "*", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "RC", ")", ";", "const", "TargetRegisterClass", "*", "VRC64", "=", "RI", ".", "getVGPR64Class", "(", ")", ";", "if", "(", "RI", ".", "getCommonSubClass", "(", "VRC64", ",", "VRC", ")", ")", "VRC", "=", "VRC64", ";", "else", "VRC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "Register", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "DebugLoc", "DL", "=", "MBB", "->", "findDebugLoc", "(", "I", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "add", "(", "MO", ")", ";", "MO", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "}", "</s>" ]

[ "Legalize", "the", "OpIndex", "operand", "of", "this", "instruction", "by", "inserting", "a", "MOV", "." ]

[ "AMDGPU", "SI", "64", "AMDGPU::V_MOV_B64_PSEUDO", "AMDGPU::V_MOV_B32_e32", "AMDGPU::COPY", "64", "AMDGPU::S_MOV_B64", "AMDGPU::S_MOV_B32", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "bool", "arm_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ")", "{", "if", "(", "arm_disable_literal_pool", ")", "sorry", "(", "\"accessing thread-local storage is not currently supported \"", "\"with %<-mpure-code%> or %<-mslow-flash-data%>\"", ")", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TLS", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "contains", "any", "TLS", "symbol", "references", "." ]

[ "arm", "0", "\"accessing thread-local storage is not currently supported \"", "\"with %<-mpure-code%> or %<-mslow-flash-data%>\"", "1" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "{", "SDValue", "Ops", "[", "2", "]", ";", "std", "::", "tie", "(", "Ops", "[", "0", "]", ",", "Ops", "[", "1", "]", ")", "=", "scalarizeVectorLoad", "(", "Load", ",", "DAG", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Load", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "getSplitDestVTs", "(", "VT", ",", "DAG", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "getSplitDestVTs", "(", "MemVT", ",", "DAG", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "splitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ",", "DAG", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "BaseAlign", "=", "Load", "->", "getAlignment", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "BaseAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getObjectPtrOffset", "(", "SL", ",", "BasePtr", ",", "TypeSize", "::", "Fixed", "(", "Size", ")", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "HiAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "Join", ";", "if", "(", "LoVT", "==", "HiVT", ")", "{", "Join", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ";", "}", "else", "{", "Join", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "SL", ",", "VT", ",", "DAG", ".", "getUNDEF", "(", "VT", ")", ",", "LoLoad", ",", "DAG", ".", "getVectorIdxConstant", "(", "0", ",", "SL", ")", ")", ";", "Join", "=", "DAG", ".", "getNode", "(", "HiVT", ".", "isVector", "(", ")", "?", "ISD", "::", "INSERT_SUBVECTOR", ":", "ISD", "::", "INSERT_VECTOR_ELT", ",", "SL", ",", "VT", ",", "Join", ",", "HiLoad", ",", "DAG", ".", "getVectorIdxConstant", "(", "LoVT", ".", "getVectorNumElements", "(", ")", ",", "SL", ")", ")", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Join", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "2", "0", "1", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "0", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "static", "int", "nios2_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "HOST_WIDE_INT", "param_size", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "param_size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "param_size", ">=", "0", ")", ";", "}", "else", "param_size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "param_size", "=", "(", "UNITS_PER_WORD", "-", "1", "+", "param_size", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "cum", "->", "regs_used", "<", "NUM_ARG_REGS", "&&", "cum", "->", "regs_used", "+", "param_size", ">", "NUM_ARG_REGS", ")", "return", "(", "NUM_ARG_REGS", "-", "cum", "->", "regs_used", ")", "*", "UNITS_PER_WORD", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "number", "of", "bytes", ",", "at", "the", "beginning", "of", "the", "argument", ",", "that", "must", "be", "put", "in", "registers", ".", "0", "is", "the", "argument", "is", "entirely", "in", "registers", "or", "entirely", "in", "memory", "." ]

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

[]

[ "<s>", "const", "char", "*", "mangle_builtin_type", "(", "const_tree", "type", ")", "{", "if", "(", "TYPE_NAME", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_NAME", "(", "type", ")", ")", "==", "TYPE_DECL", ")", "type", "=", "TREE_TYPE", "(", "TYPE_NAME", "(", "type", ")", ")", ";", "if", "(", "tree", "attr", "=", "lookup_vector_type_attribute", "(", "type", ")", ")", "if", "(", "tree", "id", "=", "TREE_VALUE", "(", "chain_index", "(", "0", ",", "TREE_VALUE", "(", "attr", ")", ")", ")", ")", "return", "IDENTIFIER_POINTER", "(", "id", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "If", "TYPE", "is", "a", "built-in", "type", "defined", "by", "the", "RVV", "ABI", ",", "return", "the", "mangled", "name", ",", "otherwise", "return", "NULL", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "bool", "GBZ80FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "16", "&&", "\"Invalid register size\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "POP", ")", ",", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB", "16", "\"Invalid register size\"", "GB::POP" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "FRE", ":", "return", "\"PPCISD::FRE\"", ";", "case", "PPCISD", "::", "FRSQRTE", ":", "return", "\"PPCISD::FRSQRTE\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "TOC_ENTRY", ":", "return", "\"PPCISD::TOC_ENTRY\"", ";", "case", "PPCISD", "::", "TOC_RESTORE", ":", "return", "\"PPCISD::TOC_RESTORE\"", ";", "case", "PPCISD", "::", "LOAD", ":", "return", "\"PPCISD::LOAD\"", ";", "case", "PPCISD", "::", "LOAD_TOC", ":", "return", "\"PPCISD::LOAD_TOC\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "CALL", ":", "return", "\"PPCISD::CALL\"", ";", "case", "PPCISD", "::", "CALL_NOP", ":", "return", "\"PPCISD::CALL_NOP\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL", ":", "return", "\"PPCISD::BCTRL\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "EH_SJLJ_SETJMP", ":", "return", "\"PPCISD::EH_SJLJ_SETJMP\"", ";", "case", "PPCISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "\"PPCISD::EH_SJLJ_LONGJMP\"", ";", "case", "PPCISD", "::", "MFCR", ":", "return", "\"PPCISD::MFCR\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "BDNZ", ":", "return", "\"PPCISD::BDNZ\"", ";", "case", "PPCISD", "::", "BDZ", ":", "return", "\"PPCISD::BDZ\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "case", "PPCISD", "::", "CR6SET", ":", "return", "\"PPCISD::CR6SET\"", ";", "case", "PPCISD", "::", "CR6UNSET", ":", "return", "\"PPCISD::CR6UNSET\"", ";", "case", "PPCISD", "::", "ADDIS_TOC_HA", ":", "return", "\"PPCISD::ADDIS_TOC_HA\"", ";", "case", "PPCISD", "::", "LD_TOC_L", ":", "return", "\"PPCISD::LD_TOC_L\"", ";", "case", "PPCISD", "::", "ADDI_TOC_L", ":", "return", "\"PPCISD::ADDI_TOC_L\"", ";", "case", "PPCISD", "::", "ADDIS_GOT_TPREL_HA", ":", "return", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", ";", "case", "PPCISD", "::", "LD_GOT_TPREL_L", ":", "return", "\"PPCISD::LD_GOT_TPREL_L\"", ";", "case", "PPCISD", "::", "ADD_TLS", ":", "return", "\"PPCISD::ADD_TLS\"", ";", "case", "PPCISD", "::", "ADDIS_TLSGD_HA", ":", "return", "\"PPCISD::ADDIS_TLSGD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSGD_L", ":", "return", "\"PPCISD::ADDI_TLSGD_L\"", ";", "case", "PPCISD", "::", "GET_TLS_ADDR", ":", "return", "\"PPCISD::GET_TLS_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_TLSLD_HA", ":", "return", "\"PPCISD::ADDIS_TLSLD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSLD_L", ":", "return", "\"PPCISD::ADDI_TLSLD_L\"", ";", "case", "PPCISD", "::", "GET_TLSLD_ADDR", ":", "return", "\"PPCISD::GET_TLSLD_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_DTPREL_HA", ":", "return", "\"PPCISD::ADDIS_DTPREL_HA\"", ";", "case", "PPCISD", "::", "ADDI_DTPREL_L", ":", "return", "\"PPCISD::ADDI_DTPREL_L\"", ";", "case", "PPCISD", "::", "VADD_SPLAT", ":", "return", "\"PPCISD::VADD_SPLAT\"", ";", "case", "PPCISD", "::", "SC", ":", "return", "\"PPCISD::SC\"", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::FRE", "\"PPCISD::FRE\"", "PPCISD::FRSQRTE", "\"PPCISD::FRSQRTE\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::TOC_ENTRY", "\"PPCISD::TOC_ENTRY\"", "PPCISD::TOC_RESTORE", "\"PPCISD::TOC_RESTORE\"", "PPCISD::LOAD", "\"PPCISD::LOAD\"", "PPCISD::LOAD_TOC", "\"PPCISD::LOAD_TOC\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::CALL", "\"PPCISD::CALL\"", "PPCISD::CALL_NOP", "\"PPCISD::CALL_NOP\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL", "\"PPCISD::BCTRL\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::EH_SJLJ_SETJMP", "\"PPCISD::EH_SJLJ_SETJMP\"", "PPCISD::EH_SJLJ_LONGJMP", "\"PPCISD::EH_SJLJ_LONGJMP\"", "PPCISD::MFCR", "\"PPCISD::MFCR\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::BDNZ", "\"PPCISD::BDNZ\"", "PPCISD::BDZ", "\"PPCISD::BDZ\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"", "PPCISD::CR6SET", "\"PPCISD::CR6SET\"", "PPCISD::CR6UNSET", "\"PPCISD::CR6UNSET\"", "PPCISD::ADDIS_TOC_HA", "\"PPCISD::ADDIS_TOC_HA\"", "PPCISD::LD_TOC_L", "\"PPCISD::LD_TOC_L\"", "PPCISD::ADDI_TOC_L", "\"PPCISD::ADDI_TOC_L\"", "PPCISD::ADDIS_GOT_TPREL_HA", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", "PPCISD::LD_GOT_TPREL_L", "\"PPCISD::LD_GOT_TPREL_L\"", "PPCISD::ADD_TLS", "\"PPCISD::ADD_TLS\"", "PPCISD::ADDIS_TLSGD_HA", "\"PPCISD::ADDIS_TLSGD_HA\"", "PPCISD::ADDI_TLSGD_L", "\"PPCISD::ADDI_TLSGD_L\"", "PPCISD::GET_TLS_ADDR", "\"PPCISD::GET_TLS_ADDR\"", "PPCISD::ADDIS_TLSLD_HA", "\"PPCISD::ADDIS_TLSLD_HA\"", "PPCISD::ADDI_TLSLD_L", "\"PPCISD::ADDI_TLSLD_L\"", "PPCISD::GET_TLSLD_ADDR", "\"PPCISD::GET_TLSLD_ADDR\"", "PPCISD::ADDIS_DTPREL_HA", "\"PPCISD::ADDIS_DTPREL_HA\"", "PPCISD::ADDI_DTPREL_L", "\"PPCISD::ADDI_DTPREL_L\"", "PPCISD::VADD_SPLAT", "\"PPCISD::VADD_SPLAT\"", "PPCISD::SC", "\"PPCISD::SC\"" ]

[]

[ "<s>", "const", "char", "*", "mips_output_tls_reloc_directive", "(", "rtx", "*", "addr", ")", "{", "enum", "mips_symbol_type", "type", ";", "type", "=", "mips_classify_symbolic_expression", "(", "*", "addr", ",", "SYMBOL_CONTEXT_LEA", ")", ";", "*", "addr", "=", "mips_strip_unspec_address", "(", "*", "addr", ")", ";", "switch", "(", "type", ")", "{", "case", "SYMBOL_DTPREL", ":", "return", "Pmode", "==", "SImode", "?", "\".dtprelword\\t%0\"", ":", "\".dtpreldword\\t%0\"", ";", "case", "SYMBOL_TPREL", ":", "return", "Pmode", "==", "SImode", "?", "\".tprelword\\t%0\"", ":", "\".tpreldword\\t%0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "pseudo-op", "for", "full", "SYMBOL_", "(", "D", ")", "TPREL", "address", "*", "ADDR", ".", "Update", "*", "ADDR", "with", "the", "operand", "that", "should", "be", "printed", "." ]

[ "mips", "\".dtprelword\\t%0\"", "\".dtpreldword\\t%0\"", "\".tprelword\\t%0\"", "\".tpreldword\\t%0\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "Thumb1FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "Thumb1InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Thumb1InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "ThumbRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "ThumbRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "DebugLoc", "dl", "=", "Old", ".", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "TII", ".", "getFrameSize", "(", "Old", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "unsigned", "Opc", "=", "Old", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitCallSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitCallSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "Amount", ")", ";", "}", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "ARM", "0", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP" ]

[]

[ "<s>", "static", "void", "s390_split_branches", "(", "void", ")", "{", "rtx", "temp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_REGNUM", ")", ";", "rtx", "insn", ",", "pat", ",", "label", ",", "target", ",", "jump", ",", "tmp", ";", "if", "(", "TARGET_64BIT", ")", "return", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "!=", "JUMP_INSN", ")", "continue", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "continue", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "LABEL_REF", ")", "{", "label", "=", "SET_SRC", "(", "pat", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "IF_THEN_ELSE", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ")", "==", "LABEL_REF", ")", "label", "=", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "2", ")", ")", "==", "LABEL_REF", ")", "label", "=", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "2", ")", ";", "else", "continue", ";", "}", "else", "continue", ";", "if", "(", "get_attr_length", "(", "insn", ")", "==", "4", ")", "continue", ";", "if", "(", "flag_pic", ")", "{", "target", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "label", ")", ",", "100", ")", ";", "target", "=", "gen_rtx_CONST", "(", "SImode", ",", "target", ")", ";", "target", "=", "force_const_mem", "(", "SImode", ",", "target", ")", ";", "jump", "=", "gen_rtx_REG", "(", "Pmode", ",", "BASE_REGISTER", ")", ";", "jump", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "jump", ",", "temp_reg", ")", ";", "}", "else", "{", "target", "=", "force_const_mem", "(", "Pmode", ",", "label", ")", ";", "jump", "=", "temp_reg", ";", "}", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "IF_THEN_ELSE", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ")", "==", "LABEL_REF", ")", "jump", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ",", "jump", ",", "pc_rtx", ")", ";", "else", "jump", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ",", "pc_rtx", ",", "jump", ")", ";", "}", "tmp", "=", "emit_insn_before", "(", "gen_rtx_SET", "(", "Pmode", ",", "temp_reg", ",", "target", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "tmp", ",", "-", "1", ")", ";", "tmp", "=", "emit_jump_insn_before", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "jump", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "tmp", ",", "-", "1", ")", ";", "remove_insn", "(", "insn", ")", ";", "insn", "=", "tmp", ";", "}", "}", "</s>" ]

[ "Split", "all", "branches", "that", "exceed", "the", "maximum", "distance", ".", "Returns", "true", "if", "this", "created", "a", "new", "literal", "pool", "entry", "." ]

[ "s390", "1", "1", "2", "2", "4", "1", "100", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "static", "bool", "ix86_rop_should_change_byte_p", "(", "int", "t", ")", "{", "return", "t", "==", "0xc2", "||", "t", "==", "0xc3", "||", "t", "==", "0xca", "||", "t", "==", "0xcb", ";", "}", "</s>" ]

[ "Return", "true", "if", "T", "is", "one", "of", "the", "bytes", "we", "should", "avoid", "with", "-mmitigate-rop", "." ]

[ "i386", "0xc2", "0xc3", "0xca", "0xcb" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "const", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "LocalMemAvailable", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "FTy", "->", "getNumParams", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "Type", "*", "ParamTy", "=", "FTy", "->", "getParamType", "(", "i", ")", ";", "if", "(", "ParamTy", "->", "isPointerTy", "(", ")", "&&", "ParamTy", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "LocalMemAvailable", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "break", ";", "}", "}", "if", "(", "LocalMemAvailable", ">", "0", ")", "{", "for", "(", "Module", "::", "global_iterator", "I", "=", "Mod", "->", "global_begin", "(", ")", ",", "E", "=", "Mod", "->", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "GlobalVariable", "*", "GV", "=", "I", ";", "PointerType", "*", "GVTy", "=", "GV", "->", "getType", "(", ")", ";", "if", "(", "GVTy", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "Value", "::", "use_iterator", "U", "=", "GV", "->", "use_begin", "(", ")", ",", "UE", "=", "GV", "->", "use_end", "(", ")", ";", "U", "!=", "UE", ";", "++", "U", ")", "{", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "*", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "LocalMemAvailable", "-=", "Mod", "->", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "GVTy", "->", "getElementType", "(", ")", ")", ";", "}", "}", "}", "LocalMemAvailable", "=", "std", "::", "max", "(", "0", ",", "LocalMemAvailable", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "LocalMemAvailable", "<<", "\"bytes free in local memory.\\n\"", ")", ";", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "R600", "0", "AMDGPUAS::LOCAL_ADDRESS", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "0", "AMDGPUAS::LOCAL_ADDRESS", "0", "\"bytes free in local memory.\\n\"" ]

[]

[ "<s>", "static", "rtx", "c6x_dwarf_register_span", "(", "rtx", "rtl", ")", "{", "unsigned", "regno", ";", "unsigned", "real_regno", ";", "int", "nregs", ";", "int", "i", ";", "rtx", "p", ";", "regno", "=", "REGNO", "(", "rtl", ")", ";", "nregs", "=", "HARD_REGNO_NREGS", "(", "regno", ",", "GET_MODE", "(", "rtl", ")", ")", ";", "if", "(", "nregs", "==", "1", ")", "return", "NULL_RTX", ";", "p", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", ";", "i", "++", ")", "{", "if", "(", "TARGET_BIG_ENDIAN", ")", "real_regno", "=", "regno", "+", "nregs", "-", "(", "i", "+", "1", ")", ";", "else", "real_regno", "=", "regno", "+", "i", ";", "XVECEXP", "(", "p", ",", "0", ",", "i", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "real_regno", ")", ";", "}", "return", "p", ";", "}", "</s>" ]

[ "We", "save", "pairs", "of", "registers", "using", "a", "DImode", "store", ".", "Describe", "the", "component", "registers", "for", "DWARF", "generation", "code", "." ]

[ "c6x", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "frv_optimize_membar_global", "(", "basic_block", "bb", ",", "struct", "frv_io", "*", "first_io", ",", "rtx_insn", "*", "membar", ")", "{", "struct", "frv_io", "this_io", ",", "next_io", ";", "edge", "succ", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "succ", ",", "ei", ",", "bb", "->", "succs", ")", "if", "(", "succ", "->", "dest", "==", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", "return", ";", "ei", "=", "ei_start", "(", "bb", "->", "succs", ")", ";", "ei_cond", "(", "ei", ",", "&", "succ", ")", ";", "next_io", "=", "first_io", "[", "succ", "->", "dest", "->", "index", "]", ";", "ei", "=", "ei_start", "(", "bb", "->", "succs", ")", ";", "if", "(", "ei_cond", "(", "ei", ",", "&", "succ", ")", ")", "{", "for", "(", "ei_next", "(", "&", "ei", ")", ";", "ei_cond", "(", "ei", ",", "&", "succ", ")", ";", "ei_next", "(", "&", "ei", ")", ")", "frv_io_union", "(", "&", "next_io", ",", "&", "first_io", "[", "succ", "->", "dest", "->", "index", "]", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "frv_extract_membar", "(", "&", "this_io", ",", "membar", ")", ";", "if", "(", "frv_io_fixed_order_p", "(", "&", "this_io", ",", "&", "next_io", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; [Global] Removing membar %d since order of accesses\"", "\" is guaranteed\\n\"", ",", "INSN_UID", "(", "membar", ")", ")", ";", "delete_insn", "(", "membar", ")", ";", "}", "}", "</s>" ]

[ "See", "if", "MEMBAR", ",", "the", "last", "membar", "instruction", "in", "BB", ",", "can", "be", "removed", ".", "FIRST_IO", "[", "X", "]", "describes", "the", "first", "operation", "performed", "by", "basic", "block", "X", "." ]

[ "frv", "\";; [Global] Removing membar %d since order of accesses\"", "\" is guaranteed\\n\"" ]

[]

[ "<s>", "const", "char", "*", "loongarch_output_equal_conditional_branch", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "bool", "inverted_p", ")", "{", "const", "char", "*", "branch", "[", "2", "]", ";", "if", "(", "operands", "[", "3", "]", "==", "const0_rtx", ")", "{", "branch", "[", "!", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b%C1z\"", ",", "\"%2,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b%N1z\"", ",", "\"%2,%0\"", ")", ";", "}", "else", "{", "branch", "[", "!", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b%C1\"", ",", "\"%2,%z3,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b%N1\"", ",", "\"%2,%z3,%0\"", ")", ";", "}", "return", "loongarch_output_conditional_branch", "(", "insn", ",", "operands", ",", "branch", "[", "1", "]", ",", "branch", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "code", "for", "INSN", ",", "which", "branches", "to", "OPERANDS", "[", "0", "]", "if", "some", "equality", "condition", "is", "true", ".", "The", "condition", "is", "given", "by", "OPERANDS", "[", "1", "]", "if", "!", "INVERTED_P", ",", "otherwise", "it", "is", "the", "inverse", "of", "OPERANDS", "[", "1", "]", ".", "OPERANDS", "[", "2", "]", "is", "the", "comparison", "'s", "first", "operand", ";", "OPERANDS", "[", "3", "]", "is", "the", "second", "operand", "and", "may", "be", "zero", "or", "a", "register", "." ]

[ "loongarch", "2", "3", "\"b%C1z\"", "\"%2,%0\"", "\"b%N1z\"", "\"%2,%0\"", "\"b%C1\"", "\"%2,%z3,%0\"", "\"b%N1\"", "\"%2,%z3,%0\"", "1", "0" ]

[]