Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"PTX DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "PTX", "\"PTX DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "rtx", "extract_nth_ls2_access_reg", "(", "rtx_insn", "*", "insn", ",", "int", "n", ")", "{", "rtx", "reg", ";", "machine_mode", "mode", ";", "if", "(", "post_update_insn_p", "(", "insn", ")", ")", "{", "memory_access_direction", "direction", "=", "determine_access_direction", "(", "insn", ")", ";", "gcc_assert", "(", "direction", "!=", "MEM_ACCESS_DIR_UNKNOWN", ")", ";", "if", "(", "direction", "==", "MEM_ACCESS_DIR_NEG", ")", "n", "=", "-", "1", "*", "n", "-", "1", ";", "}", "if", "(", "n", "<", "-", "2", "||", "n", ">", "1", ")", "return", "NULL_RTX", ";", "if", "(", "n", "<", "0", ")", "n", "=", "2", "+", "n", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_LOAD", ":", "reg", "=", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "reg", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "REG_P", "(", "reg", ")", "||", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", ";", "switch", "(", "GET_MODE", "(", "reg", ")", ")", "{", "case", "E_DImode", ":", "mode", "=", "SImode", ";", "break", ";", "case", "E_DFmode", ":", "mode", "=", "SFmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "n", "==", "0", ")", "return", "gen_lowpart", "(", "mode", ",", "reg", ")", ";", "else", "return", "gen_highpart", "(", "mode", ",", "reg", ")", ";", "}", "</s>" ]

[ "Returns", "the", "register", "operated", "by", "the", "nth", "load/store", "operation", "in", "the", "real", "micro-operation", "accessing", "order", ".", "This", "function", "assumes", "INSN", "must", "be", "a", "double-word", "load/store", "insn", "." ]

[ "nds32", "1", "1", "2", "1", "0", "2", "0" ]

[]

[ "<s>", "static", "void", "pa_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "arg_size", "=", "pa_function_arg_size", "(", "mode", ",", "type", ")", ";", "cum", "->", "nargs_prototype", "--", ";", "cum", "->", "words", "+=", "(", "arg_size", "+", "(", "(", "cum", "->", "words", "&", "01", ")", "&&", "type", "!=", "NULL_TREE", "&&", "arg_size", ">", "1", ")", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "pa", "01", "1" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "Register", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Offset", "==", "0", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "Register", "FIReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "FIReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "TII", "->", "getAddNoCarry", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "BaseReg", ")", ".", "addReg", "(", "OffsetReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "FIReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "AMDGPU", "SI", "SI", "0", "AMDGPU::V_MOV_B32_e32", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::S_MOV_B32", "AMDGPU::V_MOV_B32_e32", "0" ]

[]

[ "<s>", "static", "void", "computeKnownBits", "(", "SelectionDAG", "&", "DAG", ",", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ")", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ARMISD", "::", "BFI", ")", "{", "computeKnownBits", "(", "DAG", ",", "Op", ".", "getOperand", "(", "0", ")", ",", "KnownZero", ",", "KnownOne", ")", ";", "ConstantSDNode", "*", "CI", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "const", "APInt", "&", "Mask", "=", "CI", "->", "getAPIntValue", "(", ")", ";", "KnownZero", "&=", "Mask", ";", "KnownOne", "&=", "Mask", ";", "return", ";", "}", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ARMISD", "::", "CMOV", ")", "{", "APInt", "KZ2", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "APInt", "KO2", "(", "KnownOne", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "computeKnownBits", "(", "DAG", ",", "Op", ".", "getOperand", "(", "0", ")", ",", "KnownZero", ",", "KnownOne", ")", ";", "computeKnownBits", "(", "DAG", ",", "Op", ".", "getOperand", "(", "1", ")", ",", "KZ2", ",", "KO2", ")", ";", "KnownZero", "&=", "KZ2", ";", "KnownOne", "&=", "KO2", ";", "return", ";", "}", "return", "DAG", ".", "computeKnownBits", "(", "Op", ",", "KnownZero", ",", "KnownOne", ")", ";", "}", "</s>" ]

[ "Determine", "which", "bits", "of", "Op", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "Known", "." ]

[ "ARM", "ARMISD::BFI", "0", "2", "ARMISD::CMOV", "0", "0", "0", "1" ]

[]

[ "<s>", "rtx", "find_addr_reg", "(", "rtx", "addr", ")", "{", "while", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "!=", "0", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "0", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "REG", "&&", "REGNO", "(", "addr", ")", "!=", "0", ")", ";", "return", "addr", ";", "}", "</s>" ]

[ "Return", "a", "REG", "that", "occurs", "in", "ADDR", "with", "coefficient", "1", ".", "ADDR", "can", "be", "effectively", "incremented", "by", "incrementing", "REG", ".", "r0", "is", "special", "and", "we", "must", "not", "select", "it", "as", "an", "address", "register", "by", "this", "routine", "since", "our", "caller", "will", "try", "to", "increment", "the", "returned", "register", "via", "an", "``", "la", "''", "instruction", "." ]

[ "powerpcspe", "0", "0", "0", "0", "1", "1", "0", "1", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "char", "*", "SpillLibCall", "=", "getSpillLibCallName", "(", "*", "MF", ",", "CSI", ")", ";", "if", "(", "SpillLibCall", ")", "{", "assert", "(", "!", "RISCVABI", "::", "isCheriPureCapABI", "(", "STI", ".", "getTargetABI", "(", ")", ")", "&&", "\"Save/restore libcall not implemented for purecap\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PseudoCALLReg", ")", ",", "RISCV", "::", "X5", ")", ".", "addExternalSymbol", "(", "SpillLibCall", ",", "RISCVII", "::", "MO_CALL", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "MBB", ".", "addLiveIn", "(", "CS", ".", "getReg", "(", ")", ")", ";", "}", "const", "auto", "&", "NonLibcallCSI", "=", "getNonLibcallCSI", "(", "*", "MF", ",", "CSI", ")", ";", "for", "(", "auto", "&", "CS", ":", "NonLibcallCSI", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "bool", "IsLiveIn", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "!", "IsLiveIn", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVABI::isCheriPureCapABI", "\"Save/restore libcall not implemented for purecap\"", "RISCV::PseudoCALLReg", "RISCV::X5", "RISCVII::MO_CALL" ]

[]

[ "<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", "(", ")", ")", ";", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"did not expect relocated expression\"", ")", ";", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"did not expect relocated expression\"" ]

[]

[ "<s>", "static", "void", "nds32_emit_stack_v3pop", "(", "rtx", "Rb", ",", "rtx", "Re", ",", "rtx", "En4", "ATTRIBUTE_UNUSED", ",", "rtx", "imm8u", ")", "{", "int", "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", "=", "REGNO", "(", "Re", ")", "-", "REGNO", "(", "Rb", ")", "+", "1", "+", "3", ";", "parallel_insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_use_regs", "+", "1", ")", ")", ";", "par_index", "=", "0", ";", "offset", "=", "0", ";", "for", "(", "regno", "=", "REGNO", "(", "Rb", ")", ";", "regno", "<=", "(", "int", ")", "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", "+", "INTVAL", "(", "imm8u", ")", ")", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "adjust_sp_rtx", ";", "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>", "static", "rtx", "nios2_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "op0", ",", "op1", ";", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "nios2_legitimize_constant_address", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", ")", "return", "x", ";", "op0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "nios2_valid_addr_offset_p", "(", "op1", ")", ")", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "op0", ")", ",", "copy_rtx", "(", "op1", ")", ")", ";", "else", "if", "(", "nios2_symbolic_constant_p", "(", "op1", ")", ")", "{", "if", "(", "nios2_large_constant_allowed", "(", ")", ")", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "op0", ")", ",", "copy_rtx", "(", "op1", ")", ")", ";", "else", "return", "nios2_split_plus_large_constant", "(", "op0", ",", "op1", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST", ")", "{", "rtx", "unspec", ",", "offset", ";", "split_const", "(", "op1", ",", "&", "unspec", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", "&&", "!", "nios2_large_offset_p", "(", "XINT", "(", "unspec", ",", "1", ")", ")", "&&", "offset", "!=", "const0_rtx", ")", "{", "rtx", "reg", "=", "force_reg", "(", "Pmode", ",", "op0", ")", ";", "unspec", "=", "copy_rtx", "(", "unspec", ")", ";", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", "=", "plus_constant", "(", "Pmode", ",", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ",", "INTVAL", "(", "offset", ")", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "gen_rtx_CONST", "(", "Pmode", ",", "unspec", ")", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMIZE_ADDRESS", "." ]

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

[]

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

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "ECLair" ]

[]

[ "<s>", "static", "bool", "nvptx_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "ARG_UNUSED", "(", "aligned_p", ")", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "gcc_assert", "(", "size", "=", "decl_chunk_size", ")", ";", "if", "(", "decl_offset", "%", "decl_chunk_size", "!=", "0", ")", "sorry", "(", "\"cannot emit unaligned pointers in ptx assembly\"", ")", ";", "decl_offset", "+=", "size", ";", "begin_decl_field", "(", ")", ";", "HOST_WIDE_INT", "off", "=", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "off", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "nvptx_record_needed_fndecl", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"generic(\"", ")", ";", "output_address", "(", "x", ")", ";", "fprintf", "(", "asm_out_file", ",", "\")\"", ")", ";", "}", "if", "(", "off", "!=", "0", ")", "fprintf", "(", "asm_out_file", ",", "\" + \"", "HOST_WIDE_INT_PRINT_DEC", ",", "off", ")", ";", "return", "true", ";", "}", "HOST_WIDE_INT", "val", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "val", "=", "INTVAL", "(", "x", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "nvptx_assemble_value", "(", "val", ",", "size", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "object", "X", "of", "size", "SIZE", "." ]

[ "nvptx", "0", "\"cannot emit unaligned pointers in ptx assembly\"", "0", "0", "1", "0", "\"generic(\"", "\")\"", "0", "\" + \"" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_fabs", "(", "rtx", "op0", ",", "rtx", "*", "smask", ")", "{", "machine_mode", "vmode", ",", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "xa", ",", "mask", ";", "xa", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "vmode", "=", "V4SFmode", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "vmode", "=", "V2DFmode", ";", "else", "vmode", "=", "mode", ";", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "VECTOR_MODE_P", "(", "mode", ")", ",", "true", ")", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "rtx", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ")", ";", "tmp", "=", "gen_rtx_VEC_SELECT", "(", "mode", ",", "mask", ",", "tmp", ")", ";", "mask", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mask", ",", "tmp", ")", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "xa", ",", "gen_rtx_AND", "(", "mode", ",", "op0", ",", "mask", ")", ")", ")", ";", "if", "(", "smask", ")", "*", "smask", "=", "mask", ";", "return", "xa", ";", "}", "</s>" ]

[ "Expand", "fabs", "(", "OP0", ")", "and", "return", "a", "new", "rtx", "that", "holds", "the", "result", ".", "The", "mask", "for", "masking", "out", "the", "sign-bit", "is", "stored", "in", "*", "SMASK", ",", "if", "that", "is", "non-null", "." ]

[ "i386", "1" ]

[]

[ "<s>", "int", "num_insns_constant", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "low", ",", "high", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "CONST_INT", ":", "if", "(", "(", "INTVAL", "(", "op", ")", ">>", "31", ")", "!=", "0", "&&", "(", "INTVAL", "(", "op", ")", ">>", "31", ")", "!=", "-", "1", "&&", "rs6000_is_valid_and_mask", "(", "op", ",", "mode", ")", ")", "return", "2", ";", "else", "return", "num_insns_constant_wide", "(", "INTVAL", "(", "op", ")", ")", ";", "case", "CONST_WIDE_INT", ":", "{", "int", "i", ";", "int", "ins", "=", "CONST_WIDE_INT_NUNITS", "(", "op", ")", "-", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CONST_WIDE_INT_NUNITS", "(", "op", ")", ";", "i", "++", ")", "ins", "+=", "num_insns_constant_wide", "(", "CONST_WIDE_INT_ELT", "(", "op", ",", "i", ")", ")", ";", "return", "ins", ";", "}", "case", "CONST_DOUBLE", ":", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SDmode", ")", "{", "long", "l", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "REAL_VALUE_TO_TARGET_DECIMAL32", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "else", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "return", "num_insns_constant_wide", "(", "(", "HOST_WIDE_INT", ")", "l", ")", ";", "}", "long", "l", "[", "2", "]", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "REAL_VALUE_TO_TARGET_DECIMAL64", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "else", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "high", "=", "l", "[", "WORDS_BIG_ENDIAN", "==", "0", "]", ";", "low", "=", "l", "[", "WORDS_BIG_ENDIAN", "!=", "0", "]", ";", "if", "(", "TARGET_32BIT", ")", "return", "(", "num_insns_constant_wide", "(", "low", ")", "+", "num_insns_constant_wide", "(", "high", ")", ")", ";", "else", "{", "if", "(", "(", "high", "==", "0", "&&", "low", ">=", "0", ")", "||", "(", "high", "==", "-", "1", "&&", "low", "<", "0", ")", ")", "return", "num_insns_constant_wide", "(", "low", ")", ";", "else", "if", "(", "rs6000_is_valid_and_mask", "(", "op", ",", "mode", ")", ")", "return", "2", ";", "else", "if", "(", "low", "==", "0", ")", "return", "num_insns_constant_wide", "(", "high", ")", "+", "1", ";", "else", "return", "(", "num_insns_constant_wide", "(", "high", ")", "+", "num_insns_constant_wide", "(", "low", ")", "+", "1", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "it", "takes", "to", "form", "a", "constant", "in", "as", "many", "gprs", "are", "needed", "for", "MODE", "." ]

[ "rs6000", "31", "0", "31", "1", "2", "1", "0", "2", "0", "0", "0", "0", "1", "0", "2", "0", "1", "1" ]

[]

[ "<s>", "bool", "GBZ80FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "unsigned", "CalleeFrameSize", "=", "0", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "GBZ80FI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "reverse", "(", "CSI", ")", ")", "{", "unsigned", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "bool", "IsNotLiveIn", "=", "!", "MBB", ".", "isLiveIn", "(", "Reg", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "16", "&&", "\"Invalid register size\"", ")", ";", "if", "(", "IsNotLiveIn", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "PUSH", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "IsNotLiveIn", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "CalleeFrameSize", "+=", "2", ";", "}", "GBZ80FI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "0", "GB", "GB", "GB", "GB", "GB", "16", "\"Invalid register size\"", "GB::PUSH", "2", "GB" ]

[]

[ "<s>", "static", "int", "aarch64_sched_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "rtx", "x", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SET", ")", "{", "x", "=", "SET_SRC", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_SHA1H", ")", "return", "priority", "+", "10", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_SCHED_ADJUST_PRIORITY", "hook", ".", "Adjust", "priority", "of", "sha1h", "instructions", "so", "they", "are", "scheduled", "before", "other", "SHA1", "instructions", "." ]

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

[]

[ "<s>", "unsigned", "size", "(", ")", "const", "{", "return", "Mask", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "M68k" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "CommentStream", ")", "HasCustomInstComment", "=", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "MII", ")", ";", "unsigned", "Flags", "=", "MI", "->", "getFlags", "(", ")", ";", "if", "(", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_LOCK", ")", ")", "OS", "<<", "\"\\tlock\\t\"", ";", "if", "(", "(", "TSFlags", "&", "X86II", "::", "NOTRACK", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_NOTRACK", ")", ")", "OS", "<<", "\"\\tnotrack\\t\"", ";", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT_NE", ")", "OS", "<<", "\"\\trepne\\t\"", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT", ")", "OS", "<<", "\"\\trep\\t\"", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CALLpcrel32", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode64Bit", "]", ")", ")", "{", "OS", "<<", "\"\\tcallq\\t\"", ";", "printPCRelImm", "(", "MI", ",", "0", ",", "OS", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "DATA16_PREFIX", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ")", ")", "{", "MCInst", "Data32MI", "(", "*", "MI", ")", ";", "Data32MI", ".", "setOpcode", "(", "X86", "::", "DATA32_PREFIX", ")", ";", "printInstruction", "(", "&", "Data32MI", ",", "OS", ")", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86II::LOCK", "X86::IP_HAS_LOCK", "\"\\tlock\\t\"", "X86II::NOTRACK", "X86::IP_HAS_NOTRACK", "\"\\tnotrack\\t\"", "X86::IP_HAS_REPEAT_NE", "\"\\trepne\\t\"", "X86::IP_HAS_REPEAT", "\"\\trep\\t\"", "X86::CALLpcrel32", "X86::Mode64Bit", "\"\\tcallq\\t\"", "0", "X86::DATA16_PREFIX", "X86::Mode16Bit", "X86::DATA32_PREFIX" ]

[]

[ "<s>", "int", "insvdi_rshift_rlwimi_p", "(", "rtx", "sizeop", ",", "rtx", "startop", ",", "rtx", "shiftop", ")", "{", "if", "(", "INTVAL", "(", "startop", ")", ">", "32", "&&", "INTVAL", "(", "startop", ")", "<", "64", "&&", "INTVAL", "(", "sizeop", ")", ">", "1", "&&", "INTVAL", "(", "sizeop", ")", "+", "INTVAL", "(", "startop", ")", "<", "64", "&&", "INTVAL", "(", "shiftop", ")", ">", "0", "&&", "INTVAL", "(", "sizeop", ")", "+", "INTVAL", "(", "shiftop", ")", "<", "32", "&&", "(", "64", "-", "(", "INTVAL", "(", "shiftop", ")", "&", "63", ")", ")", ">=", "INTVAL", "(", "sizeop", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "operands", "will", "generate", "a", "valid", "arguments", "to", "rlwimiinstruction", "for", "insert", "with", "right", "shift", "in", "64-bit", "mode", ".", "The", "mask", "maynot", "start", "on", "the", "first", "bit", "or", "stop", "on", "the", "last", "bit", "because", "wrap-aroundeffects", "of", "instruction", "do", "not", "correspond", "to", "semantics", "of", "RTL", "insn", "." ]

[ "rs6000", "32", "64", "1", "64", "0", "32", "64", "63", "1", "0" ]

[]

[ "<s>", "static", "rtx", "tilegx_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", "&&", "symbolic_operand", "(", "x", ",", "Pmode", ")", "&&", "tilegx_tls_referenced_p", "(", "x", ")", ")", "{", "return", "tilegx_legitimize_tls_address", "(", "x", ")", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "return", "tilegx_legitimize_pic_address", "(", "x", ",", "mode", ",", "0", ")", ";", "}", "else", "return", "x", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMIZE_ADDRESS", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "void", "HexagonMCELFStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "MCK", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "MCInst", "HMI", ";", "HMI", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "HMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "MCInst", "*", "MCB", ";", "if", "(", "MCK", ".", "getOpcode", "(", ")", "!=", "Hexagon", "::", "BUNDLE", ")", "{", "HMI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "&", "MCK", ")", ")", ";", "MCB", "=", "&", "HMI", ";", "}", "else", "MCB", "=", "const_cast", "<", "MCInst", "*", ">", "(", "&", "MCK", ")", ";", "HexagonMCInstrInfo", "::", "padEndloop", "(", "*", "MCB", ")", ";", "HexagonMCShuffle", "(", "*", "MCII", ",", "STI", ",", "*", "MCB", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "*", "MCB", ")", "<=", "HEXAGON_PACKET_SIZE", ")", ";", "bool", "Extended", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "*", "MCB", ")", ")", "{", "MCInst", "*", "MCI", "=", "const_cast", "<", "MCInst", "*", ">", "(", "I", ".", "getInst", "(", ")", ")", ";", "if", "(", "Extended", ")", "{", "if", "(", "HexagonMCInstrInfo", "::", "isDuplex", "(", "*", "MCII", ",", "*", "MCI", ")", ")", "{", "MCInst", "*", "SubInst", "=", "const_cast", "<", "MCInst", "*", ">", "(", "MCI", "->", "getOperand", "(", "1", ")", ".", "getInst", "(", ")", ")", ";", "HexagonMCInstrInfo", "::", "clampExtended", "(", "*", "MCII", ",", "*", "SubInst", ")", ";", "}", "else", "{", "HexagonMCInstrInfo", "::", "clampExtended", "(", "*", "MCII", ",", "*", "MCI", ")", ";", "}", "Extended", "=", "false", ";", "}", "else", "{", "Extended", "=", "HexagonMCInstrInfo", "::", "isImmext", "(", "*", "MCI", ")", ";", "}", "}", "for", "(", "auto", "const", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "*", "MCB", ")", ")", "{", "MCInst", "*", "MCI", "=", "const_cast", "<", "MCInst", "*", ">", "(", "I", ".", "getInst", "(", ")", ")", ";", "EmitSymbol", "(", "*", "MCI", ")", ";", "}", "MCObjectStreamer", "::", "EmitInstruction", "(", "*", "MCB", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::BUNDLE", "0", "Hexagon::BUNDLE", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "1", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getSqrtEstimate", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ",", "bool", "&", "UseOneConstNR", ",", "bool", "Reciprocal", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", "&&", "Reciprocal", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasSSE2", "(", ")", "&&", "!", "Reciprocal", ")", "||", "(", "VT", "==", "MVT", "::", "v8f32", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", ")", "{", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "1", ";", "UseOneConstNR", "=", "false", ";", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "FRSQRT", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "Op", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Hooks", "for", "building", "estimates", "in", "place", "of", "slower", "divisions", "and", "square", "roots", "." ]

[ "X86", "X86", "MVT::f32", "MVT::v4f32", "MVT::v4f32", "MVT::v8f32", "1", "X86ISD::FRSQRT" ]

[]

[ "<s>", "void", "reset", "(", ")", "{", "count", "=", "0", ";", "size", "=", "0", ";", "call", "=", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasAVX", "(", ")", "||", "ST", ".", "hasFastPartialYMMorZMMWrite", "(", ")", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "EverMadeChange", "=", "false", ";", "IsX86INTR", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_INTR", ";", "bool", "FnHasLiveInYmmOrZmm", "=", "checkFnHasLiveInYmmOrZmm", "(", "MRI", ")", ";", "bool", "YmmOrZmmUsed", "=", "FnHasLiveInYmmOrZmm", ";", "const", "TargetRegisterClass", "*", "RCs", "[", "2", "]", "=", "{", "&", "X86", "::", "VR256RegClass", ",", "&", "X86", "::", "VR512RegClass", "}", ";", "for", "(", "auto", "*", "RC", ":", "RCs", ")", "{", "if", "(", "!", "YmmOrZmmUsed", ")", "{", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "*", "i", ")", ")", "{", "YmmOrZmmUsed", "=", "true", ";", "break", ";", "}", "}", "}", "}", "if", "(", "!", "YmmOrZmmUsed", ")", "{", "return", "false", ";", "}", "assert", "(", "BlockStates", ".", "empty", "(", ")", "&&", "DirtySuccessors", ".", "empty", "(", ")", "&&", "\"X86VZeroUpper state should be clear\"", ")", ";", "BlockStates", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MBB", ")", ";", "if", "(", "FnHasLiveInYmmOrZmm", ")", "addDirtySuccessor", "(", "MF", ".", "front", "(", ")", ")", ";", "while", "(", "!", "DirtySuccessors", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DirtySuccessors", ".", "back", "(", ")", ";", "DirtySuccessors", ".", "pop_back", "(", ")", ";", "BlockState", "&", "BBState", "=", "BlockStates", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "if", "(", "BBState", ".", "FirstUnguardedCall", "!=", "MBB", ".", "end", "(", ")", ")", "insertVZeroUpper", "(", "BBState", ".", "FirstUnguardedCall", ",", "MBB", ")", ";", "if", "(", "BBState", ".", "ExitState", "==", "PASS_THROUGH", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB #\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\" was Pass-through, is now Dirty-out.\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "addDirtySuccessor", "(", "*", "Succ", ")", ";", "}", "}", "BlockStates", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "2", "X86::VR256RegClass", "X86::VR512RegClass", "\"X86VZeroUpper state should be clear\"", "\"MBB #\"", "\" was Pass-through, is now Dirty-out.\\n\"" ]

[]

[ "<s>", "void", "HSAILPassConfig", "::", "addPreEmitPass", "(", ")", "{", "}", "</s>" ]

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

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "static", "int", "save_fprs_p", "(", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", "0", ";", "for", "(", "i", "=", "24", ";", "i", "<=", "31", ";", "i", "++", ")", "{", "if", "(", "regs_ever_live", "[", "i", "]", "==", "1", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "floating", "point", "registers", "need", "to", "be", "saved", "." ]

[ "s390", "0", "24", "31", "1", "1", "0" ]

[]

[ "<s>", "TargetPassConfig", "*", "SystemZTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "SystemZPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "enum", "unwind_info_type", "ia64_debug_unwind_info", "(", "void", ")", "{", "return", "UI_TARGET", ";", "}", "</s>" ]

[ "Implement", "TARGET_DEBUG_UNWIND_INFO", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "arc_expand_prologue", "(", "void", ")", "{", "int", "size", ";", "unsigned", "int", "gmask", "=", "cfun", "->", "machine", "->", "frame_info", ".", "gmask", ";", "struct", "arc_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "unsigned", "int", "frame_size_to_allocate", ";", "int", "first_offset", "=", "0", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "bool", "save_blink", "=", "false", ";", "bool", "save_fp", "=", "false", ";", "if", "(", "ARC_NAKED_P", "(", "fn_type", ")", ")", "{", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "0", ";", "return", ";", "}", "size", "=", "arc_compute_frame_size", "(", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "frame_size_to_allocate", "=", "size", ";", "gcc_assert", "(", "!", "(", "size", "==", "0", "&&", "gmask", ")", ")", ";", "if", "(", "frame", "->", "pretend_size", "!=", "0", ")", "first_offset", "=", "-", "frame", "->", "pretend_size", ";", "if", "(", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "frame_stack_add", "(", "first_offset", ")", ";", "first_offset", "=", "0", ";", "arc_dwarf_emit_irq_save_regs", "(", ")", ";", "}", "save_blink", "=", "arc_must_save_return_addr", "(", "cfun", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", ";", "save_fp", "=", "arc_frame_pointer_needed", "(", ")", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", ";", "if", "(", "TARGET_CODE_DENSITY", "&&", "TARGET_CODE_DENSITY_FRAME", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "arc_enter_leave_p", "(", "gmask", ")", ")", "frame_size_to_allocate", "-=", "arc_save_callee_enter", "(", "gmask", ",", "save_blink", ",", "save_fp", ",", "first_offset", ")", ";", "else", "if", "(", "frame", "->", "millicode_end_reg", ">", "14", ")", "frame_size_to_allocate", "-=", "arc_save_callee_milli", "(", "gmask", ",", "save_blink", ",", "save_fp", ",", "first_offset", ",", "frame", "->", "reg_size", ")", ";", "else", "frame_size_to_allocate", "-=", "arc_save_callee_saves", "(", "gmask", ",", "save_blink", ",", "save_fp", ",", "first_offset", ")", ";", "if", "(", "frame_size_to_allocate", ">", "0", ")", "frame_stack_add", "(", "(", "HOST_WIDE_INT", ")", "0", "-", "frame_size_to_allocate", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", "." ]

[ "arc", "0", "0", "0", "0", "0", "14", "0", "0" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "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", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_XCore", ")", ";", "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", "." ]

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

[]

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

[ "targetHandlesStackFrameRounding", "-", "Returns", "true", "if", "the", "target", "is", "responsible", "for", "rounding", "up", "the", "stack", "frame", "(", "probably", "at", "emitPrologue", "time", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "BT", "::", "run", "(", ")", "{", "reset", "(", ")", ";", "assert", "(", "FlowQ", ".", "empty", "(", ")", ")", ";", "using", "MachineFlowGraphTraits", "=", "GraphTraits", "<", "const", "MachineFunction", "*", ">", ";", "const", "MachineBasicBlock", "*", "Entry", "=", "MachineFlowGraphTraits", "::", "getEntryNode", "(", "&", "MF", ")", ";", "unsigned", "MaxBN", "=", "0", ";", "for", "(", "const", "MachineBasicBlock", "&", "B", ":", "MF", ")", "{", "assert", "(", "B", ".", "getNumber", "(", ")", ">=", "0", "&&", "\"Disconnected block\"", ")", ";", "unsigned", "BN", "=", "B", ".", "getNumber", "(", ")", ";", "if", "(", "BN", ">", "MaxBN", ")", "MaxBN", "=", "BN", ";", "}", "BitVector", "BlockScanned", "(", "MaxBN", "+", "1", ")", ";", "int", "EntryN", "=", "Entry", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "-", "1", ",", "EntryN", ")", ")", ";", "while", "(", "!", "FlowQ", ".", "empty", "(", ")", "||", "!", "UseQ", ".", "empty", "(", ")", ")", "{", "runEdgeQueue", "(", "BlockScanned", ")", ";", "runUseQueue", "(", ")", ";", "}", "UseQ", ".", "reset", "(", ")", ";", "if", "(", "Trace", ")", "print_cells", "(", "dbgs", "(", ")", "<<", "\"Cells after propagation:\\n\"", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "Hexagon", "0", "0", "\"Disconnected block\"", "1", "1", "\"Cells after propagation:\\n\"" ]

[]

[ "<s>", "static", "void", "sparc_handle_vis_mul8x16", "(", "vec", "<", "tree", ">", "*", "n_elts", ",", "enum", "sparc_builtins", "fncode", ",", "tree", "inner_type", ",", "tree", "cst0", ",", "tree", "cst1", ")", "{", "unsigned", "i", ",", "num", "=", "VECTOR_CST_NELTS", "(", "cst0", ")", ";", "int", "scale", ";", "switch", "(", "fncode", ")", "{", "case", "SPARC_BUILTIN_FMUL8X16", ":", "for", "(", "i", "=", "0", ";", "i", "<", "num", ";", "++", "i", ")", "{", "int", "val", "=", "sparc_vis_mul8x16", "(", "TREE_INT_CST_LOW", "(", "VECTOR_CST_ELT", "(", "cst0", ",", "i", ")", ")", ",", "TREE_INT_CST_LOW", "(", "VECTOR_CST_ELT", "(", "cst1", ",", "i", ")", ")", ")", ";", "n_elts", "->", "quick_push", "(", "build_int_cst", "(", "inner_type", ",", "val", ")", ")", ";", "}", "break", ";", "case", "SPARC_BUILTIN_FMUL8X16AU", ":", "scale", "=", "TREE_INT_CST_LOW", "(", "VECTOR_CST_ELT", "(", "cst1", ",", "0", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num", ";", "++", "i", ")", "{", "int", "val", "=", "sparc_vis_mul8x16", "(", "TREE_INT_CST_LOW", "(", "VECTOR_CST_ELT", "(", "cst0", ",", "i", ")", ")", ",", "scale", ")", ";", "n_elts", "->", "quick_push", "(", "build_int_cst", "(", "inner_type", ",", "val", ")", ")", ";", "}", "break", ";", "case", "SPARC_BUILTIN_FMUL8X16AL", ":", "scale", "=", "TREE_INT_CST_LOW", "(", "VECTOR_CST_ELT", "(", "cst1", ",", "1", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num", ";", "++", "i", ")", "{", "int", "val", "=", "sparc_vis_mul8x16", "(", "TREE_INT_CST_LOW", "(", "VECTOR_CST_ELT", "(", "cst0", ",", "i", ")", ")", ",", "scale", ")", ";", "n_elts", "->", "quick_push", "(", "build_int_cst", "(", "inner_type", ",", "val", ")", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Multiply", "the", "vector", "elements", "in", "ELTS0", "to", "the", "elements", "in", "ELTS1", "as", "specified", "by", "FNCODE", ".", "All", "of", "the", "elements", "in", "ELTS0", "and", "ELTS1", "lists", "must", "be", "integer", "constants", ".", "A", "tree", "list", "with", "the", "results", "of", "the", "multiplications", "is", "returned", ",", "and", "each", "element", "in", "the", "list", "is", "of", "INNER_TYPE", "." ]

[ "sparc", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", ")", "const", "{", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineOperand", "*", "BaseOpA", "=", "nullptr", ",", "*", "BaseOpB", "=", "nullptr", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "int", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", ")", "{", "int", "LowOffset", "=", "std", "::", "min", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "HighOffset", "=", "std", "::", "max", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "Lanai", "Lanai", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"", "0", "0", "0", "0" ]

[]

[ "<s>", "MVT", "::", "SimpleValueType", "PPCTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "PowerPC", "MVT::SimpleValueType", "PPC", "MVT::i32" ]

[]

[ "<s>", "void", "ix86_expand_convert_uns_sixf_sse", "(", "rtx", ",", "rtx", ")", "{", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Not", "used", ",", "but", "eases", "macroization", "of", "patterns", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "mark_current_function_as_interrupt", "(", ")", "{", "tree", "name", ";", "if", "(", "current_function_decl", "==", "NULL_TREE", ")", "{", "warning", "(", "\"cannot set interrupt attribute: no current function\"", ")", ";", "return", ";", "}", "name", "=", "get_identifier", "(", "\"interrupt\"", ")", ";", "if", "(", "name", "==", "NULL_TREE", "||", "TREE_CODE", "(", "name", ")", "!=", "IDENTIFIER_NODE", ")", "{", "warning", "(", "\"cannot set interrupt attribute: no such identifier\"", ")", ";", "return", ";", "}", "decl_attributes", "(", "&", "current_function_decl", ",", "tree_cons", "(", "name", ",", "NULL_TREE", ",", "NULL_TREE", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Set", "the", "machine", "specific", "'interrupt", "'", "attribute", "on", "the", "current", "function", "." ]

[ "v850", "\"cannot set interrupt attribute: no current function\"", "\"interrupt\"", "\"cannot set interrupt attribute: no such identifier\"", "0" ]

[]

[ "<s>", "static", "bool", "vspltis_constant", "(", "rtx", "op", ",", "unsigned", "step", ",", "unsigned", "copies", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "machine_mode", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "unsigned", "i", ";", "unsigned", "nunits", ";", "unsigned", "bitsize", ";", "unsigned", "mask", ";", "HOST_WIDE_INT", "val", ";", "HOST_WIDE_INT", "splat_val", ";", "HOST_WIDE_INT", "msb_val", ";", "if", "(", "mode", "==", "V2DImode", "||", "mode", "==", "V2DFmode", "||", "mode", "==", "V1TImode", ")", "return", "false", ";", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "bitsize", "=", "GET_MODE_BITSIZE", "(", "inner", ")", ";", "mask", "=", "GET_MODE_MASK", "(", "inner", ")", ";", "val", "=", "const_vector_elt_as_int", "(", "op", ",", "BYTES_BIG_ENDIAN", "?", "nunits", "-", "1", ":", "0", ")", ";", "splat_val", "=", "val", ";", "msb_val", "=", "val", ">=", "0", "?", "0", ":", "-", "1", ";", "for", "(", "i", "=", "2", ";", "i", "<=", "copies", ";", "i", "*=", "2", ")", "{", "HOST_WIDE_INT", "small_val", ";", "bitsize", "/=", "2", ";", "small_val", "=", "splat_val", ">>", "bitsize", ";", "mask", ">>=", "bitsize", ";", "if", "(", "splat_val", "!=", "(", "(", "small_val", "<<", "bitsize", ")", "|", "(", "small_val", "&", "mask", ")", ")", ")", "return", "false", ";", "splat_val", "=", "small_val", ";", "}", "if", "(", "EASY_VECTOR_15", "(", "splat_val", ")", ")", ";", "else", "if", "(", "EASY_VECTOR_15_ADD_SELF", "(", "splat_val", ")", "&&", "(", "splat_val", ">=", "0", "||", "(", "step", "==", "1", "&&", "copies", "==", "1", ")", ")", ")", ";", "else", "if", "(", "EASY_VECTOR_MSB", "(", "splat_val", ",", "inner", ")", ")", ";", "else", "return", "false", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nunits", ";", "++", "i", ")", "{", "HOST_WIDE_INT", "desired_val", ";", "unsigned", "elt", "=", "BYTES_BIG_ENDIAN", "?", "nunits", "-", "1", "-", "i", ":", "i", ";", "if", "(", "(", "i", "&", "(", "step", "-", "1", ")", ")", "==", "0", ")", "desired_val", "=", "val", ";", "else", "desired_val", "=", "msb_val", ";", "if", "(", "desired_val", "!=", "const_vector_elt_as_int", "(", "op", ",", "elt", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "can", "be", "synthesized", "with", "a", "particular", "vspltisb", ",", "vspltish", "or", "vspltisw", "instruction", ".", "OP", "is", "a", "CONST_VECTOR", ".", "Which", "instruction", "is", "used", "depends", "on", "STEP", "and", "COPIES", ",", "one", "of", "which", "will", "be", "1", ".", "If", "COPIES", ">", "1", ",", "all", "items", "are", "set", "to", "the", "same", "value", "and", "contain", "COPIES", "replicas", "of", "the", "vsplt", "'s", "operand", ";", "if", "STEP", ">", "1", ",", "one", "in", "STEP", "elements", "is", "set", "to", "the", "vsplt", "'s", "operand", "and", "the", "others", "are", "set", "to", "the", "value", "of", "the", "operand", "'s", "msb", "." ]

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

[]

[ "<s>", "void", "VLIWMachineScheduler", "::", "schedule", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Converging Scheduling VLIW BB#\"", "<<", "BB", "->", "getNumber", "(", ")", "<<", "\" \"", "<<", "BB", "->", "getName", "(", ")", "<<", "\" in_func \"", "<<", "BB", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\" at loop depth \"", "<<", "MLI", ".", "getLoopDepth", "(", "BB", ")", "<<", "\" \\n\"", ")", ";", "buildDAGWithRegPressure", "(", ")", ";", "postprocessDAG", "(", ")", ";", "SmallVector", "<", "SUnit", "*", ",", "8", ">", "TopRoots", ",", "BotRoots", ";", "findRootsAndBiasEdges", "(", "TopRoots", ",", "BotRoots", ")", ";", "SchedImpl", "->", "initialize", "(", "this", ")", ";", "DEBUG", "(", "unsigned", "maxH", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ">", "maxH", ")", "maxH", "=", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Height \"", "<<", "maxH", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "unsigned", "maxD", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ">", "maxD", ")", "maxD", "=", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Depth \"", "<<", "maxD", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "initQueues", "(", "TopRoots", ",", "BotRoots", ")", ";", "bool", "IsTopNode", "=", "false", ";", "while", "(", "SUnit", "*", "SU", "=", "SchedImpl", "->", "pickNode", "(", "IsTopNode", ")", ")", "{", "if", "(", "!", "checkSchedLimit", "(", ")", ")", "break", ";", "scheduleMI", "(", "SU", ",", "IsTopNode", ")", ";", "updateQueues", "(", "SU", ",", "IsTopNode", ")", ";", "SchedImpl", "->", "schedNode", "(", "SU", ",", "IsTopNode", ")", ";", "}", "assert", "(", "CurrentTop", "==", "CurrentBottom", "&&", "\"Nonempty unscheduled zone.\"", ")", ";", "placeDebugValues", "(", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "Hexagon", "\"********** MI Converging Scheduling VLIW BB#\"", "\" \"", "\" in_func \"", "\" at loop depth \"", "\" \\n\"", "8", "0", "0", "\"Max Height \"", "\"\\n\"", "0", "0", "\"Max Depth \"", "\"\\n\"", "0", "\"Nonempty unscheduled zone.\"" ]

[]

[ "<s>", "bool", "AMDGPUTargetELFStreamer", "::", "EmitHSAMetadata", "(", "const", "AMDGPU", "::", "HSAMD", "::", "Metadata", "&", "HSAMetadata", ")", "{", "std", "::", "string", "HSAMetadataString", ";", "if", "(", "HSAMD", "::", "toString", "(", "HSAMetadata", ",", "HSAMetadataString", ")", ")", "return", "false", ";", "auto", "&", "Context", "=", "getContext", "(", ")", ";", "auto", "*", "DescBegin", "=", "Context", ".", "createTempSymbol", "(", ")", ";", "auto", "*", "DescEnd", "=", "Context", ".", "createTempSymbol", "(", ")", ";", "auto", "*", "DescSZ", "=", "MCBinaryExpr", "::", "createSub", "(", "MCSymbolRefExpr", "::", "create", "(", "DescEnd", ",", "Context", ")", ",", "MCSymbolRefExpr", "::", "create", "(", "DescBegin", ",", "Context", ")", ",", "Context", ")", ";", "EmitNote", "(", "ElfNote", "::", "NoteNameV2", ",", "DescSZ", ",", "ELF", "::", "NT_AMD_HSA_METADATA", ",", "[", "&", "]", "(", "MCELFStreamer", "&", "OS", ")", "{", "OS", ".", "emitLabel", "(", "DescBegin", ")", ";", "OS", ".", "emitBytes", "(", "HSAMetadataString", ")", ";", "OS", ".", "emitLabel", "(", "DescEnd", ")", ";", "}", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "HSA", "Metadata", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::HSAMD" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "return", "(", "DisableFramePointerElim", "(", "MF", ")", "||", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getForceFramePointer", "(", ")", "||", "MMI", ".", "callsUnwindInit", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MBlazePassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createMBlazeISelDag", "(", "getMBlazeTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "rtx", "or1k_legitimize_address", "(", "rtx", "x", ",", "rtx", ",", "machine_mode", ")", "{", "return", "or1k_legitimize_address_1", "(", "x", ",", "NULL_RTX", ")", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_LEGITIMIZE_ADDRESS", ".", "This", "delegates", "implementation", "to", "or1k_legitimize_address_1", "." ]

[ "or1k" ]

[]

[ "<s>", "unsigned", "int", "mips_case_values_threshold", "(", "void", ")", "{", "if", "(", "TARGET_MIPS16", "&&", "optimize_size", ")", "return", "10", ";", "else", "return", "default_case_values_threshold", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CASE_VALUES_THRESHOLD", "." ]

[ "mips", "10" ]

[]

[ "<s>", "bool", "ix86_call_use_plt_p", "(", "rtx", "call_op", ")", "{", "if", "(", "SYMBOL_REF_LOCAL_P", "(", "call_op", ")", ")", "{", "if", "(", "SYMBOL_REF_DECL", "(", "call_op", ")", "&&", "TREE_CODE", "(", "SYMBOL_REF_DECL", "(", "call_op", ")", ")", "==", "FUNCTION_DECL", ")", "{", "cgraph_node", "*", "node", "=", "cgraph_node", "::", "get", "(", "SYMBOL_REF_DECL", "(", "call_op", ")", ")", ";", "if", "(", "node", "&&", "node", "->", "ifunc_resolver", ")", "return", "true", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "is", "called", "via", "PLT", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "h8300_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "cum", "->", "nbytes", "+=", "(", "mode", "!=", "BLKmode", "?", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "&", "-", "UNITS_PER_WORD", ":", "(", "int_size_in_bytes", "(", "type", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "&", "-", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "h8300", "1", "1" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "return", "false", ";", "assert", "(", "!", "MO", ".", "getSubReg", "(", ")", "&&", "\"Subregs should be eliminated!\"", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetARMGVSymbol", "(", "MO", ".", "getGlobal", "(", ")", ",", "MO", ".", "getTargetFlags", "(", ")", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "APFloat", "Val", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "bool", "ignored", ";", "Val", ".", "convert", "(", "APFloat", "::", "IEEEdouble", ",", "APFloat", "::", "rmTowardZero", ",", "&", "ignored", ")", ";", "MCOp", "=", "MCOperand", "::", "createFPImm", "(", "Val", ".", "convertToDouble", "(", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "ARM", "ARM", "\"unknown operand type\"", "ARM::CPSR", "\"Subregs should be eliminated!\"", "ARM" ]

[]

[ "<s>", "void", "CSKYELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "LSDAEncoding", "=", "dwarf", "::", "DW_EH_PE_pcrel", "|", "dwarf", "::", "DW_EH_PE_sdata4", ";", "PersonalityEncoding", "=", "dwarf", "::", "DW_EH_PE_indirect", "|", "dwarf", "::", "DW_EH_PE_pcrel", "|", "dwarf", "::", "DW_EH_PE_sdata4", ";", "TTypeEncoding", "=", "dwarf", "::", "DW_EH_PE_indirect", "|", "dwarf", "::", "DW_EH_PE_pcrel", "|", "dwarf", "::", "DW_EH_PE_sdata4", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "static", "void", "h8300_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "mem", ";", "if", "(", "Pmode", "==", "HImode", ")", "{", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "GEN_INT", "(", "0x7903", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "2", ")", ";", "emit_move_insn", "(", "mem", ",", "cxt", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "4", ")", ";", "emit_move_insn", "(", "mem", ",", "GEN_INT", "(", "0x5a00", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "6", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "}", "else", "{", "rtx", "tem", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "GEN_INT", "(", "0x7a03", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "2", ")", ";", "emit_move_insn", "(", "mem", ",", "cxt", ")", ";", "tem", "=", "copy_to_reg", "(", "fnaddr", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "tem", ",", "tem", ",", "GEN_INT", "(", "0x00ffffff", ")", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "tem", ",", "tem", ",", "GEN_INT", "(", "0x5a000000", ")", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "6", ")", ";", "emit_move_insn", "(", "mem", ",", "tem", ")", ";", "}", "}", "</s>" ]

[ "We", "emit", "the", "entire", "trampoline", "here", ".", "Depending", "on", "the", "pointer", "size", ",", "we", "use", "a", "different", "trampoline", ".", "Pmode", "==", "HImode", "vvvv", "context", "1", "0000", "7903xxxx", "mov.w", "#", "0x1234", ",", "r3", "2", "0004", "5A00xxxx", "jmp", "@", "0x1234", "^^^^", "function", "Pmode", "==", "SImode", "vvvvvvvv", "context", "2", "0000", "7A03xxxxxxxx", "mov.l", "#", "0x12345678", ",", "er3", "3", "0006", "5Axxxxxx", "jmp", "@", "0x123456", "^^^^^^", "function" ]

[ "h8300", "0", "0", "0x7903", "2", "4", "0x5a00", "6", "0", "0x7a03", "2", "0x00ffffff", "0x5a000000", "6" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register x\"", ";", "OS", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "ECLair", "\"<register x\"", "\">\"", "\"'\"", "\"'\"" ]

[]

[ "<s>", "static", "void", "macho_branch_islands", "(", "void", ")", "{", "char", "tmp_buf", "[", "512", "]", ";", "tree", "branch_island", ";", "for", "(", "branch_island", "=", "branch_island_list", ";", "branch_island", ";", "branch_island", "=", "TREE_CHAIN", "(", "branch_island", ")", ")", "{", "const", "char", "*", "label", "=", "IDENTIFIER_POINTER", "(", "BRANCH_ISLAND_LABEL_NAME", "(", "branch_island", ")", ")", ";", "const", "char", "*", "name", "=", "IDENTIFIER_POINTER", "(", "BRANCH_ISLAND_FUNCTION_NAME", "(", "branch_island", ")", ")", ";", "char", "name_buf", "[", "512", "]", ";", "if", "(", "name", "[", "0", "]", "==", "'*'", "||", "name", "[", "0", "]", "==", "'&'", ")", "strcpy", "(", "name_buf", ",", "name", "+", "1", ")", ";", "else", "{", "name_buf", "[", "0", "]", "=", "'_'", ";", "strcpy", "(", "name_buf", "+", "1", ",", "name", ")", ";", "}", "strcpy", "(", "tmp_buf", ",", "\"\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "if", "(", "write_symbols", "==", "DBX_DEBUG", "||", "write_symbols", "==", "XCOFF_DEBUG", ")", "dbxout_stabd", "(", "N_SLINE", ",", "BRANCH_ISLAND_LINE_NUMBER", "(", "branch_island", ")", ")", ";", "if", "(", "flag_pic", ")", "{", "strcat", "(", "tmp_buf", ",", "\":\\n\\tmflr r0\\n\\tbcl 20,31,\"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "strcat", "(", "tmp_buf", ",", "\"_pic\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "strcat", "(", "tmp_buf", ",", "\"_pic:\\n\\tmflr r11\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "\"\\taddis r11,r11,ha16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "name_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\" - \"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "strcat", "(", "tmp_buf", ",", "\"_pic)\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "\"\\tmtlr r0\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "\"\\taddi r12,r11,lo16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "name_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\" - \"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "strcat", "(", "tmp_buf", ",", "\"_pic)\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "\"\\tmtctr r12\\n\\tbctr\\n\"", ")", ";", "}", "else", "{", "strcat", "(", "tmp_buf", ",", "\":\\nlis r12,hi16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "name_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\")\\n\\tori r12,r12,lo16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "name_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\")\\n\\tmtctr r12\\n\\tbctr\"", ")", ";", "}", "output_asm_insn", "(", "tmp_buf", ",", "0", ")", ";", "if", "(", "write_symbols", "==", "DBX_DEBUG", "||", "write_symbols", "==", "XCOFF_DEBUG", ")", "dbxout_stabd", "(", "N_SLINE", ",", "BRANCH_ISLAND_LINE_NUMBER", "(", "branch_island", ")", ")", ";", "}", "branch_island_list", "=", "0", ";", "}", "</s>" ]

[ "Generate", "far-jump", "branch", "islands", "for", "everything", "on", "the", "branch_island_list", ".", "Invoked", "immediately", "after", "the", "last", "instruction", "of", "the", "epilogue", "has", "been", "emitted", ";", "the", "branch-islands", "must", "be", "appended", "to", ",", "and", "contiguous", "with", ",", "the", "function", "body", ".", "Mach-O", "stubs", "are", "generated", "in", "machopic_output_stub", "(", ")", "." ]

[ "rs6000", "512", "512", "0", "0", "1", "0", "1", "\"\\n\"", "\":\\n\\tmflr r0\\n\\tbcl 20,31,\"", "\"_pic\\n\"", "\"_pic:\\n\\tmflr r11\\n\"", "\"\\taddis r11,r11,ha16(\"", "\" - \"", "\"_pic)\\n\"", "\"\\tmtlr r0\\n\"", "\"\\taddi r12,r11,lo16(\"", "\" - \"", "\"_pic)\\n\"", "\"\\tmtctr r12\\n\\tbctr\\n\"", "\":\\nlis r12,hi16(\"", "\")\\n\\tori r12,r12,lo16(\"", "\")\\n\\tmtctr r12\\n\\tbctr\"", "0", "0" ]

[]

[ "<s>", "MVT", "PPCTargetLowering", "::", "getSetCCResultType", "(", "MVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "PowerPC", "PPC", "MVT::i32" ]

[]

[ "<s>", "BitVector", "SICRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedCPURegs", "[", "]", "=", "{", "SIC", "::", "X", ",", "SIC", "::", "PC", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "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", "." ]

[ "SIC", "SIC", "SIC::X", "SIC::PC", "0" ]

[]

[ "<s>", "unsigned", "SICABIInfo", "::", "GetCalleeAllocdArgSizeInBytes", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "CC", "!=", "0", ";", "if", "(", "IsS32", "(", ")", ")", "return", "0", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "Obtain", "the", "size", "of", "the", "area", "allocated", "by", "the", "callee", "for", "arguments", "." ]

[ "SIC", "SIC", "0", "0", "\"Unhandled ABI\"" ]

[]

[ "<s>", "rtx", "alpha_arg_info_reg_val", "(", "CUMULATIVE_ARGS", "cum", ")", "{", "unsigned", "HOST_WIDE_INT", "regval", "=", "cum", ".", "num_args", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "6", ";", "i", "++", ")", "regval", "|=", "(", "(", "int", ")", "cum", ".", "atypes", "[", "i", "]", ")", "<<", "(", "i", "*", "3", "+", "8", ")", ";", "return", "GEN_INT", "(", "regval", ")", ";", "}", "</s>" ]

[ "Return", "an", "rtx", "for", "an", "integer", "representing", "the", "VMS", "Argument", "Information", "register", "value", "." ]

[ "alpha", "0", "6", "3", "8" ]

[]

[ "<s>", "static", "int", "vfp3_const_double_index", "(", "rtx", "x", ")", "{", "REAL_VALUE_TYPE", "r", ",", "m", ";", "int", "sign", ",", "exponent", ";", "unsigned", "HOST_WIDE_INT", "mantissa", ",", "mant_hi", ";", "unsigned", "HOST_WIDE_INT", "mask", ";", "int", "point_pos", "=", "2", "*", "HOST_BITS_PER_WIDE_INT", "-", "1", ";", "bool", "fail", ";", "if", "(", "!", "TARGET_VFP3", "||", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "-", "1", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "if", "(", "REAL_VALUE_ISINF", "(", "r", ")", "||", "REAL_VALUE_ISNAN", "(", "r", ")", "||", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", ")", "return", "-", "1", ";", "sign", "=", "REAL_VALUE_NEGATIVE", "(", "r", ")", "?", "1", ":", "0", ";", "r", "=", "real_value_abs", "(", "&", "r", ")", ";", "exponent", "=", "REAL_EXP", "(", "&", "r", ")", ";", "real_ldexp", "(", "&", "m", ",", "&", "r", ",", "point_pos", "-", "exponent", ")", ";", "wide_int", "w", "=", "real_to_integer", "(", "&", "m", ",", "&", "fail", ",", "HOST_BITS_PER_WIDE_INT", "*", "2", ")", ";", "mantissa", "=", "w", ".", "elt", "(", "0", ")", ";", "mant_hi", "=", "w", ".", "elt", "(", "1", ")", ";", "if", "(", "mantissa", "!=", "0", ")", "return", "-", "1", ";", "point_pos", "-=", "HOST_BITS_PER_WIDE_INT", ";", "mantissa", "=", "mant_hi", ";", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "(", "point_pos", "-", "5", ")", ")", "-", "1", ";", "if", "(", "(", "mantissa", "&", "mask", ")", "!=", "0", ")", "return", "-", "1", ";", "mantissa", ">>=", "point_pos", "-", "5", ";", "if", "(", "mantissa", "==", "0", ")", "return", "-", "1", ";", "gcc_assert", "(", "mantissa", ">=", "16", "&&", "mantissa", "<=", "31", ")", ";", "exponent", "=", "5", "-", "exponent", ";", "if", "(", "exponent", "<", "0", "||", "exponent", ">", "7", ")", "return", "-", "1", ";", "return", "(", "sign", "<<", "7", ")", "|", "(", "(", "exponent", "^", "3", ")", "<<", "4", ")", "|", "(", "mantissa", "-", "16", ")", ";", "}", "</s>" ]

[ "Return", "an", "integer", "index", "for", "a", "VFPv3", "immediate", "operand", "X", "suitable", "for", "the", "fconst", "[", "sd", "]", "instruction", ",", "or", "-1", "if", "X", "is", "n't", "suitable", "." ]

[ "arm", "2", "1", "1", "1", "1", "0", "2", "0", "1", "0", "1", "1", "5", "1", "0", "1", "5", "0", "1", "16", "31", "5", "0", "7", "1", "7", "3", "4", "16" ]

[]

[ "<s>", "static", "rtx", "nios2_load_pic_address", "(", "rtx", "sym", ",", "int", "unspec", ",", "rtx", "tmp", ")", "{", "if", "(", "flag_pic", "==", "2", "&&", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", "&&", "nios2_symbol_binds_local_p", "(", "sym", ")", ")", "{", "rtx", "offset", "=", "nios2_unspec_offset", "(", "sym", ",", "UNSPEC_PIC_GOTOFF_SYM", ")", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "return", "nios2_large_got_address", "(", "offset", ",", "tmp", ")", ";", "}", "if", "(", "unspec", "==", "UNSPEC_PIC_CALL_SYM", ")", "return", "gen_rtx_MEM", "(", "Pmode", ",", "nios2_got_address", "(", "sym", ",", "unspec", ")", ")", ";", "else", "return", "gen_const_mem", "(", "Pmode", ",", "nios2_got_address", "(", "sym", ",", "unspec", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "PIC", "address", "as", "a", "MEM", "rtx", "." ]

[ "nios2", "2", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "useLoadStackGuardNode", "(", ")", "const", "{", "return", "Subtarget", "->", "getTargetTriple", "(", ")", ".", "getObjectFormat", "(", ")", "==", "Triple", "::", "MachO", ";", "}", "</s>" ]

[ "If", "this", "function", "returns", "true", ",", "SelectionDAGBuilder", "emits", "a", "LOAD_STACK_GUARD", "node", "when", "it", "is", "lowering", "Intrinsic", ":", ":stackprotector", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "int", "ARMFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "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>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"NEON register pre-allocation pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"NEON register pre-allocation pass\"" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "StackPtr", ",", "int64_t", "NumBytes", ",", "bool", "Is64Bit", ",", "bool", "UseLEA", ",", "const", "TargetInstrInfo", "&", "TII", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "unsigned", "Opc", ";", "if", "(", "UseLEA", ")", "Opc", "=", "getLEArOpcode", "(", "Is64Bit", ")", ";", "else", "Opc", "=", "isSub", "?", "getSUBriOpcode", "(", "Is64Bit", ",", "Offset", ")", ":", "getADDriOpcode", "(", "Is64Bit", ",", "Offset", ")", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "while", "(", "Offset", ")", "{", "uint64_t", "ThisVal", "=", "(", "Offset", ">", "Chunk", ")", "?", "Chunk", ":", "Offset", ";", "if", "(", "ThisVal", "==", "(", "Is64Bit", "?", "8", ":", "4", ")", ")", "{", "unsigned", "Reg", "=", "isSub", "?", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ":", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "Opc", "=", "isSub", "?", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ":", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "!", "isSub", ")", "|", "getUndefRegState", "(", "isSub", ")", ")", ";", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "continue", ";", "}", "}", "MachineInstr", "*", "MI", "=", "NULL", ";", "if", "(", "UseLEA", ")", "{", "MI", "=", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ",", "StackPtr", ",", "false", ",", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ")", ";", "}", "else", "{", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "ThisVal", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "X86", "0", "1LL", "31", "1", "8", "4", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "X86::POP64r", "X86::POP32r", "3" ]

[]

[ "<s>", "const", "char", "*", "thumb_call_via_reg", "(", "rtx", "reg", ")", "{", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "rtx", "*", "labelp", ";", "gcc_assert", "(", "regno", "<", "LR_REGNUM", ")", ";", "if", "(", "in_section", "==", "text_section", ")", "{", "thumb_call_reg_needed", "=", "1", ";", "if", "(", "thumb_call_via_label", "[", "regno", "]", "==", "NULL", ")", "thumb_call_via_label", "[", "regno", "]", "=", "gen_label_rtx", "(", ")", ";", "labelp", "=", "thumb_call_via_label", "+", "regno", ";", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "call_via", "[", "regno", "]", "==", "NULL", ")", "cfun", "->", "machine", "->", "call_via", "[", "regno", "]", "=", "gen_label_rtx", "(", ")", ";", "labelp", "=", "cfun", "->", "machine", "->", "call_via", "+", "regno", ";", "}", "output_asm_insn", "(", "\"bl\\t%a0\"", ",", "labelp", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "call-via", "instruction", "for", "thumb", "state", "." ]

[ "arm", "1", "\"bl\\t%a0\"", "\"\"" ]

[]

[ "<s>", "bool", "HSAILInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "return", "HSAILGenInstrInfo", "::", "expandPostRAPseudo", "(", "MI", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "HSAIL", "HSAIL", "HSAIL" ]

[]

[ "<s>", "static", "int", "maybe_split_mode", "(", "machine_mode", "*", "pmode", ")", "{", "machine_mode", "mode", "=", "*", "pmode", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "{", "*", "pmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "return", "2", ";", "}", "else", "if", "(", "mode", "==", "TImode", ")", "{", "*", "pmode", "=", "DImode", ";", "return", "2", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "pieces", "to", "use", "when", "dealing", "with", "a", "pseudo", "of", "*", "PMODE", ".", "Alter", "*", "PMODE", "if", "we", "return", "a", "number", "greater", "than", "one", "." ]

[ "nvptx", "2", "2", "1" ]

[]

[ "<s>", "bool", "HexagonPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "DisablePacketizer", "||", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "*", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "auto", "*", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "if", "(", "EnableGenAllInsnClass", ")", "HII", "->", "genAllInsnTimingClasses", "(", "MF", ")", ";", "HexagonPacketizerList", "Packetizer", "(", "MF", ",", "MLI", ",", "AA", ",", "MBPI", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "auto", "&", "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", ";", "}", "}", "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", ";", "}", "}", "Packetizer", ".", "unpacketizeSoloInstrs", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "rs6000_mangle_type", "(", "const_tree", "type", ")", "{", "type", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "!=", "VOID_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "BOOLEAN_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "INTEGER_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "REAL_TYPE", ")", "return", "NULL", ";", "if", "(", "type", "==", "bool_char_type_node", ")", "return", "\"U6__boolc\"", ";", "if", "(", "type", "==", "bool_short_type_node", ")", "return", "\"U6__bools\"", ";", "if", "(", "type", "==", "pixel_type_node", ")", "return", "\"u7__pixel\"", ";", "if", "(", "type", "==", "bool_int_type_node", ")", "return", "\"U6__booli\"", ";", "if", "(", "type", "==", "bool_long_type_node", ")", "return", "\"U6__booll\"", ";", "if", "(", "TARGET_FLOAT128", ")", "{", "if", "(", "type", "==", "ieee128_float_type_node", ")", "return", "\"U10__float128\"", ";", "if", "(", "type", "==", "ibm128_float_type_node", ")", "return", "\"g\"", ";", "if", "(", "type", "==", "long_double_type_node", "&&", "TARGET_LONG_DOUBLE_128", ")", "return", "(", "TARGET_IEEEQUAD", ")", "?", "\"U10__float128\"", ":", "\"g\"", ";", "}", "if", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", "&&", "TARGET_ELF", "&&", "TARGET_LONG_DOUBLE_128", "&&", "!", "TARGET_IEEEQUAD", ")", "return", "\"g\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "AltiVec", "defines", "five", "built-in", "scalar", "types", "that", "serve", "as", "vector", "elements", ";", "we", "must", "teach", "the", "compiler", "how", "to", "mangle", "them", ".", "The", "128-bit", "floating", "point", "mangling", "is", "target-specific", "as", "well", ".", "MMA", "defines", "two", "built-in", "types", "to", "be", "used", "as", "opaque", "vector", "types", "." ]

[ "rs6000", "\"U6__boolc\"", "\"U6__bools\"", "\"u7__pixel\"", "\"U6__booli\"", "\"U6__booll\"", "\"U10__float128\"", "\"g\"", "\"U10__float128\"", "\"g\"", "\"g\"" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "SlotSize", "=", "STI", ".", "is64Bit", "(", ")", "?", "8", ":", "4", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "CalleeFrameSize", "=", "0", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "CalleeFrameSize", "+=", "SlotSize", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "4", "0", "X86", "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "X86", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "const", "SDValue", "&", "getIndex", "(", ")", "const", "{", "return", "getOperand", "(", "4", ")", ";", "}", "</s>" ]

[ "Get", "the", "index", "built", "by", "pass", "." ]

[ "X86", "4" ]

[]

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

[ "True", "if", "subtarget", "inserts", "the", "final", "scheduling", "pass", "on", "its", "own", "." ]

[ "SystemZ" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_AArch64_WebKit_JS", ":", "RetCC_AArch64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "realRVLocIdx", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ",", "++", "realRVLocIdx", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "realRVLocIdx", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "if", "(", "Outs", "[", "i", "]", ".", "ArgVT", "==", "MVT", "::", "i1", ")", "{", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i1", ",", "Arg", ")", ";", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "}", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "const", "AArch64RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "I", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "&", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "if", "(", "I", ")", "{", "for", "(", ";", "*", "I", ";", "++", "I", ")", "{", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "*", "I", ",", "MVT", "::", "i64", ")", ")", ";", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "*", "I", ",", "MVT", "::", "getFloatingPointVT", "(", "64", ")", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "}", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::OutputArg", "AArch64", "AArch64", "16", "4", "1", "0", "0", "\"Can only return in registers!\"", "\"Unknown loc info!\"", "MVT::i1", "ISD::TRUNCATE", "MVT::i1", "ISD::ZERO_EXTEND", "ISD::BITCAST", "1", "AArch64", "AArch64::GPR64RegClass", "MVT::i64", "AArch64::FPR64RegClass", "MVT::getFloatingPointVT", "64", "\"Unexpected register class in CSRsViaCopy!\"", "0", "AArch64ISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "unsigned", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Asm", ",", "Fixup", ",", "Target", ",", "Value", ",", "IsResolved", ",", "Ctx", ",", "STI", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "const", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Kind", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "Endian", "==", "support", "::", "big", ")", "{", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Kind", ")", ";", "assert", "(", "(", "Offset", "+", "FullSizeBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FullSizeBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "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!\"", "support::big", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "support::little", "1", "8", "0xff" ]

[]

[ "<s>", "rtx", "pure_scalable_type_info", "::", "get_rtx", "(", "machine_mode", "mode", ",", "unsigned", "int", "first_zr", ",", "unsigned", "int", "first_pr", ")", "const", "{", "if", "(", "mode", "==", "pieces", "[", "0", "]", ".", "mode", ")", "{", "gcc_assert", "(", "pieces", ".", "length", "(", ")", "==", "1", ")", ";", "return", "pieces", "[", "0", "]", ".", "get_rtx", "(", "first_zr", ",", "first_pr", ")", ";", "}", "rtvec", "rtxes", "=", "rtvec_alloc", "(", "pieces", ".", "length", "(", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "pieces", ".", "length", "(", ")", ";", "++", "i", ")", "{", "rtx", "reg", "=", "pieces", "[", "i", "]", ".", "get_rtx", "(", "first_zr", ",", "first_pr", ")", ";", "rtx", "offset", "=", "gen_int_mode", "(", "pieces", "[", "i", "]", ".", "offset", ",", "Pmode", ")", ";", "RTVEC_ELT", "(", "rtxes", ",", "i", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "offset", ")", ";", "first_zr", "+=", "pieces", "[", "i", "]", ".", "num_zr", ";", "first_pr", "+=", "pieces", "[", "i", "]", ".", "num_pr", ";", "}", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "rtxes", ")", ";", "}", "</s>" ]

[ "Return", "the", "location", "of", "a", "PST", "that", "is", "known", "to", "be", "passed", "or", "returned", "in", "registers", ".", "FIRST_ZR", "is", "the", "first", "unused", "vector", "argument", "register", "and", "FIRST_PR", "is", "the", "first", "unused", "predicate", "argument", "register", "." ]

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

[]

[ "<s>", "bool", "ARMSubtarget", "::", "useDFAforSMS", "(", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Default", "to", "DFA", "for", "resource", "management", ",", "return", "false", "when", "target", "will", "use", "ProcResource", "in", "InstrSchedModel", "instead", "." ]

[ "ARM", "ARM" ]

[]

[ "<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", "(", ")", ";", "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", "=", "(", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "TargetFrameInfo", "&", "TFI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", ".", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Offset", "=", "FIOffset", "+", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "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", "3", "3", "3" ]

[]

[ "<s>", "llvm", "::", "FastISel", "*", "AArch64", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "FuncInfo", ",", "const", "TargetLibraryInfo", "*", "LibInfo", ")", "{", "return", "new", "AArch64FastISel", "(", "FuncInfo", ",", "LibInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "AArch64", "AArch64::createFastISel", "AArch64" ]

[]

[ "<s>", "void", "sh_emit_scc_to_t", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "t_reg", "=", "get_t_reg_rtx", "(", ")", ";", "enum", "rtx_code", "oldcode", "=", "code", ";", "switch", "(", "code", ")", "{", "case", "NE", ":", "gcc_unreachable", "(", ")", ";", "case", "LT", ":", "code", "=", "GT", ";", "break", ";", "case", "LE", ":", "code", "=", "GE", ";", "break", ";", "case", "LTU", ":", "code", "=", "GTU", ";", "break", ";", "case", "LEU", ":", "code", "=", "GEU", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "code", "!=", "oldcode", ")", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op1", ")", ";", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "(", "code", "!=", "EQ", "&&", "code", "!=", "NE", "&&", "(", "op1", "!=", "const0_rtx", "||", "code", "==", "GTU", "||", "code", "==", "GEU", "||", "code", "==", "LTU", "||", "code", "==", "LEU", ")", ")", "||", "(", "mode", "==", "DImode", "&&", "op1", "!=", "const0_rtx", ")", "||", "(", "TARGET_SH2E", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "sh_emit_set_t_insn", "(", "gen_rtx_SET", "(", "t_reg", ",", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op0", ",", "op1", ")", ")", ",", "mode", ")", ";", "}", "</s>" ]

[ "Prepare", "the", "operands", "for", "an", "scc", "instruction", ";", "make", "sure", "that", "the", "compare", "has", "been", "done", "and", "the", "result", "is", "in", "T_REG", "." ]

[ "sh" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_tfr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_tfrp", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "C2_or", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "SrcReg", "==", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_tfr", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "return", ";", "}", "if", "(", "Hexagon", "::", "CtrRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_tfrrcr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "C2_tfrpr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "C2_tfrrp", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::A2_tfr", "Hexagon::DoubleRegsRegClass", "Hexagon::A2_tfrp", "Hexagon::PredRegsRegClass", "Hexagon::C2_or", "Hexagon::DoubleRegsRegClass", "Hexagon::IntRegsRegClass", "Hexagon::subreg_loreg", "Hexagon::A2_tfrsi", "Hexagon::subreg_hireg", "0", "Hexagon::A2_tfr", "Hexagon::subreg_loreg", "Hexagon::A2_tfrsi", "Hexagon::subreg_hireg", "0", "Hexagon::CtrRegsRegClass", "Hexagon::IntRegsRegClass", "Hexagon::A2_tfrrcr", "Hexagon::PredRegsRegClass", "Hexagon::IntRegsRegClass", "Hexagon::C2_tfrpr", "Hexagon::IntRegsRegClass", "Hexagon::PredRegsRegClass", "Hexagon::C2_tfrrp", "\"Unimplemented\"" ]

[]

[ "<s>", "void", "StackPU2MCInstLower", "::", "lowerInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "MachineOperand", "const", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "MI", ".", "print", "(", "errs", "(", ")", ")", ";", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "Lowers", "a", "MachineInstr", "into", "a", "MCInst", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_save_callee_saves", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "start_offset", ",", "unsigned", "start", ",", "unsigned", "limit", ",", "bool", "skip_wb", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "(", "*", "gen_mem_ref", ")", "(", "machine_mode", ",", "rtx", ")", "=", "(", "frame_pointer_needed", "?", "gen_frame_mem", ":", "gen_rtx_MEM", ")", ";", "unsigned", "regno", ";", "unsigned", "regno2", ";", "for", "(", "regno", "=", "aarch64_next_callee_save", "(", "start", ",", "limit", ")", ";", "regno", "<=", "limit", ";", "regno", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ")", "{", "rtx", "reg", ",", "mem", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "skip_wb", "&&", "(", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "||", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ")", ")", "continue", ";", "if", "(", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno", "]", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "mem", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "regno2", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ";", "if", "(", "regno2", "<=", "limit", "&&", "!", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno2", "]", "&&", "(", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", "+", "UNITS_PER_WORD", ")", "==", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ")", ")", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "rtx", "mem2", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "mem2", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "insn", "=", "emit_insn", "(", "aarch64_gen_store_pair", "(", "mode", ",", "mem", ",", "reg", ",", "mem2", ",", "reg2", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", "=", "1", ";", "regno", "=", "regno2", ";", "}", "else", "insn", "=", "emit_move_insn", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "the", "callee-saved", "registers", "from", "register", "number", "START", "to", "LIMIT", "to", "the", "stack", "at", "the", "location", "starting", "at", "offset", "START_OFFSET", ",", "skipping", "any", "write-back", "candidates", "if", "SKIP_WB", "is", "true", "." ]

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

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "TailDuplicateID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createNVVMReflectPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createNVPTXImageOptimizerPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXAssignValidGlobalNamesPass", "(", ")", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXLowerArgsPass", "(", "&", "getNVPTXTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addAddressSpaceInferencePasses", "(", ")", ";", "if", "(", "!", "DisableLoadStoreVectorizer", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "AS", "=", "AMDGPU", "::", "getAMDGPUAS", "(", "M", ")", ";", "static", "const", "StringRef", "IntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.workitem.id.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workitem.id.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tgid.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.r600.read.tgid.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tidig.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.r600.read.tidig.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", "}", ";", "static", "const", "StringRef", "HSAIntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.dispatch.ptr\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.amdgcn.queue.ptr\"", ",", "\"amdgpu-queue-ptr\"", "}", ",", "{", "\"llvm.amdgcn.dispatch.id\"", ",", "\"amdgpu-dispatch-id\"", "}", ",", "{", "\"llvm.trap\"", ",", "\"amdgpu-queue-ptr\"", "}", ",", "{", "\"llvm.debugtrap\"", ",", "\"amdgpu-queue-ptr\"", "}", "}", ";", "bool", "Changed", "=", "addAttrsForIntrinsics", "(", "M", ",", "IntrinsicToAttr", ")", ";", "if", "(", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "||", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "Mesa3D", ")", "{", "Changed", "|=", "addAttrsForIntrinsics", "(", "M", ",", "HSAIntrinsicToAttr", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-queue-ptr\"", ")", ")", "continue", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "bool", "HasApertureRegs", "=", "TPC", "&&", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ".", "hasApertureRegs", "(", ")", ";", "if", "(", "!", "HasApertureRegs", "&&", "hasAddrSpaceCast", "(", "F", ",", "AS", ")", ")", "F", ".", "addFnAttr", "(", "\"amdgpu-queue-ptr\"", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::getAMDGPUAS", "2", "\"llvm.amdgcn.workitem.id.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.amdgcn.workitem.id.z\"", "\"amdgpu-work-item-id-z\"", "\"llvm.amdgcn.workgroup.id.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.amdgcn.workgroup.id.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tgid.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.r600.read.tgid.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tidig.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.r600.read.tidig.z\"", "\"amdgpu-work-item-id-z\"", "2", "\"llvm.amdgcn.dispatch.ptr\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.amdgcn.queue.ptr\"", "\"amdgpu-queue-ptr\"", "\"llvm.amdgcn.dispatch.id\"", "\"amdgpu-dispatch-id\"", "\"llvm.trap\"", "\"amdgpu-queue-ptr\"", "\"llvm.debugtrap\"", "\"amdgpu-queue-ptr\"", "\"amdgpu-queue-ptr\"", "AMDGPU", "\"amdgpu-queue-ptr\"" ]

[]

[ "<s>", "static", "bool", "spu_addr_space_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "reg_ok_strict", ",", "addr_space_t", "as", ")", "{", "if", "(", "as", "==", "ADDR_SPACE_EA", ")", "return", "(", "REG_P", "(", "x", ")", "&&", "(", "GET_MODE", "(", "x", ")", "==", "EAmode", ")", ")", ";", "else", "if", "(", "as", "!=", "ADDR_SPACE_GENERIC", ")", "gcc_unreachable", "(", ")", ";", "return", "spu_legitimate_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ")", ";", "}", "</s>" ]

[ "Like", "spu_legitimate_address_p", ",", "except", "with", "named", "addresses", "." ]

[ "spu" ]

[]

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

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

[ "Hexagon", "Hexagon", "0", "1", "\"Bad Memop.\"", "0", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "setForcedEncodingSize", "(", "0", ")", ";", "if", "(", "Name", ".", "endswith", "(", "\"_e64\"", ")", ")", "setForcedEncodingSize", "(", "64", ")", ";", "else", "if", "(", "Name", ".", "endswith", "(", "\"_e32\"", ")", ")", "setForcedEncodingSize", "(", "32", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "AMDGPUAsmParser", "::", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "switch", "(", "Res", ")", "{", "case", "MatchOperand_Success", ":", "break", ";", "case", "MatchOperand_ParseFail", ":", "return", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"failed parsing operand.\"", ")", ";", "case", "MatchOperand_NoMatch", ":", "return", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"not a valid operand.\"", ")", ";", "}", "}", "AMDGPUAsmParser", "::", "OperandMatchResultTy", "Res", ";", "while", "(", "(", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "!=", "MatchOperand_NoMatch", ")", "{", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "return", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"failed parsing operand.\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "0", "\"_e64\"", "64", "\"_e32\"", "32", "\"failed parsing operand.\"", "\"not a valid operand.\"", "\"failed parsing operand.\"" ]

[]

[ "<s>", "static", "bool", "s390_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "if", "(", "from", "==", "BASE_REGNUM", "&&", "to", "==", "BASE_REGNUM", ")", "{", "s390_init_frame_layout", "(", ")", ";", "return", "cfun", "->", "machine", "->", "base_reg", "==", "NULL_RTX", ";", "}", "gcc_assert", "(", "to", "==", "STACK_POINTER_REGNUM", "||", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", ";", "gcc_assert", "(", "from", "==", "FRAME_POINTER_REGNUM", "||", "from", "==", "ARG_POINTER_REGNUM", "||", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", ";", "if", "(", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", "if", "(", "!", "crtl", "->", "calls_eh_return", "&&", "!", "cfun", "->", "stdarg", "&&", "!", "cfun_frame_layout", ".", "save_return_addr_p", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "FROM", "can", "be", "eliminated", "via", "register", "TO", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "X86RetpolineThunks", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "Is64Bit", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "Module", "&", "M", "=", "const_cast", "<", "Module", "&", ">", "(", "*", "MMI", "->", "getModule", "(", ")", ")", ";", "if", "(", "!", "MF", ".", "getName", "(", ")", ".", "startswith", "(", "ThunkNamePrefix", ")", ")", "{", "if", "(", "InsertedThunks", ")", "return", "false", ";", "if", "(", "!", "STI", "->", "useRetpoline", "(", ")", "||", "STI", "->", "useRetpolineExternalThunk", "(", ")", ")", "return", "false", ";", "if", "(", "Is64Bit", ")", "createThunkFunction", "(", "M", ",", "R11ThunkName", ")", ";", "else", "for", "(", "StringRef", "Name", ":", "{", "EAXThunkName", ",", "ECXThunkName", ",", "EDXThunkName", ",", "EDIThunkName", "}", ")", "createThunkFunction", "(", "M", ",", "Name", ")", ";", "InsertedThunks", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Is64Bit", ")", "{", "assert", "(", "MF", ".", "getName", "(", ")", "==", "\"__llvm_retpoline_r11\"", "&&", "\"Should only have an r11 thunk on 64-bit targets\"", ")", ";", "populateThunk", "(", "MF", ",", "X86", "::", "R11", ")", ";", "}", "else", "{", "if", "(", "MF", ".", "getName", "(", ")", "==", "EAXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EAX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "ECXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "ECX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDIThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDI", ")", ";", "else", "llvm_unreachable", "(", "\"Invalid thunk name on x86-32!\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"__llvm_retpoline_r11\"", "\"Should only have an r11 thunk on 64-bit targets\"", "X86::R11", "X86::EAX", "X86::ECX", "X86::EDX", "X86::EDI", "\"Invalid thunk name on x86-32!\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'d'", ":", "case", "'y'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "{", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU16RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR32RegClass", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", "->", "isSingleFloat", "(", ")", ")", ")", "{", "if", "(", "Subtarget", "->", "isFP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "AFGR64RegClass", ")", ";", "}", "break", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Unexpected type.\"", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9_64", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "case", "'l'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO", ",", "&", "Mips", "::", "HILORegClass", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO64", ",", "&", "Mips", "::", "HILO64RegClass", ")", ";", "case", "'x'", ":", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "0", "MVT::i32", "MVT::i16", "MVT::i8", "Mips", "0U", "Mips::CPU16RegsRegClass", "0U", "Mips::CPURegsRegClass", "MVT::i64", "Mips", "0U", "Mips::CPURegsRegClass", "MVT::i64", "Mips", "0U", "Mips::CPU64RegsRegClass", "0u", "0", "MVT::f32", "0U", "Mips::FGR32RegClass", "MVT::f64", "0U", "Mips::FGR64RegClass", "0U", "Mips::AFGR64RegClass", "MVT::i32", "Mips::T9", "Mips::CPURegsRegClass", "MVT::i64", "\"Unexpected type.\"", "Mips::T9_64", "Mips::CPU64RegsRegClass", "MVT::i32", "Mips::LO", "Mips::HILORegClass", "Mips::LO64", "Mips::HILO64RegClass", "0u", "0" ]

[]

[ "<s>", "const", "char", "*", "output_fix_trunc", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "bool", "fisttp", ")", "{", "int", "stack_top_dies", "=", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "FIRST_STACK_REG", ")", "!=", "0", ";", "int", "dimode_p", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "DImode", ";", "int", "round_mode", "=", "get_attr_i387_cw", "(", "insn", ")", ";", "if", "(", "(", "dimode_p", "||", "fisttp", ")", "&&", "!", "stack_top_dies", ")", "output_asm_insn", "(", "\"fld\\t%y1\"", ",", "operands", ")", ";", "gcc_assert", "(", "STACK_TOP_P", "(", "operands", "[", "1", "]", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "operands", "[", "1", "]", ")", "!=", "TFmode", ")", ";", "if", "(", "fisttp", ")", "output_asm_insn", "(", "\"fisttp%Z0\\t%0\"", ",", "operands", ")", ";", "else", "{", "if", "(", "round_mode", "!=", "I387_CW_ANY", ")", "output_asm_insn", "(", "\"fldcw\\t%3\"", ",", "operands", ")", ";", "if", "(", "stack_top_dies", "||", "dimode_p", ")", "output_asm_insn", "(", "\"fistp%Z0\\t%0\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"fist%Z0\\t%0\"", ",", "operands", ")", ";", "if", "(", "round_mode", "!=", "I387_CW_ANY", ")", "output_asm_insn", "(", "\"fldcw\\t%2\"", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "code", "for", "INSN", "to", "convert", "a", "float", "to", "a", "signed", "int", ".", "OPERANDS", "are", "the", "insn", "operands", ".", "The", "output", "may", "be", "[", "HSD", "]", "Imode", "and", "the", "input", "operand", "may", "be", "[", "SDX", "]", "Fmode", "." ]

[ "i386", "0", "0", "\"fld\\t%y1\"", "1", "0", "1", "\"fisttp%Z0\\t%0\"", "\"fldcw\\t%3\"", "\"fistp%Z0\\t%0\"", "\"fist%Z0\\t%0\"", "\"fldcw\\t%2\"", "\"\"" ]

[]

[ "<s>", "static", "tree", "get_prev_label", "(", "tree", "function_name", ")", "{", "branch_island", "*", "bi", ";", "unsigned", "ix", ";", "FOR_EACH_VEC_SAFE_ELT", "(", "branch_islands", ",", "ix", ",", "bi", ")", "if", "(", "function_name", "==", "bi", "->", "function_name", ")", "return", "bi", "->", "label_name", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "GET_PREV_LABEL", "gets", "the", "label", "name", "from", "the", "previous", "definition", "of", "the", "function", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "Register", "X86TargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "if", "(", "classifyEHPersonality", "(", "PersonalityFn", ")", "==", "EHPersonality", "::", "CoreCLR", ")", "return", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RDX", ":", "X86", "::", "EDX", ";", "return", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "X86", "X86", "X86::RDX", "X86::EDX", "X86::RAX", "X86::EAX" ]

[]

[ "<s>", "bool", "M88kFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ")", "return", "true", ";", "return", "(", "MFI", ".", "hasCalls", "(", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k" ]

[]

[ "<s>", "static", "bool", "need_to_save_reg", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "flag_pic", "&&", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "||", "regno", "==", "TILEGX_PIC_TEXT_LABEL_REGNUM", ")", "&&", "(", "crtl", "->", "uses_pic_offset_table", "||", "crtl", "->", "saves_all_registers", ")", ")", "return", "true", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "i", ";", "for", "(", "i", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "i", ")", "!=", "INVALID_REGNUM", ";", "i", "++", ")", "{", "if", "(", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "i", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "REGNO", "needs", "to", "be", "saved", "in", "the", "stack", "frame", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "TL45AsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"fixup_tl45_hi16_i\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_tl45_lo16_i\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_tl45_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "}", ";", "static_assert", "(", "(", "array_lengthof", "(", "Infos", ")", ")", "==", "TL45", "::", "NumTargetFixupKinds", ",", "\"Not all fixup kinds added to Infos array\"", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "TL45", "TL45", "\"fixup_tl45_hi16_i\"", "0", "16", "0", "\"fixup_tl45_lo16_i\"", "0", "16", "0", "\"fixup_tl45_32\"", "0", "32", "0", "TL45::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "CAHPAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "(", "Count", "%", "2", ")", "!=", "0", ")", "return", "false", ";", "Count", "/=", "2", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "++", "i", ")", "OS", ".", "write", "(", "\"\\0\\0\"", ",", "2", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "2", "0", "2", "0", "\"\\0\\0\"", "2" ]

[]

[ "<s>", "SDNode", "*", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "NULL", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "SelectConstantFP", "(", "N", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "SelectAdd", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "SelectSelect", "(", "N", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "SelectTruncate", "(", "N", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "SelectMul", "(", "N", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "SelectZeroExtend", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::ADD", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::SELECT", "ISD::TRUNCATE", "ISD::MUL", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "static", "void", "vax_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "if", "(", "write_symbols", "==", "DBX_DEBUG", ")", "fprintf", "(", "asm_out_file", ",", "\"___vax_%c_doubles:\\n\"", ",", "ASM_DOUBLE_CHAR", ")", ";", "}", "</s>" ]

[ "When", "debugging", "with", "stabs", ",", "we", "want", "to", "output", "an", "extra", "dummy", "label", "so", "that", "gas", "can", "distinguish", "between", "D_float", "and", "G_float", "prior", "to", "processing", "the", ".stabs", "directive", "identifying", "type", "double", "." ]

[ "vax", "\"___vax_%c_doubles:\\n\"" ]

[]

[ "<s>", "static", "const", "char", "*", "singlemove_string", "(", "rtx", "*", "operands", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "return", "output_move_simode_const", "(", "operands", ")", ";", "return", "\"move%.l %1,%0\"", ";", "}", "</s>" ]

[ "Return", "the", "best", "assembler", "insn", "template", "for", "moving", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "as", "a", "fullword", "." ]

[ "m68k", "1", "\"move%.l %1,%0\"" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "auto", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__memory_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__table_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_size\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_align\"", ")", "==", "0", ")", "{", "bool", "Mutable", "=", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_base\"", ")", "==", "0", ";", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "WasmSym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "WASM_TYPE_I64", ":", "wasm", "::", "WASM_TYPE_I32", ")", ",", "Mutable", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__cpp_exception\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_EVENT", ")", ";", "WasmSym", "->", "setEventType", "(", "{", "wasm", "::", "WASM_EVENT_ATTRIBUTE_EXCEPTION", ",", "0", "}", ")", ";", "WasmSym", "->", "setWeak", "(", "true", ")", ";", "WasmSym", "->", "setExternal", "(", "true", ")", ";", "Params", ".", "push_back", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ")", ";", "}", "else", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ")", ";", "getLibcallSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "}", "auto", "Signature", "=", "std", "::", "make_unique", "<", "wasm", "::", "WasmSignature", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "\"__tls_base\"", "0", "\"__memory_base\"", "0", "\"__table_base\"", "0", "\"__tls_size\"", "0", "\"__tls_align\"", "0", "\"__stack_pointer\"", "0", "\"__tls_base\"", "0", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType", "wasm::WASM_TYPE_I64", "wasm::WASM_TYPE_I32", "wasm::ValType", "4", "wasm::ValType", "4", "\"__cpp_exception\"", "0", "wasm::WASM_SYMBOL_TYPE_EVENT", "wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION", "0", "wasm::ValType", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WasmSignature" ]

[]

[ "<s>", "void", "tilepro_expand_insv", "(", "rtx", "operands", "[", "4", "]", ")", "{", "rtx", "first_rtx", "=", "operands", "[", "2", "]", ";", "HOST_WIDE_INT", "first", "=", "INTVAL", "(", "first_rtx", ")", ";", "HOST_WIDE_INT", "width", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "rtx", "v", "=", "operands", "[", "3", "]", ";", "if", "(", "first", "!=", "0", ")", "{", "if", "(", "CONST_INT_P", "(", "v", ")", ")", "{", "v", "=", "gen_int_si", "(", "INTVAL", "(", "v", ")", "<<", "first", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "tmp", ",", "v", ",", "first_rtx", ")", ")", ";", "v", "=", "tmp", ";", "}", "}", "emit_insn", "(", "gen_insn_mm", "(", "operands", "[", "0", "]", ",", "v", ",", "operands", "[", "0", "]", ",", "first_rtx", ",", "GEN_INT", "(", "first", "+", "width", "-", "1", ")", ")", ")", ";", "}", "</s>" ]

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

[ "tilepro", "4", "2", "1", "3", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "rs6000_attribute_takes_identifier_p", "(", "const_tree", "attr_id", ")", "{", "return", "is_attribute_p", "(", "\"altivec\"", ",", "attr_id", ")", ";", "}", "</s>" ]

[ "Returns", "TRUE", "iff", "the", "target", "attribute", "indicated", "by", "ATTR_ID", "takes", "a", "plain", "identifier", "as", "an", "argument", ",", "so", "the", "front", "end", "should", "n't", "look", "it", "up", "." ]

[ "powerpcspe", "\"altivec\"" ]

[]