Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "X86FrameLowering", "::", "canUseAsPrologue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "MBB", ".", "getParent", "(", ")", "&&", "\"Block is not attached to a function!\"", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "!", "MBB", ".", "isLiveIn", "(", "X86", "::", "EFLAGS", ")", ")", "return", "true", ";", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "return", "!", "TRI", "->", "hasStackRealignment", "(", "MF", ")", "&&", "!", "X86FI", "->", "hasSwiftAsyncContext", "(", ")", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "prologue", "for", "the", "target", "." ]

[ "X86", "X86", "\"Block is not attached to a function!\"", "X86::EFLAGS", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "int", "ia64_load_pair_ok", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "if", "(", "GET_CODE", "(", "dst", ")", "!=", "REG", "||", "!", "FP_REGNO_P", "(", "REGNO", "(", "dst", ")", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "src", ")", "!=", "MEM", "||", "MEM_VOLATILE_P", "(", "src", ")", ")", "return", "0", ";", "switch", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "{", "case", "REG", ":", "case", "POST_INC", ":", "break", ";", "case", "POST_DEC", ":", "return", "0", ";", "case", "POST_MODIFY", ":", "{", "rtx", "adjust", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "adjust", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "adjust", ")", "!=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "src", ")", ")", ")", "return", "0", ";", "}", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "operands", "are", "ok", "for", "a", "floating", "point", "load", "pair", "." ]

[ "ia64", "0", "0", "0", "0", "0", "1", "1", "0", "1" ]

[]

[ "<s>", "bool", "ok_for_simple_move_operands", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "!", "register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "visium_flags_exposed", "&&", "gpc_reg_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "gpc_reg_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "operands", "are", "valid", "for", "a", "simple", "move", "insn", "." ]

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

[]

[ "<s>", "static", "rtx", "move_acc_to_reg", "(", "rtx", "acc", ",", "int", "regno", ",", "rtx", "before", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "acc", ")", ";", "rtx", "reg", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "return", "gen_and_emit_move", "(", "reg", ",", "acc", ",", "before", ",", "true", ")", ";", "}", "</s>" ]

[ "Copy", "accumulator", "(", "A", "or", "AX", ")", "to", "REGNO", ",", "placing", "any", "generated", "insns", "before", "BEFORE", ".", "Returns", "reg", "RTX", "." ]

[ "rl78" ]

[]

[ "<s>", "void", "altivec_expand_lvx_be", "(", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "mode", ",", "unsigned", "unspec", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "load", "=", "gen_rtx_SET", "(", "tmp", ",", "op1", ")", ";", "rtx", "lvx", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "unspec", ")", ";", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "load", ",", "lvx", ")", ")", ";", "rtx", "sel", "=", "swap_selector_for_mode", "(", "mode", ")", ";", "rtx", "vperm", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "tmp", ",", "tmp", ",", "sel", ")", ",", "UNSPEC_VPERM", ")", ";", "gcc_assert", "(", "REG_P", "(", "op0", ")", ")", ";", "emit_insn", "(", "par", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "vperm", ")", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "an", "``", "lvx", "''", ",", "``", "lvxl", "''", ",", "or", "``", "lve", "*", "x", "''", "built-in", "for", "a", "little", "endian", "target", "with", "-maltivec=be", "specified", ".", "Issue", "the", "load", "followed", "by", "an", "element-reversing", "permute", "." ]

[ "powerpcspe", "1", "2", "3" ]

[]

[ "<s>", "const", "MIRFormatter", "*", "getMIRFormatter", "(", ")", "const", "override", "{", "if", "(", "!", "Formatter", ".", "get", "(", ")", ")", "Formatter", "=", "std", "::", "make_unique", "<", "AMDGPUMIRFormatter", ">", "(", ")", ";", "return", "Formatter", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "MIR", "formatter", "to", "format/parse", "MIR", "operands", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "const", "uint32_t", "*", "PPCRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "pairedVectorMemops", "(", ")", ")", "return", "CSR_64_AllRegs_VSRP_RegMask", ";", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", "&&", "!", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", ")", "return", "CSR_64_AllRegs_AIX_Dflt_VSX_RegMask", ";", "return", "CSR_64_AllRegs_VSX_RegMask", ";", "}", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", "&&", "!", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", ")", "return", "CSR_64_AllRegs_AIX_Dflt_Altivec_RegMask", ";", "return", "CSR_64_AllRegs_Altivec_RegMask", ";", "}", "return", "CSR_64_AllRegs_RegMask", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", ")", "?", "CSR_PPC64_Altivec_RegMask", ":", "CSR_PPC64_RegMask", ")", ":", "(", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", ")", "?", "CSR_AIX32_Altivec_RegMask", ":", "CSR_AIX32_RegMask", ")", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "Cold", ")", "{", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "return", "Subtarget", ".", "pairedVectorMemops", "(", ")", "?", "CSR_SVR64_ColdCC_VSRP_RegMask", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR64_ColdCC_Altivec_RegMask", ":", "CSR_SVR64_ColdCC_RegMask", ")", ";", "else", "return", "Subtarget", ".", "pairedVectorMemops", "(", ")", "?", "CSR_SVR32_ColdCC_VSRP_RegMask", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR32_ColdCC_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR32_ColdCC_SPE_RegMask", ":", "CSR_SVR32_ColdCC_RegMask", ")", ")", ";", "}", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "return", "Subtarget", ".", "pairedVectorMemops", "(", ")", "?", "CSR_SVR464_VSRP_RegMask", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_PPC64_Altivec_RegMask", ":", "CSR_PPC64_RegMask", ")", ";", "else", "return", "Subtarget", ".", "pairedVectorMemops", "(", ")", "?", "CSR_SVR432_VSRP_RegMask", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR432_SPE_RegMask", ":", "CSR_SVR432_RegMask", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "{", "if", "(", "TLI", ".", "isPositionIndependent", "(", ")", ")", "return", "0", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "Subtarget", "->", "hasAddr64", "(", ")", "?", "&", "WebAssembly", "::", "I64RegClass", ":", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "unsigned", "Opc", "=", "Subtarget", "->", "hasAddr64", "(", ")", "?", "WebAssembly", "::", "CONST_I64", ":", "WebAssembly", "::", "CONST_I32", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addGlobalAddress", "(", "GV", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "WebAssembly::I64RegClass", "WebAssembly::I32RegClass", "WebAssembly::CONST_I64", "WebAssembly::CONST_I32", "0" ]

[]

[ "<s>", "virtual", "const", "ARCompactRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "ARCompact", "ARC" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "const", "MCInstrInfo", "*", "MCII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MCInstrDesc", "const", "&", "Desc", "=", "MCII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "auto", "&", "OI", ":", "enumerate", "(", "Desc", ".", "operands", "(", ")", ")", ")", "{", "unsigned", "OpType", "=", "OI", ".", "value", "(", ")", ".", "OperandType", ";", "if", "(", "OpType", ">=", "RISCVOp", "::", "OPERAND_FIRST_RISCV_IMM", "&&", "OpType", "<=", "RISCVOp", "::", "OPERAND_LAST_RISCV_IMM", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OI", ".", "index", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "bool", "Ok", ";", "switch", "(", "OpType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected operand type\"", ")", ";", "case", "RISCVOp", "::", "OPERAND_UIMM4", ":", "Ok", "=", "isUInt", "<", "4", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM5", ":", "Ok", "=", "isUInt", "<", "5", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM12", ":", "Ok", "=", "isUInt", "<", "12", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_SIMM12", ":", "Ok", "=", "isInt", "<", "12", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_SIMM13_LSB0", ":", "Ok", "=", "isShiftedInt", "<", "12", ",", "1", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM20", ":", "Ok", "=", "isUInt", "<", "20", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_SIMM21_LSB0", ":", "Ok", "=", "isShiftedInt", "<", "20", ",", "1", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMMLOG2XLEN", ":", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", ")", "Ok", "=", "isUInt", "<", "6", ">", "(", "Imm", ")", ";", "else", "Ok", "=", "isUInt", "<", "5", ">", "(", "Imm", ")", ";", "break", ";", "}", "if", "(", "!", "Ok", ")", "{", "ErrInfo", "=", "\"Invalid immediate\"", ";", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVOp::OPERAND_FIRST_RISCV_IMM", "RISCVOp::OPERAND_LAST_RISCV_IMM", "\"Unexpected operand type\"", "RISCVOp::OPERAND_UIMM4", "4", "RISCVOp::OPERAND_UIMM5", "5", "RISCVOp::OPERAND_UIMM12", "12", "RISCVOp::OPERAND_SIMM12", "12", "RISCVOp::OPERAND_SIMM13_LSB0", "12", "1", "RISCVOp::OPERAND_UIMM20", "20", "RISCVOp::OPERAND_SIMM21_LSB0", "20", "1", "RISCVOp::OPERAND_UIMMLOG2XLEN", "6", "5", "\"Invalid immediate\"" ]

[]

[ "<s>", "static", "void", "fold_compare_helper", "(", "gimple_stmt_iterator", "*", "gsi", ",", "tree_code", "code", ",", "gimple", "*", "stmt", ")", "{", "tree", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "0", ")", ";", "tree", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "1", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "tree", "cmp", "=", "fold_build_vec_cmp", "(", "code", ",", "TREE_TYPE", "(", "lhs", ")", ",", "arg0", ",", "arg1", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "cmp", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "handle", "the", "in-between", "steps", "for", "the", "vector", "compare", "built-ins", "." ]

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

[]

[ "<s>", "const", "CallLowering", "*", "getCallLowering", "(", ")", "const", "override", "{", "return", "&", "CallLoweringInfo", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "MOS" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AS", ")", "{", "case", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ":", "{", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", ">=", "SISubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "}", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "}", "case", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ":", "{", "if", "(", "AM", ".", "BaseOffs", "%", "4", "!=", "0", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Ty", ")", "<", "4", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "SISubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "8", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "SISubtarget", "::", "SEA_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "32", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "SISubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "20", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "}", "else", "llvm_unreachable", "(", "\"unhandled generation\"", ")", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ":", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "case", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "case", "AMDGPUAS", "::", "REGION_ADDRESS", ":", "{", "if", "(", "!", "isUInt", "<", "16", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUAS", "::", "FLAT_ADDRESS", ":", "case", "AMDGPUAS", "::", "UNKNOWN_ADDRESS_SPACE", ":", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unhandled address space\"", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "SI", "AMDGPU", "4", "0", "4", "SI", "8", "4", "SI", "32", "4", "SI", "20", "\"unhandled generation\"", "0", "1", "AMDGPU", "AMDGPU", "AMDGPU", "16", "0", "1", "AMDGPU", "AMDGPU", "\"unhandled address space\"" ]

[]

[ "<s>", "void", "MipsPreLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "rs6000_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "switch", "(", "size", ")", "{", "case", "4", ":", "fputs", "(", "\"\\t.long\\t\"", ",", "file", ")", ";", "break", ";", "case", "8", ":", "fputs", "(", "DOUBLE_INT_ASM_OP", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "output_addr_const", "(", "file", ",", "x", ")", ";", "if", "(", "TARGET_ELF", ")", "fputs", "(", "\"@dtprel+0x8000\"", ",", "file", ")", ";", "else", "if", "(", "TARGET_XCOFF", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "switch", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "{", "case", "0", ":", "break", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "fputs", "(", "\"@le\"", ",", "file", ")", ";", "break", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "fputs", "(", "\"@ie\"", ",", "file", ")", ";", "break", ";", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "fputs", "(", "\"@m\"", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "This", "is", "called", "from", "dwarf2out.c", "via", "TARGET_ASM_OUTPUT_DWARF_DTPREL", ".", "We", "need", "to", "emit", "DTP-relative", "relocations", "." ]

[ "rs6000", "4", "\"\\t.long\\t\"", "8", "\"@dtprel+0x8000\"", "0", "\"@le\"", "\"@ie\"", "\"@m\"" ]

[]

[ "<s>", "static", "void", "xtensa_function_arg_advance", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "int", "words", ",", "max", ";", "int", "*", "arg_words", ";", "arg_words", "=", "&", "get_cumulative_args", "(", "cum", ")", "->", "arg_words", ";", "max", "=", "MAX_ARGS_IN_REGISTERS", ";", "words", "=", "(", "(", "arg", ".", "promoted_size_in_bytes", "(", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "if", "(", "*", "arg_words", "<", "max", "&&", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", "||", "*", "arg_words", "+", "words", ">", "max", ")", ")", "*", "arg_words", "=", "max", ";", "*", "arg_words", "+=", "words", ";", "}", "</s>" ]

[ "Advance", "the", "argument", "to", "the", "next", "argument", "position", "." ]

[ "xtensa", "1" ]

[]

[ "<s>", "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STM", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "STM", "->", "loadStoreOptEnabled", "(", ")", ")", "return", "false", ";", "TII", "=", "STM", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Must be run on SSA\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SILoadStoreOptimizer\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "do", "{", "OptimizeAgain", "=", "false", ";", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "}", "while", "(", "OptimizeAgain", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"Must be run on SSA\"", "\"Running SILoadStoreOptimizer\\n\"" ]

[]

[ "<s>", "bool", "MipsAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "OS", ".", "write_zeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "KILLGT", ")", "{", "return", "false", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", "{", "if", "(", "MI", "->", "getParent", "(", ")", "->", "begin", "(", ")", "!=", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "!=", "0", "||", "MI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "!=", "0", ")", "return", "false", ";", "return", "true", ";", "}", "else", "if", "(", "isVector", "(", "*", "MI", ")", ")", "{", "return", "false", ";", "}", "else", "{", "return", "AMDGPUInstrInfo", "::", "isPredicable", "(", "MI", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "AMDGPU", "R600", "AMDGPU::KILLGT", "AMDGPU::CF_ALU", "3", "0", "4", "0", "AMDGPU" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerCRSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "bool", "LP64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "MFOCRF8", ":", "PPC", "::", "MFOCRF", ")", ",", "Reg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ")", ")", ";", "if", "(", "SrcReg", "!=", "PPC", "::", "CR0", ")", "{", "unsigned", "Reg1", "=", "Reg", ";", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "RLWINM8", ":", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg1", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "getEncodingValue", "(", "SrcReg", ")", "*", "4", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ";", "}", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "STW8", ":", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ",", "FrameIndex", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerCRSpilling", "-", "Generate", "the", "code", "for", "spilling", "a", "CR", "register", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "0", "PPC::MFOCRF8", "PPC::MFOCRF", "0", "PPC::CR0", "PPC::RLWINM8", "PPC::RLWINM", "4", "0", "31", "PPC::STW8", "PPC::STW" ]

[]

[ "<s>", "static", "void", "alpha_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", ",", "mem", ",", "word1", ",", "word2", ";", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "fnaddr", "=", "convert_memory_address", "(", "Pmode", ",", "fnaddr", ")", ";", "chain_value", "=", "convert_memory_address", "(", "Pmode", ",", "chain_value", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "{", "const", "char", "*", "fnname", ";", "char", "*", "trname", ";", "fnname", "=", "XSTR", "(", "fnaddr", ",", "0", ")", ";", "trname", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "fnname", ")", "+", "5", ")", ";", "strcpy", "(", "trname", ",", "fnname", ")", ";", "strcat", "(", "trname", ",", "\"..tr\"", ")", ";", "fnname", "=", "ggc_alloc_string", "(", "trname", ",", "strlen", "(", "trname", ")", "+", "1", ")", ";", "word2", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "fnname", ")", ";", "word1", "=", "force_reg", "(", "DImode", ",", "gen_const_mem", "(", "DImode", ",", "fnaddr", ")", ")", ";", "word1", "=", "expand_and", "(", "DImode", ",", "word1", ",", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0xffff0fff0000fff0", ")", ")", ",", "NULL", ")", ";", "}", "else", "{", "word1", "=", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0xa77b0010a43b0018", ")", ")", ";", "word2", "=", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0x47ff041f6bfb0000", ")", ")", ";", "}", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "word1", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "8", ")", ";", "emit_move_insn", "(", "mem", ",", "word2", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "16", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "24", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "if", "(", "TARGET_ABI_OSF", ")", "{", "emit_insn", "(", "gen_imb", "(", ")", ")", ";", "emit_library_call", "(", "init_one_libfunc", "(", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "Pmode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "M_TRAMP", ".", "FNDECL", "is", "target", "function", "'s", "decl", ".", "CHAIN_VALUE", "is", "an", "rtx", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "alpha", "0", "0", "5", "\"..tr\"", "1", "0xffff0fff0000fff0", "0xa77b0010a43b0018", "0x47ff041f6bfb0000", "0", "8", "16", "24", "\"__enable_execute_stack\"", "0" ]

[]

[ "<s>", "static", "void", "expand_block_set_2", "(", "rtx", "dst", ",", "rtx", "dst_reg", ",", "rtx", "value_rtx", ",", "rtx", "bytes_rtx", ")", "{", "unsigned", "HOST_WIDE_INT", "bytes", "=", "UINTVAL", "(", "bytes_rtx", ")", ";", "unsigned", "int", "rem", "=", "bytes", "%", "2", ";", "value_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "value_rtx", ",", "1", ")", ";", "emit_library_call", "(", "wrd_memset_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "dst_reg", ",", "Pmode", ",", "value_rtx", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "GEN_INT", "(", "bytes", ">>", "1", ")", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "if", "(", "rem", "==", "0", ")", "return", ";", "dst", "=", "replace_equiv_address_nv", "(", "dst", ",", "dst_reg", ")", ";", "bytes", "-=", "rem", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "convert_to_mode", "(", "QImode", ",", "value_rtx", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "set", "BYTES_RTX", "bytes", "of", "DST", "with", "address", "DST_REG", "to", "VALUE_RTX", "in", "2-byte", "chunks", "." ]

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

[]

[ "<s>", "void", "RISCVDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "MVT", "XLenVT", "=", "Subtarget", "->", "getXLenVT", "(", ")", ";", "SDLoc", "DL", "(", "Node", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "Constant", ":", "{", "auto", "ConstNode", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "if", "(", "VT", "==", "XLenVT", "&&", "ConstNode", "->", "isNullValue", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "RISCV", "::", "X0", ",", "XLenVT", ")", ";", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "return", ";", "}", "int64_t", "Imm", "=", "ConstNode", "->", "getSExtValue", "(", ")", ";", "if", "(", "XLenVT", "==", "MVT", "::", "i64", ")", "{", "ReplaceNode", "(", "Node", ",", "selectImm", "(", "CurDAG", ",", "SDLoc", "(", "Node", ")", ",", "Imm", ",", "XLenVT", ")", ")", ";", "return", ";", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "Imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "DL", ",", "XLenVT", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "RISCV", "::", "ADDI", ",", "DL", ",", "VT", ",", "TFI", ",", "Imm", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "SRL", ":", "{", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "break", ";", "SDValue", "Op0", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Op1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "uint64_t", "Mask", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "&&", "isConstantMask", "(", "Op0", ".", "getNode", "(", ")", ",", "Mask", ")", ")", "{", "uint64_t", "ShAmt", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op1", ".", "getNode", "(", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "(", "Mask", "|", "maskTrailingOnes", "<", "uint64_t", ">", "(", "ShAmt", ")", ")", "==", "0xffffffff", ")", "{", "SDValue", "ShAmtVal", "=", "CurDAG", "->", "getTargetConstant", "(", "ShAmt", ",", "SDLoc", "(", "Node", ")", ",", "XLenVT", ")", ";", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "RISCV", "::", "SRLIW", ",", "XLenVT", ",", "Op0", ".", "getOperand", "(", "0", ")", ",", "ShAmtVal", ")", ";", "return", ";", "}", "}", "break", ";", "}", "case", "RISCVISD", "::", "READ_CYCLE_WIDE", ":", "assert", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "\"READ_CYCLE_WIDE is only used on riscv32\"", ")", ";", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "RISCV", "::", "ReadCycleWide", ",", "DL", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Node", "->", "getOperand", "(", "0", ")", ")", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"== \"", "\"\\n\"", "1", "0", "ISD::Constant", "RISCV::X0", "MVT::i64", "ISD::FrameIndex", "0", "RISCV::ADDI", "ISD::SRL", "0", "1", "ISD::Constant", "0xffffffff", "RISCV::SRLIW", "0", "RISCVISD::READ_CYCLE_WIDE", "\"READ_CYCLE_WIDE is only used on riscv32\"", "RISCV::ReadCycleWide", "MVT::i32", "MVT::i32", "MVT::Other", "0" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "k_Register", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "ARM64", "\"Invalid access!\"" ]

[]

[ "<s>", "bool", "arm_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TLS", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "arm", "0", "1" ]

[]

[ "<s>", "bool", "hasAndNot", "(", "SDValue", "Y", ")", "const", "override", "{", "EVT", "VT", "=", "Y", ".", "getValueType", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "hasAndNotCompare", "(", "Y", ")", ";", "return", "VT", ".", "getSizeInBits", "(", ")", ">=", "64", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "a", "bitwise", "and-not", "operation", ":", "X", "=", "~A", "&", "B", "This", "can", "be", "used", "to", "simplify", "select", "or", "other", "instructions", "." ]

[ "AArch64", "64" ]

[]

[ "<s>", "static", "const", "char", "*", "get_decl_name", "(", "tree", "fn", ")", "{", "tree", "name", ";", "if", "(", "!", "fn", ")", "return", "\"<null>\"", ";", "name", "=", "DECL_NAME", "(", "fn", ")", ";", "if", "(", "!", "name", ")", "return", "\"<no-name>\"", ";", "return", "IDENTIFIER_POINTER", "(", "name", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "printing", "the", "function", "name", "when", "debugging", "." ]

[ "rs6000", "\"<null>\"", "\"<no-name>\"" ]

[]

[ "<s>", "static", "unsigned", "int", "tilepro_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "alignment", ";", "alignment", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "alignment", "<", "PARM_BOUNDARY", ")", "alignment", "=", "PARM_BOUNDARY", ";", "if", "(", "alignment", ">", "STACK_BOUNDARY", ")", "alignment", "=", "STACK_BOUNDARY", ";", "return", "alignment", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_BOUNDARY", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "pdp11_expand_prologue", "(", "void", ")", "{", "HOST_WIDE_INT", "fsize", "=", "get_frame_size", "(", ")", ";", "unsigned", "regno", ";", "rtx", "x", ",", "via_ac", "=", "NULL", ";", "if", "(", "MAIN_NAME_P", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", "&&", "TARGET_FPU", ")", "{", "emit_insn", "(", "gen_setd", "(", ")", ")", ";", "emit_insn", "(", "gen_seti", "(", ")", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "x", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "Pmode", ",", "x", ")", ";", "emit_move_insn", "(", "x", ",", "hard_frame_pointer_rtx", ")", ";", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "if", "(", "fsize", ")", "{", "emit_insn", "(", "gen_addhi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "fsize", ")", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "for", "(", "regno", "=", "R0_REGNUM", ";", "regno", "<=", "PC_REGNUM", ";", "regno", "++", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", "&&", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", ")", "{", "x", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "Pmode", ",", "x", ")", ";", "emit_move_insn", "(", "x", ",", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ")", ";", "}", "for", "(", "regno", "=", "AC0_REGNUM", ";", "regno", "<=", "AC3_REGNUM", ";", "regno", "++", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", ")", "{", "x", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "DFmode", ",", "x", ")", ";", "via_ac", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "emit_move_insn", "(", "x", ",", "via_ac", ")", ";", "}", "for", "(", "regno", "=", "AC4_REGNUM", ";", "regno", "<=", "AC5_REGNUM", ";", "regno", "++", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", ")", "{", "gcc_assert", "(", "via_ac", "!=", "NULL", ")", ";", "emit_move_insn", "(", "via_ac", ",", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ")", ";", "x", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "DFmode", ",", "x", ")", ";", "emit_move_insn", "(", "x", ",", "via_ac", ")", ";", "}", "}", "</s>" ]

[ "Expand", "the", "function", "prologue", "." ]

[ "pdp11" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "Subtarget", "->", "hasAddr64", "(", ")", "?", "&", "WebAssembly", "::", "I64RegClass", ":", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "unsigned", "Opc", "=", "Subtarget", "->", "hasAddr64", "(", ")", "?", "WebAssembly", "::", "COPY_I64", ":", "WebAssembly", "::", "COPY_I32", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::I64RegClass", "WebAssembly::I32RegClass", "WebAssembly::COPY_I64", "WebAssembly::COPY_I32", "0" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "k_Immediate", ":", "OS", "<<", "\"Imm<\"", ";", "OS", "<<", "*", "Imm", ".", "Val", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Memory", ":", "OS", "<<", "\"Mem<\"", ";", "OS", "<<", "Mem", ".", "Base", ";", "OS", "<<", "\", \"", ";", "OS", "<<", "*", "Mem", ".", "Off", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"Register<\"", "<<", "Reg", ".", "RegNum", "<<", "\">\"", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "}", "}", "</s>" ]

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

[ "MINA32", "\"Imm<\"", "\">\"", "\"Mem<\"", "\", \"", "\">\"", "\"Register<\"", "\">\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "DisableFunctionSplitter", ")", "return", "false", ";", "unsigned", "max_subfunc_size", "=", "MaxSubfunctionSize", "?", "MaxSubfunctionSize", ":", "STC", ".", "getMethodCacheSize", "(", ")", ";", "max_subfunc_size", "=", "std", "::", "min", "(", "max_subfunc_size", ",", "STC", ".", "getMethodCacheSize", "(", ")", ")", ";", "unsigned", "prefer_subfunc_size", "=", "PreferSubfunctionSize", "?", "PreferSubfunctionSize", ":", "max_subfunc_size", ";", "unsigned", "prefer_scc_size", "=", "PreferSCCSize", "?", "PreferSCCSize", ":", "prefer_subfunc_size", ";", "prefer_subfunc_size", "=", "std", "::", "min", "(", "max_subfunc_size", ",", "prefer_subfunc_size", ")", ";", "prefer_scc_size", "=", "std", "::", "min", "(", "max_subfunc_size", ",", "prefer_scc_size", ")", ";", "unsigned", "total_size", "=", "0", ";", "bool", "blocks_splitted", "=", "false", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachinePostDominatorTree", "&", "MPDT", "=", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "i", "(", "MF", ".", "begin", "(", ")", ")", ",", "ie", "(", "MF", ".", "end", "(", ")", ")", ";", "i", "!=", "ie", ";", "i", "++", ")", "{", "unsigned", "bb_size", "=", "agraph", "::", "getBBSize", "(", "i", ",", "PTM", ")", ";", "if", "(", "bb_size", "+", "agraph", "::", "getMaxBlockMargin", "(", "PTM", ",", "i", ")", ">", "max_subfunc_size", ")", "{", "bb_size", "=", "agraph", "::", "splitBlock", "(", "i", ",", "max_subfunc_size", ",", "PTM", ",", "MDT", ",", "MPDT", ")", ";", "blocks_splitted", "=", "true", ";", "}", "total_size", "+=", "bb_size", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nPatmos Function Splitter: \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\": \"", "<<", "total_size", "<<", "\"\\n\"", ")", ";", "TotalFunctions", "++", ";", "if", "(", "total_size", ">", "prefer_subfunc_size", ")", "{", "bool", "CollectStats", "=", "!", "StatsFile", ".", "empty", "(", ")", ";", "TimeRecord", "Time", ";", "if", "(", "CollectStats", ")", "Time", "-=", "TimeRecord", "::", "getCurrentTime", "(", "true", ")", ";", "PMLImport", "&", "PI", "=", "getAnalysis", "<", "PMLImport", ">", "(", ")", ";", "agraph", "G", "(", "&", "MF", ",", "PTM", ",", "PI", ".", "createMCQuery", "(", "*", "this", ",", "MF", ")", ",", "MPDT", ",", "prefer_subfunc_size", ",", "prefer_scc_size", ",", "max_subfunc_size", ")", ";", "G", ".", "transformSCCs", "(", ")", ";", "ablocks", "order", ";", "G", ".", "computeRegions", "(", "order", ")", ";", "assert", "(", "order", ".", "size", "(", ")", "==", "MF", ".", "size", "(", ")", ")", ";", "G", ".", "applyRegions", "(", "order", ")", ";", "if", "(", "CollectStats", ")", "{", "Time", "+=", "TimeRecord", "::", "getCurrentTime", "(", "false", ")", ";", "writeStats", "(", "StatsFile", ",", "MF", ",", "G", ",", "order", ",", "total_size", ",", "Time", ")", ";", "}", "SplitFunctions", "++", ";", "return", "true", ";", "}", "return", "blocks_splitted", ";", "}", "</s>" ]

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

[ "Patmos", "0", "\"\\nPatmos Function Splitter: \"", "\": \"", "\"\\n\"" ]

[]

[ "<s>", "static", "int", "shmedia_target_regs_stack_space", "(", "HARD_REG_SET", "*", "live_regs_mask", ")", "{", "int", "reg", ";", "int", "stack_space", "=", "0", ";", "int", "interrupt_handler", "=", "sh_cfun_interrupt_handler_p", "(", ")", ";", "for", "(", "reg", "=", "LAST_TARGET_REG", ";", "reg", ">=", "FIRST_TARGET_REG", ";", "reg", "--", ")", "if", "(", "(", "!", "call_really_used_regs", "[", "reg", "]", "||", "interrupt_handler", ")", "&&", "!", "TEST_HARD_REG_BIT", "(", "*", "live_regs_mask", ",", "reg", ")", ")", "stack_space", "+=", "GET_MODE_SIZE", "(", "REGISTER_NATURAL_MODE", "(", "reg", ")", ")", ";", "return", "stack_space", ";", "}", "</s>" ]

[ "Calculate", "how", "much", "extra", "space", "is", "needed", "to", "save", "all", "callee-saved", "target", "registers", ".", "LIVE_REGS_MASK", "is", "the", "register", "mask", "calculated", "by", "calc_live_regs", "." ]

[ "sh", "0" ]

[]

[ "<s>", "bool", "SystemZPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createSystemZISelDag", "(", "getSystemZTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "csky_legitimize_tls_address", "(", "rtx", "x", ",", "rtx", "reg", ")", "{", "rtx", "dest", ",", "tp", ",", "label", ",", "labelno", ",", "unspec", ",", "ret", ",", "eqv", ",", "addend", ",", "tmp", ";", "rtx_insn", "*", "insns", ";", "unsigned", "int", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ";", "if", "(", "!", "reg", ")", "reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "insns", "=", "csky_call_tls_get_addr", "(", "x", ",", "reg", ",", "&", "ret", ",", "TLS_GD32", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "ret", ",", "x", ")", ";", "return", "dest", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "insns", "=", "csky_call_tls_get_addr", "(", "x", ",", "reg", ",", "&", "ret", ",", "TLS_LDM32", ")", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const1_rtx", ")", ",", "UNSPEC_TLS", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "ret", ",", "eqv", ")", ";", "addend", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "GEN_INT", "(", "TLS_LDO32", ")", ")", ",", "UNSPEC_TLS", ")", ";", "addend", "=", "force_reg", "(", "SImode", ",", "addend", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "dest", ",", "addend", ")", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "labelno", "=", "GEN_INT", "(", "tls_labelno", "++", ")", ";", "label", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "labelno", ")", ",", "UNSPEC_TLS_LABEL", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "x", ",", "GEN_INT", "(", "TLS_IE32", ")", ",", "label", ")", ",", "UNSPEC_TLS", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "reg", ",", "unspec", ")", ";", "emit_move_insn", "(", "tmp", ",", "label", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "reg", ",", "reg", ",", "tmp", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "gen_const_mem", "(", "Pmode", ",", "reg", ")", ")", ";", "tp", "=", "gen_rtx_REG", "(", "SImode", ",", "CSKY_TLS_REGNUM", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "reg", ")", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "unspec", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "GEN_INT", "(", "TLS_LE32", ")", ")", ",", "UNSPEC_TLS", ")", ";", "emit_move_insn", "(", "reg", ",", "unspec", ")", ";", "tp", "=", "gen_rtx_REG", "(", "SImode", ",", "CSKY_TLS_REGNUM", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "reg", ")", ";", "default", ":", "abort", "(", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "csky_legitimize_address", ",", "to", "handle", "the", "TLS", "cases", ".", "REG", "is", "a", "scratch", "register", "and", "may", "be", "null", "." ]

[ "csky", "1", "2", "1", "3", "2" ]

[]

[ "<s>", "static", "bool", "s390_loadrelative_operand_p", "(", "rtx", "addr", ",", "rtx", "*", "symref", ",", "HOST_WIDE_INT", "*", "addend", ")", "{", "HOST_WIDE_INT", "tmpaddend", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "return", "false", ";", "tmpaddend", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "&&", "!", "CONSTANT_POOL_ADDRESS_P", "(", "addr", ")", ")", "||", "(", "GET_CODE", "(", "addr", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "addr", ",", "1", ")", "==", "UNSPEC_GOTENT", "||", "(", "TARGET_CPU_ZARCH", "&&", "XINT", "(", "addr", ",", "1", ")", "==", "UNSPEC_PLT", ")", ")", ")", ")", "{", "if", "(", "symref", ")", "*", "symref", "=", "addr", ";", "if", "(", "addend", ")", "*", "addend", "=", "tmpaddend", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "ADDR", "is", "an", "operand", "valid", "for", "a", "load/store", "relative", "instruction", ".", "Be", "aware", "that", "the", "alignment", "of", "the", "operand", "needs", "to", "be", "checked", "separately", ".", "Valid", "addresses", "are", "single", "references", "or", "a", "sum", "of", "a", "reference", "and", "a", "constant", "integer", ".", "Return", "these", "parts", "in", "SYMREF", "and", "ADDEND", ".", "You", "can", "pass", "NULL", "in", "REF", "and/or", "ADDEND", "if", "you", "are", "not", "interested", "in", "these", "values", ".", "Literal", "pool", "references", "are", "*", "not", "*", "considered", "symbol", "references", "." ]

[ "s390", "0", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "static", "bool", "frv_cannot_force_const_mem", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "TARGET_FDPIC", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "force", "certain", "constants", "to", "memory", ".", "If", "we", "decide", "we", "ca", "n't", ",", "the", "caller", "should", "be", "able", "to", "cope", "with", "it", "in", "another", "way", ".", "We", "never", "allow", "constants", "to", "be", "forced", "into", "memory", "for", "TARGET_FDPIC", ".", "This", "is", "necessary", "for", "several", "reasons", ":", "1", ".", "Since", "LEGITIMATE_CONSTANT_P", "rejects", "constant", "pool", "addresses", ",", "the", "target-independent", "code", "will", "try", "to", "force", "them", "into", "the", "constant", "pool", ",", "thus", "leading", "to", "infinite", "recursion", ".", "2", ".", "We", "can", "never", "introduce", "new", "constant", "pool", "references", "during", "reload", ".", "Any", "such", "reference", "would", "require", "use", "of", "the", "pseudo", "FDPIC", "register", ".", "3", ".", "We", "ca", "n't", "represent", "a", "constant", "added", "to", "a", "function", "pointer", "(", "which", "is", "not", "the", "same", "as", "a", "pointer", "to", "a", "function+constant", ")", ".", "4", ".", "In", "many", "cases", ",", "it", "'s", "more", "efficient", "to", "calculate", "the", "constant", "in-line", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "DL", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getDataLayout", "(", ")", ";", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "if", "(", "TLI", ".", "getSubtarget", "(", ")", "->", "isThumb", "(", ")", ")", "return", "false", ";", "auto", "&", "Args", "=", "F", ".", "getArgumentList", "(", ")", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "Idx", "+", "1", ",", "DL", ",", "F", ")", ";", "ArgInfos", ".", "push_back", "(", "AInfo", ")", ";", "Idx", "++", ";", "}", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "return", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "ARM", "ARM", "ARM", "8", "0", "1" ]

[]

[ "<s>", "const", "unsigned", "*", "IA64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "IA64", "::", "r5", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "IA64", "IA64", "IA64::r5", "0" ]

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "vax_expand_prologue", "(", "void", ")", "{", "int", "regno", ",", "offset", ";", "int", "mask", "=", "0", ";", "HOST_WIDE_INT", "size", ";", "rtx", "insn", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "mask", "|=", "1", "<<", "regno", ";", "insn", "=", "emit_insn", "(", "gen_procedure_entry_mask", "(", "GEN_INT", "(", "mask", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "vax_add_reg_cfa_offset", "(", "insn", ",", "4", ",", "arg_pointer_rtx", ")", ";", "vax_add_reg_cfa_offset", "(", "insn", ",", "8", ",", "frame_pointer_rtx", ")", ";", "vax_add_reg_cfa_offset", "(", "insn", ",", "12", ",", "pc_rtx", ")", ";", "offset", "=", "16", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "regno", ")", ")", "{", "vax_add_reg_cfa_offset", "(", "insn", ",", "offset", ",", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ")", ";", "offset", "+=", "4", ";", "}", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "frame_pointer_rtx", ",", "offset", ")", ")", ";", "size", "=", "get_frame_size", "(", ")", ";", "size", "-=", "vax_starting_frame_offset", "(", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Generate", "the", "assembly", "code", "for", "function", "entry", ".", "FILE", "is", "a", "stdio", "stream", "to", "output", "the", "code", "to", ".", "SIZE", "is", "an", "int", ":", "how", "many", "units", "of", "temporary", "storage", "to", "allocate", ".", "Refer", "to", "the", "array", "`", "regs_ever_live", "'", "to", "determine", "which", "registers", "to", "save", ";", "`", "regs_ever_live", "[", "I", "]", "'", "is", "nonzero", "if", "register", "number", "I", "is", "ever", "used", "in", "the", "function", ".", "This", "function", "is", "responsible", "for", "knowing", "which", "registers", "should", "not", "be", "saved", "even", "if", "used", "." ]

[ "vax", "0", "0", "1", "1", "4", "8", "12", "16", "0", "1", "4" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasCustomCheapAsMoveHandling", "(", ")", ")", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "unsigned", "Imm", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "ADDWri", ":", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "SUBWri", ":", "case", "AArch64", "::", "SUBXri", ":", "return", "(", "Subtarget", ".", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "ExynosM1", "||", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "case", "AArch64", "::", "ADDWrs", ":", "case", "AArch64", "::", "ADDXrs", ":", "case", "AArch64", "::", "SUBWrs", ":", "case", "AArch64", "::", "SUBXrs", ":", "Imm", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "return", "(", "Subtarget", ".", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "ExynosM1", "&&", "AArch64_AM", "::", "getArithShiftValue", "(", "Imm", ")", "<", "4", ")", ";", "case", "AArch64", "::", "ANDWri", ":", "case", "AArch64", "::", "ANDXri", ":", "case", "AArch64", "::", "EORWri", ":", "case", "AArch64", "::", "EORXri", ":", "case", "AArch64", "::", "ORRWri", ":", "case", "AArch64", "::", "ORRXri", ":", "return", "true", ";", "case", "AArch64", "::", "ANDWrr", ":", "case", "AArch64", "::", "ANDXrr", ":", "case", "AArch64", "::", "BICWrr", ":", "case", "AArch64", "::", "BICXrr", ":", "case", "AArch64", "::", "EONWrr", ":", "case", "AArch64", "::", "EONXrr", ":", "case", "AArch64", "::", "EORWrr", ":", "case", "AArch64", "::", "EORXrr", ":", "case", "AArch64", "::", "ORNWrr", ":", "case", "AArch64", "::", "ORNXrr", ":", "case", "AArch64", "::", "ORRWrr", ":", "case", "AArch64", "::", "ORRXrr", ":", "return", "true", ";", "case", "AArch64", "::", "ANDWrs", ":", "case", "AArch64", "::", "ANDXrs", ":", "case", "AArch64", "::", "BICWrs", ":", "case", "AArch64", "::", "BICXrs", ":", "case", "AArch64", "::", "EONWrs", ":", "case", "AArch64", "::", "EONXrs", ":", "case", "AArch64", "::", "EORWrs", ":", "case", "AArch64", "::", "EORXrs", ":", "case", "AArch64", "::", "ORNWrs", ":", "case", "AArch64", "::", "ORNXrs", ":", "case", "AArch64", "::", "ORRWrs", ":", "case", "AArch64", "::", "ORRXrs", ":", "Imm", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "return", "(", "Subtarget", ".", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "ExynosM1", "&&", "AArch64_AM", "::", "getShiftValue", "(", "Imm", ")", "<", "4", "&&", "AArch64_AM", "::", "getShiftType", "(", "Imm", ")", "==", "AArch64_AM", "::", "LSL", ")", ";", "case", "AArch64", "::", "MOVi32imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "32", ")", ";", "case", "AArch64", "::", "MOVi64imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "64", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown opcode to check as cheap as a move!\"", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "AArch64", "AArch64", "AArch64::ADDWri", "AArch64::ADDXri", "AArch64::SUBWri", "AArch64::SUBXri", "AArch64", "3", "0", "AArch64::ADDWrs", "AArch64::ADDXrs", "AArch64::SUBWrs", "AArch64::SUBXrs", "3", "AArch64", "AArch64_AM::getArithShiftValue", "4", "AArch64::ANDWri", "AArch64::ANDXri", "AArch64::EORWri", "AArch64::EORXri", "AArch64::ORRWri", "AArch64::ORRXri", "AArch64::ANDWrr", "AArch64::ANDXrr", "AArch64::BICWrr", "AArch64::BICXrr", "AArch64::EONWrr", "AArch64::EONXrr", "AArch64::EORWrr", "AArch64::EORXrr", "AArch64::ORNWrr", "AArch64::ORNXrr", "AArch64::ORRWrr", "AArch64::ORRXrr", "AArch64::ANDWrs", "AArch64::ANDXrs", "AArch64::BICWrs", "AArch64::BICXrs", "AArch64::EONWrs", "AArch64::EONXrs", "AArch64::EORWrs", "AArch64::EORXrs", "AArch64::ORNWrs", "AArch64::ORNXrs", "AArch64::ORRWrs", "AArch64::ORRXrs", "3", "AArch64", "AArch64_AM::getShiftValue", "4", "AArch64_AM::getShiftType", "AArch64_AM::LSL", "AArch64::MOVi32imm", "32", "AArch64::MOVi64imm", "64", "\"Unknown opcode to check as cheap as a move!\"" ]

[]

[ "<s>", "int", "XCoreRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "return", "XCoreGenRegisterInfo", "::", "getDwarfRegNumFull", "(", "RegNum", ",", "0", ")", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

[ "XCore", "XCore", "XCore", "0" ]

[]

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

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

[ "Kudeyar", "Kudeyar" ]

[]

[ "<s>", "void", "MipsInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "Mips", "::", "CPURegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "else", "if", "(", "RC", "==", "Mips", "::", "FGR32RegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SWC1", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "else", "if", "(", "RC", "==", "Mips", "::", "AFGR64RegisterClass", ")", "{", "if", "(", "!", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isMips1", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SDC1", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "else", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "unsigned", "*", "SubSet", "=", "TRI", "->", "getSubRegisters", "(", "SrcReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SWC1", ")", ")", ".", "addReg", "(", "SubSet", "[", "0", "]", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SWC1", ")", ")", ".", "addReg", "(", "SubSet", "[", "1", "]", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "4", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "}", "else", "llvm_unreachable", "(", "\"Register class not handled!\"", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::CPURegsRegisterClass", "Mips::SW", "0", "Mips::FGR32RegisterClass", "Mips::SWC1", "0", "Mips::AFGR64RegisterClass", "Mips", "Mips", "Mips::SDC1", "0", "Mips::SWC1", "0", "0", "Mips::SWC1", "1", "4", "\"Register class not handled!\"" ]

[]

[ "<s>", "unsigned", "getStackAlignment", "(", ")", "const", "{", "return", "4", "*", "256", "/", "getWavefrontSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "for", "this", "subtarget", "." ]

[ "AMDGPU", "4", "256" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Can't spill VGPR!\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "AMDGPU", "::", "VGPR0", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "unsigned", "Opcode", ";", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Cannot spill register class\"", ")", ";", "}", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"VGPR spilling not supported\"", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "\"SIInstrInfo::storeRegToStackSlot - Can't spill VGPR!\"", "8", "32", "SI", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "\"Cannot spill register class\"", "4", "\"VGPR spilling not supported\"" ]

[]

[ "<s>", "static", "bool", "ix86_is_empty_record", "(", "const_tree", "type", ")", "{", "if", "(", "!", "TARGET_64BIT", ")", "return", "false", ";", "return", "default_is_empty_record", "(", "type", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EMPTY_RECORD_P", "." ]

[ "i386" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "2", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getJumpTargetOpValue expects only expressions or an immediate\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_Mips_26", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]

[ "Mips", "Mips", "2", "\"getJumpTargetOpValue expects only expressions or an immediate\"", "0", "Mips::fixup_Mips_26", "0" ]

[]

[ "<s>", "InstructionCost", "GCNTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "ICA", ".", "getID", "(", ")", "==", "Intrinsic", "::", "fabs", ")", "return", "0", ";", "if", "(", "!", "intrinsicHasPackedVectorBenefit", "(", "ICA", ".", "getID", "(", ")", ")", ")", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "Type", "*", "RetTy", "=", "ICA", ".", "getReturnType", "(", ")", ";", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "RetTy", ")", ";", "if", "(", "!", "OrigTy", ".", "isSimple", "(", ")", ")", "{", "if", "(", "CostKind", "!=", "TTI", "::", "TCK_CodeSize", ")", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "if", "(", "ICA", ".", "isTypeBasedOnly", "(", ")", ")", "return", "getTypeBasedIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "unsigned", "RetVF", "=", "(", "RetTy", "->", "isVectorTy", "(", ")", "?", "cast", "<", "FixedVectorType", ">", "(", "RetTy", ")", "->", "getNumElements", "(", ")", ":", "1", ")", ";", "const", "IntrinsicInst", "*", "I", "=", "ICA", ".", "getInst", "(", ")", ";", "const", "SmallVectorImpl", "<", "const", "Value", "*", ">", "&", "Args", "=", "ICA", ".", "getArgs", "(", ")", ";", "FastMathFlags", "FMF", "=", "ICA", ".", "getFlags", "(", ")", ";", "InstructionCost", "ScalarizationCost", "=", "InstructionCost", "::", "getInvalid", "(", ")", ";", "if", "(", "RetVF", ">", "1", ")", "{", "ScalarizationCost", "=", "0", ";", "if", "(", "!", "RetTy", "->", "isVoidTy", "(", ")", ")", "ScalarizationCost", "+=", "getScalarizationOverhead", "(", "cast", "<", "VectorType", ">", "(", "RetTy", ")", ",", "true", ",", "false", ")", ";", "ScalarizationCost", "+=", "getOperandsScalarizationOverhead", "(", "Args", ",", "ICA", ".", "getArgTypes", "(", ")", ")", ";", "}", "IntrinsicCostAttributes", "Attrs", "(", "ICA", ".", "getID", "(", ")", ",", "RetTy", ",", "ICA", ".", "getArgTypes", "(", ")", ",", "FMF", ",", "I", ",", "ScalarizationCost", ")", ";", "return", "getIntrinsicInstrCost", "(", "Attrs", ",", "CostKind", ")", ";", "}", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "unsigned", "NElts", "=", "LT", ".", "second", ".", "isVector", "(", ")", "?", "LT", ".", "second", ".", "getVectorNumElements", "(", ")", ":", "1", ";", "MVT", "::", "SimpleValueType", "SLT", "=", "LT", ".", "second", ".", "getScalarType", "(", ")", ".", "SimpleTy", ";", "if", "(", "SLT", "==", "MVT", "::", "f64", ")", "return", "LT", ".", "first", "*", "NElts", "*", "get64BitInstrCost", "(", "CostKind", ")", ";", "if", "(", "(", "ST", "->", "has16BitInsts", "(", ")", "&&", "SLT", "==", "MVT", "::", "f16", ")", "||", "(", "ST", "->", "hasPackedFP32Ops", "(", ")", "&&", "SLT", "==", "MVT", "::", "f32", ")", ")", "NElts", "=", "(", "NElts", "+", "1", ")", "/", "2", ";", "unsigned", "InstRate", "=", "getQuarterRateInstrCost", "(", "CostKind", ")", ";", "switch", "(", "ICA", ".", "getID", "(", ")", ")", "{", "case", "Intrinsic", "::", "fma", ":", "InstRate", "=", "ST", "->", "hasFastFMAF32", "(", ")", "?", "getHalfRateInstrCost", "(", "CostKind", ")", ":", "getQuarterRateInstrCost", "(", "CostKind", ")", ";", "break", ";", "case", "Intrinsic", "::", "uadd_sat", ":", "case", "Intrinsic", "::", "usub_sat", ":", "case", "Intrinsic", "::", "sadd_sat", ":", "case", "Intrinsic", "::", "ssub_sat", ":", "static", "const", "auto", "ValidSatTys", "=", "{", "MVT", "::", "v2i16", ",", "MVT", "::", "v4i16", "}", ";", "if", "(", "any_of", "(", "ValidSatTys", ",", "[", "&", "LT", "]", "(", "MVT", "M", ")", "{", "return", "M", "==", "LT", ".", "second", ";", "}", ")", ")", "NElts", "=", "1", ";", "break", ";", "}", "return", "LT", ".", "first", "*", "NElts", "*", "InstRate", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "AMDGPU", "Intrinsic::fabs", "0", "1", "1", "0", "1", "MVT::SimpleValueType", "MVT::f64", "MVT::f16", "MVT::f32", "1", "2", "Intrinsic::fma", "Intrinsic::uadd_sat", "Intrinsic::usub_sat", "Intrinsic::sadd_sat", "Intrinsic::ssub_sat", "MVT::v2i16", "MVT::v4i16", "1" ]

[]

[ "<s>", "static", "void", "nvptx_goacc_reduction_init", "(", "gcall", "*", "call", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "tree", "var", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "enum", "tree_code", "rcode", "=", "(", "enum", "tree_code", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "4", ")", ")", ";", "tree", "init", "=", "omp_reduction_init_op", "(", "gimple_location", "(", "call", ")", ",", "rcode", ",", "TREE_TYPE", "(", "var", ")", ")", ";", "gimple_seq", "seq", "=", "NULL", ";", "push_gimplify_context", "(", "true", ")", ";", "if", "(", "level", "==", "GOMP_DIM_VECTOR", ")", "{", "tree", "tid", "=", "make_ssa_name", "(", "integer_type_node", ")", ";", "tree", "dim_vector", "=", "gimple_call_arg", "(", "call", ",", "3", ")", ";", "gimple", "*", "tid_call", "=", "gimple_build_call_internal", "(", "IFN_GOACC_DIM_POS", ",", "1", ",", "dim_vector", ")", ";", "gimple", "*", "cond_stmt", "=", "gimple_build_cond", "(", "NE_EXPR", ",", "tid", ",", "integer_zero_node", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "gimple_call_set_lhs", "(", "tid_call", ",", "tid", ")", ";", "gimple_seq_add_stmt", "(", "&", "seq", ",", "tid_call", ")", ";", "gimple_seq_add_stmt", "(", "&", "seq", ",", "cond_stmt", ")", ";", "edge", "init_edge", "=", "split_block", "(", "gsi_bb", "(", "gsi", ")", ",", "call", ")", ";", "basic_block", "init_bb", "=", "init_edge", "->", "dest", ";", "basic_block", "call_bb", "=", "init_edge", "->", "src", ";", "init_edge", "->", "flags", "^=", "EDGE_FALLTHRU", "|", "EDGE_TRUE_VALUE", ";", "gimple_seq", "init_seq", "=", "NULL", ";", "tree", "init_var", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "var", ")", ")", ";", "gimplify_assign", "(", "init_var", ",", "init", ",", "&", "init_seq", ")", ";", "gsi", "=", "gsi_start_bb", "(", "init_bb", ")", ";", "gsi_insert_seq_before", "(", "&", "gsi", ",", "init_seq", ",", "GSI_SAME_STMT", ")", ";", "gsi_prev", "(", "&", "gsi", ")", ";", "edge", "inited_edge", "=", "split_block", "(", "gsi_bb", "(", "gsi", ")", ",", "gsi_stmt", "(", "gsi", ")", ")", ";", "basic_block", "dst_bb", "=", "inited_edge", "->", "dest", ";", "edge", "nop_edge", "=", "make_edge", "(", "call_bb", ",", "dst_bb", ",", "EDGE_FALSE_VALUE", ")", ";", "gphi", "*", "phi", "=", "create_phi_node", "(", "lhs", ",", "dst_bb", ")", ";", "add_phi_arg", "(", "phi", ",", "init_var", ",", "inited_edge", ",", "gimple_location", "(", "call", ")", ")", ";", "add_phi_arg", "(", "phi", ",", "var", ",", "nop_edge", ",", "gimple_location", "(", "call", ")", ")", ";", "set_immediate_dominator", "(", "CDI_DOMINATORS", ",", "dst_bb", ",", "call_bb", ")", ";", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "}", "else", "{", "if", "(", "level", "==", "GOMP_DIM_GANG", ")", "{", "tree", "ref_to_res", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "if", "(", "integer_zerop", "(", "ref_to_res", ")", ")", "init", "=", "var", ";", "}", "gimplify_assign", "(", "lhs", ",", "init", ",", "&", "seq", ")", ";", "}", "pop_gimplify_context", "(", "NULL", ")", ";", "gsi_replace_with_seq", "(", "&", "gsi", ",", "seq", ",", "true", ")", ";", "}", "</s>" ]

[ "NVPTX", "implementation", "of", "GOACC_REDUCTION_INIT", "." ]

[ "nvptx", "2", "3", "4", "3", "1", "1" ]

[]

[ "<s>", "const", "SystemZInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "isTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "Mips", "Mips", "MVT::Other" ]

[]

[ "<s>", "static", "void", "or1k_init_pic_reg", "(", "void", ")", "{", "if", "(", "crtl", "->", "profile", ")", "cfun", "->", "machine", "->", "set_got_insn", "=", "emit_insn_after", "(", "gen_set_got_tmp", "(", "pic_offset_table_rtx", ")", ",", "cfun", "->", "machine", "->", "set_mcount_arg_insn", ")", ";", "else", "{", "start_sequence", "(", ")", ";", "cfun", "->", "machine", "->", "set_got_insn", "=", "emit_insn", "(", "gen_set_got_tmp", "(", "pic_offset_table_rtx", ")", ")", ";", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "edge", "entry_edge", "=", "single_succ_edge", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ";", "insert_insn_on_edge", "(", "seq", ",", "entry_edge", ")", ";", "commit_one_edge_insertion", "(", "entry_edge", ")", ";", "}", "}", "</s>" ]

[ "Worker", "for", "TARGET_INIT_PIC_REG", ".", "Initialize", "the", "cfun-", ">", "machine-", ">", "set_got_insn", "rtx", "and", "insert", "it", "at", "the", "entry", "of", "the", "current", "function", ".", "The", "rtx", "is", "just", "a", "temporary", "placeholder", "for", "the", "GOT", "and", "will", "be", "replaced", "or", "removed", "during", "or1k_expand_prologue", "." ]

[ "or1k" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "printAndVerify", "(", "\"After ARM load / store optimizer\"", ")", ";", "if", "(", "getARMSubtarget", "(", ")", ".", "hasNEON", "(", ")", ")", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "ARM", "::", "DPRRegClass", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "restrictIT", "(", ")", "&&", "!", "getARMSubtarget", "(", ")", ".", "prefers32BitThumb", "(", ")", ")", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "ARM", "ARM", "ARM", "\"After ARM load / store optimizer\"", "ARM", "ARM::DPRRegClass", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "F2003f" ]

[]

[ "<s>", "bool", "MSP430AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "EmitInterruptVectorSection", "(", "MF", ")", ";", "}", "SetupMachineFunction", "(", "MF", ")", ";", "emitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "\"interrupt\"" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAG", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAGp", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "long", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R30", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDQ", ")", ",", "Alpha", "::", "R15", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "}", "if", "(", "NumBytes", "!=", "0", ")", "{", "if", "(", "NumBytes", "<=", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "if", "(", "getUpper16", "(", "NumBytes", ")", "<=", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getUpper16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getLower16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "std", "::", "string", "msg", ";", "raw_string_ostream", "Msg", "(", "msg", ")", ";", "Msg", "<<", "\"Too big a stack frame at \"", "<<", "NumBytes", ";", "llvm_report_error", "(", "Msg", ".", "str", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Alpha", "Alpha", "Alpha::RETDAG", "Alpha::RETDAGp", "\"Can only insert epilog into returning blocks\"", "Alpha::BISr", "Alpha::R30", "Alpha::R15", "Alpha::R15", "Alpha::LDQ", "Alpha::R15", "0", "Alpha::R15", "0", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::LDAH", "Alpha::R30", "Alpha::R30", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "\"Too big a stack frame at \"" ]

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "C", ")", "{", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "C", ")", ")", "return", "0", ";", "assert", "(", "C", "->", "isStaticAlloca", "(", ")", "&&", "\"dynamic alloca in the static alloca map?\"", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "C", ",", "AM", ")", ")", "return", "0", ";", "unsigned", "Opc", "=", "TLI", ".", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", "?", "X86", "::", "LEA32r", ":", "X86", "::", "LEA64r", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "TLI", ".", "getPointerTy", "(", ")", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "addFullAddress", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ",", "AM", ")", ";", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "X86", "X86", "0", "\"dynamic alloca in the static alloca map?\"", "X86", "X86", "0", "MVT::i32", "X86::LEA32r", "X86::LEA64r" ]

[]

[ "<s>", "int", "mmix_data_alignment", "(", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "basic_align", ")", "{", "if", "(", "basic_align", "<", "32", ")", "return", "32", ";", "return", "basic_align", ";", "}", "</s>" ]

[ "DATA_ALIGNMENT", ".", "We", "have", "trouble", "getting", "the", "address", "of", "stuff", "that", "is", "located", "at", "other", "than", "32-bit", "alignments", "(", "GETA", "requirements", ")", ",", "so", "try", "to", "give", "everything", "at", "least", "32-bit", "alignment", "." ]

[ "mmix", "32", "32" ]

[]

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

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

[ "AVR", "AVR", "\"invalid instruction\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SparcTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "BROpcode", ";", "unsigned", "CC", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown SELECT_CC!\"", ")", ";", "case", "SP", "::", "SELECT_CC_Int_ICC", ":", "case", "SP", "::", "SELECT_CC_FP_ICC", ":", "case", "SP", "::", "SELECT_CC_DFP_ICC", ":", "BROpcode", "=", "SP", "::", "BCOND", ";", "break", ";", "case", "SP", "::", "SELECT_CC_Int_FCC", ":", "case", "SP", "::", "SELECT_CC_FP_FCC", ":", "case", "SP", "::", "SELECT_CC_DFP_FCC", ":", "BROpcode", "=", "SP", "::", "FBCOND", ";", "break", ";", "}", "CC", "=", "(", "SPCC", "::", "CondCodes", ")", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "BROpcode", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ".", "addImm", "(", "CC", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "transferSuccessors", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "F", "->", "DeleteMachineInstr", "(", "MI", ")", ";", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "Sparc", "Sparc", "\"Unknown SELECT_CC!\"", "SP::SELECT_CC_Int_ICC", "SP::SELECT_CC_FP_ICC", "SP::SELECT_CC_DFP_ICC", "SP::BCOND", "SP::SELECT_CC_Int_FCC", "SP::SELECT_CC_FP_FCC", "SP::SELECT_CC_DFP_FCC", "SP::FBCOND", "SPCC::CondCodes", "3", "SP::PHI", "0", "2", "1" ]

[]

[ "<s>", "ARMRelocator", "::", "Result", "none", "(", "Relocation", "&", "pReloc", ",", "ARMRelocator", "&", "pParent", ")", "{", "return", "Relocator", "::", "OK", ";", "}", "</s>" ]

[ "Returns", "true", "if", "none", "of", "the", "bits", "are", "set", "." ]

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

[]

[ "<s>", "static", "void", "mips_sim_issue_insn", "(", "struct", "mips_sim", "*", "state", ",", "rtx", "insn", ")", "{", "state_transition", "(", "state", "->", "dfa_state", ",", "insn", ")", ";", "state", "->", "insns_left", "--", ";", "mips_sim_insn", "=", "insn", ";", "note_stores", "(", "PATTERN", "(", "insn", ")", ",", "mips_sim_record_set", ",", "state", ")", ";", "}", "</s>" ]

[ "Issue", "instruction", "INSN", "in", "scheduler", "state", "STATE", ".", "Assume", "that", "INSN", "can", "issue", "immediately", "(", "i.e.", ",", "that", "mips_sim_wait_insn", "has", "already", "been", "called", ")", "." ]

[ "mips" ]

[]

[ "<s>", "FastISel", "*", "ARMTargetLowering", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "const", "{", "return", "ARM", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::createFastISel" ]

[]

[ "<s>", "static", "rtx", "spe_synthesize_frame_save", "(", "rtx", "real", ")", "{", "rtx", "synth", ",", "offset", ",", "reg", ",", "real2", ";", "if", "(", "GET_CODE", "(", "real", ")", "!=", "SET", "||", "GET_MODE", "(", "SET_SRC", "(", "real", ")", ")", "!=", "V2SImode", ")", "return", "real", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_DEST", "(", "real", ")", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "SET_DEST", "(", "real", ")", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "SET_SRC", "(", "real", ")", ")", "==", "REG", ")", ";", "real2", "=", "copy_rtx", "(", "real", ")", ";", "PUT_MODE", "(", "SET_DEST", "(", "real2", ")", ",", "SImode", ")", ";", "reg", "=", "SET_SRC", "(", "real2", ")", ";", "real2", "=", "replace_rtx", "(", "real2", ",", "reg", ",", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "reg", ")", ")", ")", ";", "synth", "=", "copy_rtx", "(", "real2", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "offset", "=", "XEXP", "(", "XEXP", "(", "SET_DEST", "(", "real2", ")", ",", "0", ")", ",", "1", ")", ";", "real2", "=", "replace_rtx", "(", "real2", ",", "offset", ",", "GEN_INT", "(", "INTVAL", "(", "offset", ")", "+", "4", ")", ")", ";", "}", "reg", "=", "SET_SRC", "(", "synth", ")", ";", "synth", "=", "replace_rtx", "(", "synth", ",", "reg", ",", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "reg", ")", "+", "1200", ")", ")", ";", "offset", "=", "XEXP", "(", "XEXP", "(", "SET_DEST", "(", "synth", ")", ",", "0", ")", ",", "1", ")", ";", "synth", "=", "replace_rtx", "(", "synth", ",", "offset", ",", "GEN_INT", "(", "INTVAL", "(", "offset", ")", "+", "(", "BYTES_BIG_ENDIAN", "?", "0", ":", "4", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "synth", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "real2", ")", "=", "1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "real", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "synth", ",", "real2", ")", ")", ";", "else", "real", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "real2", ",", "synth", ")", ")", ";", "return", "real", ";", "}", "</s>" ]

[ "Given", "an", "SPE", "frame", "note", ",", "return", "a", "PARALLEL", "of", "SETs", "with", "the", "original", "note", ",", "plus", "a", "synthetic", "register", "save", "." ]

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

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isSourceOfDivergence", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "Argument", "*", "A", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ")", "return", "!", "isArgPassedInSGPR", "(", "A", ")", ";", "if", "(", "const", "LoadInst", "*", "Load", "=", "dyn_cast", "<", "LoadInst", ">", "(", "V", ")", ")", "return", "Load", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", "||", "Load", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ";", "if", "(", "isa", "<", "AtomicRMWInst", ">", "(", "V", ")", "||", "isa", "<", "AtomicCmpXchgInst", ">", "(", "V", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "return", "AMDGPU", "::", "isIntrinsicSourceOfDivergence", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", ";", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "V", ")", ")", "{", "if", "(", "CI", "->", "isInlineAsm", "(", ")", ")", "return", "isInlineAsmSourceOfDivergence", "(", "CI", ")", ";", "return", "true", ";", "}", "if", "(", "isa", "<", "InvokeInst", ">", "(", "V", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "whether", "V", "is", "a", "source", "of", "divergence", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU::isIntrinsicSourceOfDivergence" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_ti_to_v1ti", "(", "rtx", "x", ")", "{", "if", "(", "TARGET_SSE2", ")", "{", "rtx", "lo", "=", "gen_lowpart", "(", "DImode", ",", "x", ")", ";", "rtx", "hi", "=", "gen_highpart", "(", "DImode", ",", "x", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "emit_insn", "(", "gen_vec_concatv2di", "(", "tmp", ",", "lo", ",", "hi", ")", ")", ";", "return", "force_reg", "(", "V1TImode", ",", "gen_lowpart", "(", "V1TImode", ",", "tmp", ")", ")", ";", "}", "return", "force_reg", "(", "V1TImode", ",", "gen_lowpart", "(", "V1TImode", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Expand", "move", "of", "TI", "mode", "register", "X", "to", "a", "new", "V1TI", "mode", "register", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "rl78_alloc_physical_registers_umul", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "prev", "=", "prev_nonnote_nondebug_insn", "(", "insn", ")", ";", "rtx_insn", "*", "first", ";", "int", "tmp_id", ";", "rtx", "saved_op1", ";", "OP", "(", "0", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "0", ")", ",", "BC", ",", "insn", ")", ";", "OP", "(", "1", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "1", ")", ",", "DE", ",", "insn", ")", ";", "OP", "(", "2", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "2", ")", ",", "HL", ",", "insn", ")", ";", "MAYBE_OK", "(", "insn", ")", ";", "if", "(", "recog_data", ".", "constraints", "[", "1", "]", "[", "0", "]", "==", "'%'", "&&", "is_virtual_register", "(", "OP", "(", "1", ")", ")", "&&", "!", "is_virtual_register", "(", "OP", "(", "2", ")", ")", "&&", "!", "CONSTANT_P", "(", "OP", "(", "2", ")", ")", ")", "{", "rtx", "tmp", "=", "OP", "(", "1", ")", ";", "OP", "(", "1", ")", "=", "OP", "(", "2", ")", ";", "OP", "(", "2", ")", "=", "tmp", ";", "}", "OP", "(", "0", ")", "=", "move_from_acc", "(", "0", ",", "insn", ")", ";", "tmp_id", "=", "get_max_insn_count", "(", ")", ";", "saved_op1", "=", "OP", "(", "1", ")", ";", "if", "(", "rtx_equal_p", "(", "OP", "(", "1", ")", ",", "OP", "(", "2", ")", ")", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "OP", "(", "2", ")", ")", "==", "QImode", ")", ";", "OP", "(", "2", ")", "=", "move_to_x", "(", "2", ",", "insn", ")", ";", "OP", "(", "1", ")", "=", "A", ";", "}", "else", "OP", "(", "1", ")", "=", "move_to_acc", "(", "1", ",", "insn", ")", ";", "MAYBE_OK", "(", "insn", ")", ";", "if", "(", "tmp_id", "==", "get_max_insn_count", "(", ")", ")", "force_into_acc", "(", "saved_op1", ",", "insn", ")", ";", "if", "(", "prev", ")", "first", "=", "next_nonnote_nondebug_insn", "(", "prev", ")", ";", "else", "for", "(", "first", "=", "insn", ";", "prev_nonnote_nondebug_insn", "(", "first", ")", ";", "first", "=", "prev_nonnote_nondebug_insn", "(", "first", ")", ")", ";", "OP", "(", "2", ")", "=", "move_to_x", "(", "2", ",", "first", ")", ";", "MUST_BE_OK", "(", "insn", ")", ";", "}", "</s>" ]

[ "Like", "op2", ",", "but", "AX", "=", "A", "*", "X", "." ]

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

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "hasFnAttr", "(", "Attribute", "::", "OptimizeForSize", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "||", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "EVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "bool", "SrcIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "EVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "static", "reg_class_t", "ia64_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "switch", "(", "rclass", ")", "{", "case", "FR_REGS", ":", "case", "FP_REGS", ":", "if", "(", "MEM_P", "(", "x", ")", "&&", "MEM_VOLATILE_P", "(", "x", ")", ")", "return", "NO_REGS", ";", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "NO_REGS", ";", "break", ";", "case", "AR_M_REGS", ":", "case", "AR_I_REGS", ":", "if", "(", "!", "OBJECT_P", "(", "x", ")", ")", "return", "NO_REGS", ";", "break", ";", "default", ":", "break", ";", "}", "return", "rclass", ";", "}", "</s>" ]

[ "Implement", "PREFERRED_RELOAD_CLASS", ".", "Place", "additional", "restrictions", "on", "CLASS", "to", "use", "when", "copying", "X", "into", "that", "class", "." ]

[ "ia64" ]

[]

[ "<s>", "ARCSubtarget", "::", "ARCSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "ARCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "FrameLowering", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

[ "ARC", "ARC", "ARC", "ARC" ]

[]

[ "<s>", "static", "rtx", "mips_return_fpr_pair", "(", "machine_mode", "mode", ",", "machine_mode", "mode1", ",", "HOST_WIDE_INT", "offset1", ",", "machine_mode", "mode2", ",", "HOST_WIDE_INT", "offset2", ")", "{", "int", "inc", ";", "inc", "=", "(", "TARGET_NEWABI", "||", "mips_abi", "==", "ABI_32", "?", "2", ":", "MAX_FPRS_PER_FMT", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode1", ",", "FP_RETURN", ")", ",", "GEN_INT", "(", "offset1", ")", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode2", ",", "FP_RETURN", "+", "inc", ")", ",", "GEN_INT", "(", "offset2", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "composite", "value", "in", "a", "pair", "of", "floating-point", "registers", ".", "MODE1", "and", "OFFSET1", "are", "the", "mode", "and", "byte", "offset", "for", "the", "first", "value", ",", "likewise", "MODE2", "and", "OFFSET2", "for", "the", "second", ".", "MODE", "is", "the", "mode", "of", "the", "complete", "value", ".", "For", "n32", "&", "n64", ",", "$", "f0", "always", "holds", "the", "first", "value", "and", "$", "f2", "the", "second", ".", "Otherwise", "the", "values", "are", "packed", "together", "as", "closely", "as", "possible", "." ]

[ "mips", "2", "2" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "if", "(", "!", "MI", "->", "mayLoad", "(", ")", "&&", "!", "MI", "->", "mayStore", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "16", "*", "20", ";", "Offset", "+=", "MFI", "->", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "128", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "isFrameOffsetLegal", "(", "MI", ",", "AArch64", "::", "FP", ",", "FPOffset", ")", ")", "return", "false", ";", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "AArch64", "::", "SP", ",", "Offset", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "AArch64", "AArch64", "0", "\"Instr doesn't have FrameIndex operand!\"", "16", "20", "128", "AArch64::FP", "AArch64::SP" ]

[]

[ "<s>", "void", "AArch64RegisterBankInfo", "::", "applyMappingImpl", "(", "const", "OperandsMapper", "&", "OpdMapper", ")", "const", "{", "switch", "(", "OpdMapper", ".", "getMI", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_OR", ":", "{", "assert", "(", "(", "OpdMapper", ".", "getInstrMapping", "(", ")", ".", "getID", "(", ")", "==", "1", "||", "OpdMapper", ".", "getInstrMapping", "(", ")", ".", "getID", "(", ")", "==", "2", ")", "&&", "\"Don't know how to handle that ID\"", ")", ";", "return", "applyDefaultMapping", "(", "OpdMapper", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Don't know how to handle that operation\"", ")", ";", "}", "}", "</s>" ]

[ "See", "RegisterBankInfo", ":", ":applyMapping", "." ]

[ "AArch64", "AArch64", "1", "2", "\"Don't know how to handle that ID\"", "\"Don't know how to handle that operation\"" ]

[]

[ "<s>", "SparcTargetLowering", "::", "ConstraintType", "SparcTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'I'", ":", "return", "C_Other", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "Sparc", "Sparc", "Sparc", "1", "0" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "override", "{", "if", "(", "VT", ".", "isScalableVector", "(", ")", "||", "VT", ".", "getVectorNumElements", "(", ")", "==", "1", ")", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "if", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "==", "1", "&&", "VT", ".", "getSizeInBits", "(", ")", ">", "16", ")", "return", "TypeSplitVector", ";", "if", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "==", "1", ")", "return", "TypePromoteInteger", ";", "if", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "%", "8", "==", "0", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "PowerPC", "1", "1", "16", "1", "8", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "(", "MI", ".", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ")", ")", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "A2_tfrsi", ")", "{", "auto", "Op", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "Op", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_GlobalAddress", ")", "return", "false", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "16", ">", "(", "Imm", ")", ")", "return", "false", ";", "}", "}", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "Hexagon", "Hexagon", "Hexagon::A2_tfrsi", "1", "16" ]

[]

[ "<s>", "static", "int", "mips_fpr_return_fields", "(", "const_tree", "valtype", ",", "tree", "*", "fields", ",", "bool", "*", "has_cxx_zero_width_bf", ",", "bool", "*", "has_cxx17_empty_base", ")", "{", "tree", "field", ";", "int", "i", ";", "if", "(", "!", "TARGET_NEWABI", ")", "return", "0", ";", "if", "(", "TREE_CODE", "(", "valtype", ")", "!=", "RECORD_TYPE", ")", "return", "0", ";", "i", "=", "0", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "valtype", ")", ";", "field", "!=", "0", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "if", "(", "cxx17_empty_base_field_p", "(", "field", ")", ")", "{", "*", "has_cxx17_empty_base", "=", "true", ";", "continue", ";", "}", "if", "(", "DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD", "(", "field", ")", ")", "{", "*", "has_cxx_zero_width_bf", "=", "true", ";", "continue", ";", "}", "if", "(", "!", "SCALAR_FLOAT_TYPE_P", "(", "TREE_TYPE", "(", "field", ")", ")", ")", "return", "0", ";", "if", "(", "i", "==", "2", ")", "return", "0", ";", "fields", "[", "i", "++", "]", "=", "field", ";", "}", "return", "i", ";", "}", "</s>" ]

[ "See", "whether", "VALTYPE", "is", "a", "record", "whose", "fields", "should", "be", "returned", "in", "floating-point", "registers", ".", "If", "so", ",", "return", "the", "number", "of", "fields", "and", "list", "them", "in", "FIELDS", "(", "which", "should", "have", "two", "elements", ")", ".", "Return", "0", "otherwise", ".", "For", "n32", "&", "n64", ",", "a", "structure", "with", "one", "or", "two", "fields", "is", "returned", "in", "floating-point", "registers", "as", "long", "as", "every", "field", "has", "a", "floating-point", "type", ".", "The", "C++", "FE", "used", "to", "remove", "zero-width", "bit-fields", "in", "GCC", "11", "and", "earlier", ".", "To", "make", "a", "proper", "diagnostic", ",", "this", "function", "will", "set", "HAS_CXX_ZERO_WIDTH_BF", "to", "true", "once", "a", "C++", "zero-width", "bit-field", "shows", "up", ",", "and", "then", "ignore", "it", ".", "We", "had", "failed", "to", "ignore", "C++17", "empty", "bases", "in", "GCC", "7", ",", "8", ",", "9", ",", "10", ",", "and", "11", ".", "This", "caused", "an", "ABI", "incompatibility", "between", "C++14", "and", "C++17", ".", "This", "is", "fixed", "now", "and", "to", "make", "a", "proper", "diagnostic", ",", "this", "function", "will", "set", "HAS_CXX17_EMPTY_BASE", "to", "true", "once", "a", "C++17", "empty", "base", "shows", "up", ",", "and", "then", "ignore", "it", ".", "The", "caller", "should", "use", "the", "value", "of", "HAS_CXX17_EMPTY_BASE", "and/or", "HAS_CXX_ZERO_WIDTH_BF", "to", "emit", "a", "proper", "-Wpsabi", "inform", "." ]

[ "mips", "0", "0", "0", "0", "0", "2", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isDesirableToCommuteWithShift", "(", "const", "SDNode", "*", "N", ")", "const", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", ")", "{", "uint64_t", "TruncMask", "=", "N", "->", "getConstantOperandVal", "(", "1", ")", ";", "if", "(", "isMask_64", "(", "TruncMask", ")", "&&", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "isa", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "move", "this", "shift", "by", "a", "constant", "amount", "through", "its", "operand", ",", "adjusting", "any", "immediate", "operands", "as", "necessary", "to", "preserve", "semantics", "." ]

[ "AArch64", "AArch64", "0", "ISD::AND", "MVT::i32", "MVT::i64", "1", "1", "0", "ISD::SRL", "0", "1" ]

[]

[ "<s>", "int", "visium_initial_elimination_offset", "(", "int", "from", ",", "int", "to", "ATTRIBUTE_UNUSED", ")", "{", "const", "int", "save_fp", "=", "current_frame_info", ".", "save_fp", ";", "const", "int", "save_lr", "=", "current_frame_info", ".", "save_lr", ";", "const", "int", "lr_slot", "=", "current_frame_info", ".", "lr_slot", ";", "int", "offset", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "offset", "=", "(", "save_fp", "+", "save_lr", "+", "lr_slot", ")", "*", "UNITS_PER_WORD", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", ")", "offset", "=", "visium_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "return", "offset", ";", "}", "</s>" ]

[ "Helper", "function", "for", "INITIAL_ELIMINATION_OFFSET", "(", "FROM", ",", "TO", ",", "OFFSET", ")", ".", "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "visium" ]

[]

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

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

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

[]

[ "<s>", "void", "emitValueImpl", "(", "const", "MCExpr", "*", "Value", ",", "unsigned", "Size", ",", "SMLoc", "Loc", ")", "override", "{", "emitDataMappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "emitValueImpl", "(", "Value", ",", "Size", ",", "Loc", ")", ";", "}", "</s>" ]

[ "Overriding", "these", "functions", "allows", "us", "to", "dismiss", "all", "labels", "that", "are", "candidates", "for", "marking", "as", "microMIPS", "when", ".word/.long/.4byte", "etc", "directives", "are", "emitted", "." ]

[ "AArch64" ]

[]

[ "<s>", "int", "avr_hard_regno_mode_ok", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "REG_Y", "&&", "mode", "==", "Pmode", ")", "return", "1", ";", "if", "(", "regno", "<=", "(", "REG_Y", "+", "1", ")", "&&", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ")", ">=", "(", "REG_Y", "+", "1", ")", ")", "return", "0", ";", "if", "(", "mode", "==", "QImode", ")", "return", "1", ";", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "FIRST_PSEUDO_REGISTER", ")", "return", "0", ";", "return", "!", "(", "regno", "&", "1", ")", ";", "}", "</s>" ]

[ "Returns", "1", "if", "a", "value", "of", "mode", "MODE", "can", "be", "stored", "starting", "with", "hard", "register", "number", "REGNO", ".", "On", "the", "enhanced", "core", ",", "anything", "larger", "than", "1", "byte", "must", "start", "in", "even", "numbered", "register", "for", "``", "movw", "''", "to", "work", "(", "this", "way", "we", "do", "n't", "have", "to", "check", "for", "odd", "registers", "everywhere", ")", "." ]

[ "avr", "1", "1", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "getTOCSaveOffset", "(", ")", "const", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"TOC save is not implemented on AIX yet.\"", ")", ";", "return", "TOCSaveOffset", ";", "}", "</s>" ]

[ "getTOCSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "TOC", "register", "�", "?", "64-bit", "SVR4", "ABI", "only", "." ]

[ "PowerPC", "PPC", "\"TOC save is not implemented on AIX yet.\"" ]

[]

[ "<s>", "bool", "AMDGPUPrintfRuntimeBinding", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "return", "false", ";", "visit", "(", "M", ")", ";", "if", "(", "Printfs", ".", "empty", "(", ")", ")", "return", "false", ";", "TD", "=", "&", "M", ".", "getDataLayout", "(", ")", ";", "auto", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "TLI", "=", "&", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", ")", ";", "return", "lowerPrintfForGpu", "(", "M", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "parse_codes", "parse_ovld_stanza", "(", "void", ")", "{", "pos", "=", "0", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "'['", ")", "{", "diag", "(", "pos", ",", "\"ill-formed stanza header.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "safe_inc_pos", "(", ")", ";", "char", "*", "stanza_name", "=", "match_identifier", "(", ")", ";", "if", "(", "!", "stanza_name", ")", "{", "diag", "(", "pos", ",", "\"no identifier found in stanza header.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "if", "(", "num_ovld_stanzas", ">=", "MAXOVLDSTANZAS", ")", "{", "diag", "(", "pos", ",", "\"too many stanza headers.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "curr_ovld_stanza", "=", "num_ovld_stanzas", "++", ";", "ovld_stanza", "*", "stanza", "=", "&", "ovld_stanzas", "[", "curr_ovld_stanza", "]", ";", "stanza", "->", "stanza_id", "=", "stanza_name", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "','", ")", "{", "diag", "(", "pos", ",", "\"missing comma.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "safe_inc_pos", "(", ")", ";", "consume_whitespace", "(", ")", ";", "stanza", "->", "extern_name", "=", "match_identifier", "(", ")", ";", "if", "(", "!", "stanza", "->", "extern_name", ")", "{", "diag", "(", "pos", ",", "\"missing external name.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "','", ")", "{", "diag", "(", "pos", ",", "\"missing comma.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "safe_inc_pos", "(", ")", ";", "consume_whitespace", "(", ")", ";", "stanza", "->", "intern_name", "=", "match_identifier", "(", ")", ";", "if", "(", "!", "stanza", "->", "intern_name", ")", "{", "diag", "(", "pos", ",", "\"missing internal name.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "==", "','", ")", "{", "safe_inc_pos", "(", ")", ";", "consume_whitespace", "(", ")", ";", "stanza", "->", "ifdef", "=", "match_identifier", "(", ")", ";", "if", "(", "!", "stanza", "->", "ifdef", ")", "{", "diag", "(", "pos", ",", "\"missing ifdef token.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "consume_whitespace", "(", ")", ";", "}", "else", "stanza", "->", "ifdef", "=", "0", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "']'", ")", "{", "diag", "(", "pos", ",", "\"ill-formed stanza header.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "safe_inc_pos", "(", ")", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "'\\n'", "&&", "pos", "!=", "LINELEN", "-", "1", ")", "{", "diag", "(", "pos", ",", "\"garbage after stanza header.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "parse_codes", "result", "=", "PC_OK", ";", "while", "(", "result", "!=", "PC_EOSTANZA", ")", "{", "if", "(", "!", "advance_line", "(", "ovld_file", ")", ")", "return", "PC_EOFILE", ";", "result", "=", "parse_ovld_entry", "(", ")", ";", "if", "(", "result", "==", "PC_EOFILE", "||", "result", "==", "PC_PARSEFAIL", ")", "return", "result", ";", "}", "return", "PC_OK", ";", "}", "</s>" ]

[ "Parse", "one", "stanza", "of", "the", "input", "overload", "file", ".", "linebuf", "already", "contains", "the", "first", "line", "to", "parse", "." ]

[ "rs6000", "0", "\"ill-formed stanza header.\\n\"", "\"no identifier found in stanza header.\\n\"", "\"too many stanza headers.\\n\"", "\"missing comma.\\n\"", "\"missing external name.\\n\"", "\"missing comma.\\n\"", "\"missing internal name.\\n\"", "\"missing ifdef token.\\n\"", "0", "\"ill-formed stanza header.\\n\"", "1", "\"garbage after stanza header.\\n\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "int64_t", "AbsImm", "=", "std", "::", "abs", "(", "Imm", ")", ";", "if", "(", "!", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "ARM_AM", "::", "getSOImmVal", "(", "AbsImm", ")", "!=", "-", "1", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "return", "ARM_AM", "::", "getT2SOImmVal", "(", "AbsImm", ")", "!=", "-", "1", ";", "return", "AbsImm", ">=", "0", "&&", "AbsImm", "<=", "255", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "ARM", "ARM", "ARM_AM::getSOImmVal", "1", "ARM_AM::getT2SOImmVal", "1", "0", "255" ]

[]

[ "<s>", "static", "void", "avr_fix_operands", "(", "rtx", "*", "op", ",", "rtx", "*", "hreg", ",", "unsigned", "opmask", ",", "unsigned", "rmask", ")", "{", "for", "(", ";", "opmask", ";", "opmask", ">>=", "1", ",", "op", "++", ")", "{", "rtx", "reg", "=", "*", "op", ";", "if", "(", "hreg", ")", "*", "hreg", "=", "NULL_RTX", ";", "if", "(", "(", "opmask", "&", "1", ")", "&&", "REG_P", "(", "reg", ")", "&&", "REGNO", "(", "reg", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "(", "rmask", "&", "regmask", "(", "GET_MODE", "(", "reg", ")", ",", "REGNO", "(", "reg", ")", ")", ")", ")", "{", "*", "op", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "reg", ")", ")", ";", "if", "(", "hreg", "==", "NULL", ")", "emit_move_insn", "(", "*", "op", ",", "reg", ")", ";", "else", "*", "hreg", "=", "reg", ";", "}", "if", "(", "hreg", ")", "hreg", "++", ";", "}", "}", "</s>" ]

[ "PR63633", ":", "The", "middle-end", "might", "come", "up", "with", "hard", "regs", "as", "input", "operands", ".", "RMASK", "is", "a", "bit", "mask", "representing", "a", "subset", "of", "hard", "registers", "R0", "...", "R31", ":", "Rn", "is", "an", "element", "of", "that", "set", "iff", "bit", "n", "of", "RMASK", "is", "set", ".", "OPMASK", "describes", "a", "subset", "of", "OP", "[", "]", ":", "If", "bit", "n", "of", "OPMASK", "is", "1", "then", "OP", "[", "n", "]", "has", "to", "be", "fixed", ";", "otherwise", "OP", "[", "n", "]", "is", "left", "alone", ".", "For", "each", "element", "of", "OPMASK", "which", "is", "a", "hard", "register", "overlapping", "RMASK", ",", "replace", "OP", "[", "n", "]", "with", "a", "newly", "created", "pseudo", "register", "HREG", "==", "0", ":", "Also", "emit", "a", "move", "insn", "that", "copies", "the", "contents", "of", "that", "hard", "register", "into", "the", "new", "pseudo", ".", "HREG", "!", "=", "0", ":", "Also", "set", "HREG", "[", "n", "]", "to", "the", "hard", "register", "." ]

[ "avr", "1", "1" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ",", "const", "SelectionDAG", "&", "DAG", ")", "const", "{", "bool", "NoFloat", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "NoFloat", ")", "{", "unsigned", "MaxIntSize", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "MaxIntSize", ")", ";", "}", "if", "(", "MemVT", ".", "getSizeInBits", "(", ")", ">", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ")", "return", "false", ";", "if", "(", "MemVT", "==", "MVT", "::", "v256i32", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

[ "X86", "X86", "64", "32", "MVT::v256i32" ]

[]

[ "<s>", "bool", "PIC16AsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "O", "<<", "\"\\n\\t#include P16F1937.INC\\n\"", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "!", "I", "->", "isDeclaration", "(", ")", "&&", "!", "I", "->", "hasAvailableExternallyLinkage", "(", ")", ")", "{", "const", "MCSection", "*", "S", "=", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "I", ",", "Mang", ",", "TM", ")", ";", "I", "->", "setSection", "(", "(", "(", "const", "MCSectionPIC16", "*", ")", "S", ")", "->", "getName", "(", ")", ")", ";", "}", "DbgInfo", ".", "BeginModule", "(", "M", ")", ";", "EmitFunctionDecls", "(", "M", ")", ";", "EmitUndefinedVars", "(", "M", ")", ";", "EmitDefinedVars", "(", "M", ")", ";", "EmitIData", "(", "M", ")", ";", "EmitUData", "(", "M", ")", ";", "EmitRomData", "(", "M", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "PIC16", "PIC16", "\"\\n\\t#include P16F1937.INC\\n\"", "PIC16" ]

[]

[ "<s>", "static", "void", "aarch64_emit_unspec_cond_or", "(", "rtx", "target", ",", "rtx_code", "code1", ",", "rtx_code", "code2", ",", "machine_mode", "pred_mode", ",", "rtx", "ptrue", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "tmp1", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_unspec_cond", "(", "tmp1", ",", "code1", ",", "pred_mode", ",", "ptrue", ",", "op0", ",", "op1", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_unspec_cond", "(", "tmp2", ",", "code2", ",", "pred_mode", ",", "ptrue", ",", "op0", ",", "op1", ")", ";", "emit_set_insn", "(", "target", ",", "gen_rtx_AND", "(", "pred_mode", ",", "gen_rtx_IOR", "(", "pred_mode", ",", "tmp1", ",", "tmp2", ")", ",", "ptrue", ")", ")", ";", "}", "</s>" ]

[ "Emit", ":", "(", "set", "TMP1", "(", "unspec", ":", "PRED_MODE", "[", "PTRUE", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X1", ">", ")", ")", "(", "set", "TMP2", "(", "unspec", ":", "PRED_MODE", "[", "PTRUE", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X2", ">", ")", ")", "(", "set", "TARGET", "(", "and", ":", "PRED_MODE", "(", "ior", ":", "PRED_MODE", "TMP1", "TMP2", ")", "PTRUE", ")", ")", "where", "<", "Xi", ">", "is", "the", "operation", "associated", "with", "comparison", "CODEi", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "long_immediate_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "1", ";", "case", "CONST_INT", ":", "return", "!", "SMALL_INT", "(", "INTVAL", "(", "op", ")", ")", ";", "case", "CONST_DOUBLE", ":", "return", "1", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "will", "require", "a", "long", "immediate", "(", "limm", ")", "value", ".", "This", "is", "currently", "only", "used", "when", "calculating", "length", "attributes", "." ]

[ "arc", "1", "1", "0" ]

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "bool", "Vector", ")", "const", "override", "{", "if", "(", "Vector", ")", "{", "if", "(", "ST", "->", "hasNEON", "(", ")", ")", "return", "32", ";", "return", "0", ";", "}", "return", "31", ";", "}", "</s>" ]

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

[ "ARM64", "32", "0", "31" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "LowerSMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "LowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "ExpandADDSUB", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAME_TO_ARGS_OFFSET", ":", "return", "LowerFRAME_TO_ARGS_OFFSET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD", ":", "return", "LowerATOMIC_LOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_STORE", ":", "return", "LowerATOMIC_STORE", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::EH_RETURN", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::BR_JT", "ISD::LOAD", "ISD::STORE", "ISD::SELECT_CC", "ISD::VAARG", "ISD::VASTART", "ISD::SMUL_LOHI", "ISD::UMUL_LOHI", "ISD::ADD", "ISD::SUB", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::FRAME_TO_ARGS_OFFSET", "ISD::INIT_TRAMPOLINE", "ISD::ADJUST_TRAMPOLINE", "ISD::INTRINSIC_WO_CHAIN", "ISD::ATOMIC_FENCE", "ISD::ATOMIC_LOAD", "ISD::ATOMIC_STORE", "\"unimplemented operand\"" ]

[]

[ "<s>", "static", "bool", "arm_tls_symbol_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "is", "a", "thread-local", "symbol", "." ]

[ "arm", "0" ]

[]

[ "<s>", "const", "X86InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "X86AsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "static", "const", "uint8_t", "TrueNops", "[", "10", "]", "[", "10", "]", "=", "{", "{", "0x90", "}", ",", "{", "0x66", ",", "0x90", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x40", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x80", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x2e", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "}", ";", "static", "const", "uint8_t", "AltNops", "[", "7", "]", "[", "10", "]", "=", "{", "{", "0x90", "}", ",", "{", "0x66", ",", "0x90", "}", ",", "{", "0x8d", ",", "0x76", ",", "0x00", "}", ",", "{", "0x8d", ",", "0x74", ",", "0x26", ",", "0x00", "}", ",", "{", "0x90", ",", "0x8d", ",", "0x74", ",", "0x26", ",", "0x00", "}", ",", "{", "0x8d", ",", "0xb6", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x8d", ",", "0xb4", ",", "0x26", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "}", ";", "const", "uint8_t", "(", "*", "Nops", ")", "[", "10", "]", "=", "HasNopl", "?", "TrueNops", ":", "AltNops", ";", "assert", "(", "HasNopl", "||", "MaxNopLength", "<=", "7", ")", ";", "do", "{", "const", "uint8_t", "ThisNopLength", "=", "(", "uint8_t", ")", "std", "::", "min", "(", "Count", ",", "MaxNopLength", ")", ";", "const", "uint8_t", "Prefixes", "=", "ThisNopLength", "<=", "10", "?", "0", ":", "ThisNopLength", "-", "10", ";", "for", "(", "uint8_t", "i", "=", "0", ";", "i", "<", "Prefixes", ";", "i", "++", ")", "OW", "->", "write8", "(", "0x66", ")", ";", "const", "uint8_t", "Rest", "=", "ThisNopLength", "-", "Prefixes", ";", "for", "(", "uint8_t", "i", "=", "0", ";", "i", "<", "Rest", ";", "i", "++", ")", "OW", "->", "write8", "(", "Nops", "[", "Rest", "-", "1", "]", "[", "i", "]", ")", ";", "Count", "-=", "ThisNopLength", ";", "}", "while", "(", "Count", "!=", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "10", "10", "0x90", "0x66", "0x90", "0x0f", "0x1f", "0x00", "0x0f", "0x1f", "0x40", "0x00", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x0f", "0x1f", "0x80", "0x00", "0x00", "0x00", "0x00", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x2e", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "7", "10", "0x90", "0x66", "0x90", "0x8d", "0x76", "0x00", "0x8d", "0x74", "0x26", "0x00", "0x90", "0x8d", "0x74", "0x26", "0x00", "0x8d", "0xb6", "0x00", "0x00", "0x00", "0x00", "0x8d", "0xb4", "0x26", "0x00", "0x00", "0x00", "0x00", "10", "7", "10", "0", "10", "0", "0x66", "0", "1", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "R600RegisterInfo", "::", "getCFGStructurizerRegClass", "(", "MVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "case", "MVT", "::", "i32", ":", "return", "&", "AMDGPU", "::", "R600_TReg32RegClass", ";", "}", "}", "</s>" ]

[ "get", "the", "register", "class", "of", "the", "specified", "type", "to", "use", "in", "the", "CFGStructurizer" ]

[ "AMDGPU", "R600", "MVT::i32", "AMDGPU::R600_TReg32RegClass" ]

[]

[ "<s>", "bool", "CAHPPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createCAHPISelDag", "(", "getCAHPTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP", "CAHP" ]

[]