Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "char", "*", "output_64bit_ior", "(", "rtx", "*", "operands", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "int", "bs0", ",", "bs1", ",", "p", ",", "len", ";", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "==", "0", ")", "return", "\"copy %1,%0\"", ";", "for", "(", "bs0", "=", "0", ";", "bs0", "<", "HOST_BITS_PER_WIDE_INT", ";", "bs0", "++", ")", "if", "(", "(", "mask", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "bs0", ")", ")", "!=", "0", ")", "break", ";", "for", "(", "bs1", "=", "bs0", ";", "bs1", "<", "HOST_BITS_PER_WIDE_INT", ";", "bs1", "++", ")", "if", "(", "(", "mask", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "bs1", ")", ")", "==", "0", ")", "break", ";", "gcc_assert", "(", "bs1", "==", "HOST_BITS_PER_WIDE_INT", "||", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "bs1", ")", ">", "mask", ")", ";", "p", "=", "63", "-", "bs0", ";", "len", "=", "bs1", "-", "bs0", ";", "operands", "[", "2", "]", "=", "GEN_INT", "(", "p", ")", ";", "operands", "[", "3", "]", "=", "GEN_INT", "(", "len", ")", ";", "return", "\"depdi -1,%2,%3,%0\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "perform", "a", "bitwise-and", "of", "operands", "[", "1", "]", "with", "operands", "[", "2", "]", "storing", "the", "result", "in", "operands", "[", "0", "]", "." ]

[ "pa", "2", "2", "0", "\"copy %1,%0\"", "0", "1", "0", "1", "0", "1", "63", "2", "3", "\"depdi -1,%2,%3,%0\"" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "getTgtMemIntrinsic", "(", "IntrinsicInst", "*", "Inst", ",", "MemIntrinsicInfo", "&", "Info", ")", "{", "switch", "(", "Inst", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_lvx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_lvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvewx", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvw4x", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvd2x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvw4x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvl", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvll", ":", "{", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "0", ")", ";", "Info", ".", "ReadMem", "=", "true", ";", "Info", ".", "WriteMem", "=", "false", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "ppc_altivec_stvx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvw4x", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvw4x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvl", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvll", ":", "{", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "1", ")", ";", "Info", ".", "ReadMem", "=", "false", ";", "Info", ".", "WriteMem", "=", "true", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "PowerPC", "PPC", "Intrinsic::ppc_altivec_lvx", "Intrinsic::ppc_altivec_lvxl", "Intrinsic::ppc_altivec_lvebx", "Intrinsic::ppc_altivec_lvehx", "Intrinsic::ppc_altivec_lvewx", "Intrinsic::ppc_vsx_lxvd2x", "Intrinsic::ppc_vsx_lxvw4x", "Intrinsic::ppc_vsx_lxvd2x_be", "Intrinsic::ppc_vsx_lxvw4x_be", "Intrinsic::ppc_vsx_lxvl", "Intrinsic::ppc_vsx_lxvll", "0", "Intrinsic::ppc_altivec_stvx", "Intrinsic::ppc_altivec_stvxl", "Intrinsic::ppc_altivec_stvebx", "Intrinsic::ppc_altivec_stvehx", "Intrinsic::ppc_altivec_stvewx", "Intrinsic::ppc_vsx_stxvd2x", "Intrinsic::ppc_vsx_stxvw4x", "Intrinsic::ppc_vsx_stxvd2x_be", "Intrinsic::ppc_vsx_stxvw4x_be", "Intrinsic::ppc_vsx_stxvl", "Intrinsic::ppc_vsx_stxvll", "1" ]

[]

[ "<s>", "void", "rs6000_expand_vector_set", "(", "rtx", "target", ",", "rtx", "val", ",", "int", "elt", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "mask", ",", "mem", ",", "x", ";", "int", "width", "=", "GET_MODE_SIZE", "(", "inner_mode", ")", ";", "int", "i", ";", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "(", "mode", "==", "V2DFmode", "||", "mode", "==", "V2DImode", ")", ")", "{", "rtx", "(", "*", "set_func", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", "=", "(", "(", "mode", "==", "V2DFmode", ")", "?", "gen_vsx_set_v2df", ":", "gen_vsx_set_v2di", ")", ";", "emit_insn", "(", "set_func", "(", "target", ",", "target", ",", "val", ",", "GEN_INT", "(", "elt", ")", ")", ")", ";", "return", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "GET_MODE_SIZE", "(", "inner_mode", ")", "&&", "elt", "==", "0", ")", "{", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "mode", ",", "val", ")", ")", ";", "return", ";", "}", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "0", ")", ",", "val", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_LVE", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ",", "x", ")", ")", ")", ";", "mask", "=", "gen_rtx_PARALLEL", "(", "V16QImode", ",", "rtvec_alloc", "(", "16", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "++", "i", ")", "XVECEXP", "(", "mask", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "width", ";", "++", "i", ")", "XVECEXP", "(", "mask", ",", "0", ",", "elt", "*", "width", "+", "i", ")", "=", "GEN_INT", "(", "i", "+", "0x10", ")", ";", "x", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "XVEC", "(", "mask", ",", "0", ")", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "x", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "target", ",", "reg", ",", "force_reg", "(", "V16QImode", ",", "x", ")", ")", ",", "UNSPEC_VPERM", ")", ";", "else", "{", "rtx", "notx", "=", "gen_rtx_NOT", "(", "V16QImode", ",", "force_reg", "(", "V16QImode", ",", "x", ")", ")", ";", "rtx", "iorx", "=", "(", "TARGET_P8_VECTOR", "?", "gen_rtx_IOR", "(", "V16QImode", ",", "notx", ",", "notx", ")", ":", "gen_rtx_AND", "(", "V16QImode", ",", "notx", ",", "notx", ")", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "iorx", ")", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "reg", ",", "target", ",", "tmp", ")", ",", "UNSPEC_VPERM", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Set", "field", "ELT_RTX", "of", "TARGET", "to", "VAL", "." ]

[ "rs6000", "0", "0", "1", "2", "16", "0", "16", "0", "0", "0", "0x10", "0", "3", "3" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "bool", "SCS", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "ShadowCallStack", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "SCS", "?", "CSR_AArch64_NoRegs_SCS_RegMask", ":", "CSR_AArch64_NoRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "SCS", "?", "CSR_AArch64_AllRegs_SCS_RegMask", ":", "CSR_AArch64_AllRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "SCS", "?", "CSR_AArch64_CXX_TLS_Darwin_SCS_RegMask", ":", "CSR_AArch64_CXX_TLS_Darwin_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "SCS", "?", "CSR_AArch64_AAVPCS_SCS_RegMask", ":", "CSR_AArch64_AAVPCS_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "SCS", "?", "CSR_AArch64_AAPCS_SwiftError_SCS_RegMask", ":", "CSR_AArch64_AAPCS_SwiftError_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "PreserveMost", ")", "return", "SCS", "?", "CSR_AArch64_RT_MostRegs_SCS_RegMask", ":", "CSR_AArch64_RT_MostRegs_RegMask", ";", "else", "return", "SCS", "?", "CSR_AArch64_AAPCS_SCS_RegMask", ":", "CSR_AArch64_AAPCS_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "aarch64_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", ")", "{", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "bool", "from_sve_p", "=", "aarch64_sve_data_mode_p", "(", "from", ")", ";", "bool", "to_sve_p", "=", "aarch64_sve_data_mode_p", "(", "to", ")", ";", "if", "(", "from_sve_p", "!=", "to_sve_p", ")", "return", "false", ";", "if", "(", "from_sve_p", "&&", "GET_MODE_UNIT_SIZE", "(", "from", ")", "!=", "GET_MODE_UNIT_SIZE", "(", "to", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "aarch64" ]

[]

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

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

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "const", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "unsigned", "ValRegIndex", ",", "Register", "Addr", ",", "LLT", "MemTy", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "Register", "ValVReg", "=", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "LocInfo", "::", "FPExt", "?", "extendRegister", "(", "Arg", ".", "Regs", "[", "ValRegIndex", "]", ",", "VA", ")", ":", "Arg", ".", "Regs", "[", "ValRegIndex", "]", ";", "assignValueToAddress", "(", "ValVReg", ",", "Addr", ",", "MemTy", ",", "MPO", ",", "VA", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

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

[ "Return", "the", "contained", "Value", "." ]

[ "X86", "1" ]

[]

[ "<s>", "unsigned", "ARMCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "ARMRegisterInfo", "::", "getRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ",", "true", ",", "false", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "{", "const", "TargetInstrDesc", "&", "TID", "=", "MI", ".", "getDesc", "(", ")", ";", "unsigned", "Reloc", "=", "(", "(", "TID", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "==", "ARMII", "::", "VFPLdStFrm", ")", "?", "ARM", "::", "reloc_arm_vfp_cp_entry", ":", "ARM", "::", "reloc_arm_cp_entry", ";", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "Reloc", ")", ";", "}", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "ARM", "::", "reloc_arm_relative", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "{", "errs", "(", ")", "<<", "MO", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM::reloc_arm_branch", "ARM::reloc_arm_branch", "ARMII::FormMask", "ARMII::VFPLdStFrm", "ARM::reloc_arm_vfp_cp_entry", "ARM::reloc_arm_cp_entry", "ARM::reloc_arm_relative", "ARM::reloc_arm_branch", "0", "0" ]

[]

[ "<s>", "static", "int", "calc_live_regs", "(", "int", "*", "count", ")", "{", "int", "reg", ";", "int", "live_regs_mask", "=", "0", ";", "*", "count", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "FIRST_PSEUDO_REGISTER", ";", "reg", "++", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "!", "call_used_regs", "[", "reg", "]", ")", "{", "(", "*", "count", ")", "++", ";", "live_regs_mask", "|=", "(", "1", "<<", "reg", ")", ";", "}", "}", "return", "live_regs_mask", ";", "}", "</s>" ]

[ "Work", "out", "the", "registers", "which", "need", "to", "be", "saved", ",", "both", "as", "a", "mask", "and", "a", "count" ]

[ "mcore", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SISubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "SeenFI", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isFI", "(", ")", ")", "{", "if", "(", "SeenFI", ")", "llvm_unreachable", "(", "\"should not see multiple frame indices\"", ")", ";", "SeenFI", "=", "true", ";", "}", "}", "MachineOperand", "*", "FIOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "assert", "(", "FIOp", "&&", "FIOp", "->", "isFI", "(", ")", "&&", "\"frame index must be address operand\"", ")", ";", "assert", "(", "TII", "->", "isMUBUF", "(", "MI", ")", ")", ";", "MachineOperand", "*", "OffsetOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "int64_t", "NewOffset", "=", "OffsetOp", "->", "getImm", "(", ")", "+", "Offset", ";", "assert", "(", "isUInt", "<", "12", ">", "(", "NewOffset", ")", "&&", "\"offset should be legal\"", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "\"should not see multiple frame indices\"", "AMDGPU::OpName", "\"frame index must be address operand\"", "AMDGPU::OpName", "12", "\"offset should be legal\"" ]

[]

[ "<s>", "static", "bool", "isNodeHidden", "(", "const", "ablock", "*", ",", "const", "agraph", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Do", "not", "print", "nodes", "that", "are", "part", "of", "a", "pi-block", "separately", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "SystemZElimCompare", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "*", "F", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "F", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "Changed", "|=", "processBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

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

[ "Return", "true", "if", "this", "asm", "streamer", "supports", "emitting", "unformatted", "text", "to", "the", ".s", "file", "with", "EmitRawText", "." ]

[ "Cpu0" ]

[]

[ "<s>", "unsigned", "OptimizePICCall", "::", "getReg", "(", "ValueType", "Entry", ")", "{", "unsigned", "Reg", "=", "ScopedHT", ".", "lookup", "(", "Entry", ")", ".", "second", ";", "assert", "(", "Reg", ")", ";", "return", "Reg", ";", "}", "</s>" ]

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

[ "Mips" ]

[]

[ "<s>", "void", "emitExportName", "(", "const", "MCSymbolWasm", "*", ",", "StringRef", ")", "override", "{", "}", "</s>" ]

[ ".export_name" ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "rtx_insn", "*", "emit_new_cond_insn", "(", "rtx", "insn", ",", "int", "cond", ")", "{", "rtx", "c_insn", "=", "0", ";", "rtx", "pat", ",", "dst", ",", "src", ";", "cond_type", "num", ";", "if", "(", "(", "num", "=", "is_cond_candidate", "(", "insn", ")", ")", "==", "COND_NO", ")", "return", "NULL", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", ")", "{", "dst", "=", "SET_DEST", "(", "pat", ")", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "}", "else", "{", "dst", "=", "JUMP_LABEL", "(", "insn", ")", ";", "src", "=", "NULL_RTX", ";", "}", "switch", "(", "num", ")", "{", "case", "COND_MOV_INSN", ":", "case", "COND_CLR_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_movt0", "(", "dst", ",", "src", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_movt0", "(", "dst", ",", "dst", ",", "src", ")", ";", "break", ";", "case", "COND_INC_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_incscc", "(", "dst", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_incscc_false", "(", "dst", ",", "dst", ")", ";", "break", ";", "case", "COND_DEC_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_decscc", "(", "dst", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_decscc_false", "(", "dst", ",", "dst", ")", ";", "break", ";", "case", "COND_BRANCH_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_branch_true", "(", "dst", ")", ";", "else", "c_insn", "=", "gen_branch_false", "(", "dst", ")", ";", "break", ";", "default", ":", "return", "NULL", ";", "}", "if", "(", "rtx_length", "[", "GET_CODE", "(", "c_insn", ")", "]", ">=", "7", "&&", "rtx_length", "[", "GET_CODE", "(", "insn", ")", "]", ">=", "7", ")", "{", "REG_NOTES", "(", "c_insn", ")", "=", "REG_NOTES", "(", "insn", ")", ";", "}", "if", "(", "num", "==", "COND_BRANCH_INSN", ")", "{", "c_insn", "=", "emit_jump_insn_before", "(", "c_insn", ",", "insn", ")", ";", "++", "LABEL_NUSES", "(", "dst", ")", ";", "JUMP_LABEL", "(", "c_insn", ")", "=", "dst", ";", "}", "else", "c_insn", "=", "emit_insn_after", "(", "c_insn", ",", "insn", ")", ";", "delete_insn", "(", "insn", ")", ";", "return", "as_a", "<", "rtx_insn", "*", ">", "(", "c_insn", ")", ";", "}", "</s>" ]

[ "Emit", "a", "conditional", "version", "of", "insn", "and", "replace", "the", "old", "insn", "with", "the", "new", "one", ".", "Return", "the", "new", "insn", "if", "emitted", "." ]

[ "mcore", "0", "7", "7" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getAddrModeArguments", "(", "IntrinsicInst", "*", "II", ",", "SmallVectorImpl", "<", "Value", "*", ">", "&", "Ops", ",", "Type", "*", "&", "AccessTy", ")", "const", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_add", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_swap", ":", "case", "Intrinsic", "::", "amdgcn_ds_append", ":", "case", "Intrinsic", "::", "amdgcn_ds_consume", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "case", "Intrinsic", "::", "amdgcn_global_atomic_fadd", ":", "case", "Intrinsic", "::", "amdgcn_flat_atomic_fadd", ":", "case", "Intrinsic", "::", "amdgcn_flat_atomic_fmin", ":", "case", "Intrinsic", "::", "amdgcn_flat_atomic_fmax", ":", "case", "Intrinsic", "::", "amdgcn_global_atomic_csub", ":", "{", "Value", "*", "Ptr", "=", "II", "->", "getArgOperand", "(", "0", ")", ";", "AccessTy", "=", "II", "->", "getType", "(", ")", ";", "Ops", ".", "push_back", "(", "Ptr", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "CodeGenPrepare", "sinks", "address", "calculations", "into", "the", "same", "BB", "as", "Load/Store", "instructions", "reading", "the", "address", "." ]

[ "AMDGPU", "SI", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_ordered_add", "Intrinsic::amdgcn_ds_ordered_swap", "Intrinsic::amdgcn_ds_append", "Intrinsic::amdgcn_ds_consume", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "Intrinsic::amdgcn_global_atomic_fadd", "Intrinsic::amdgcn_flat_atomic_fadd", "Intrinsic::amdgcn_flat_atomic_fmin", "Intrinsic::amdgcn_flat_atomic_fmax", "Intrinsic::amdgcn_global_atomic_csub", "0" ]

[]

[ "<s>", "void", "BTFTypeArray", "::", "completeType", "(", "BTFDebug", "&", "BDebug", ")", "{", "ArrayInfo", ".", "IndexType", "=", "BDebug", ".", "getArrayIndexTypeId", "(", ")", ";", "}", "</s>" ]

[ "Complete", "BTF", "type", "generation", "after", "all", "related", "DebugInfo", "types", "have", "been", "visited", "so", "their", "BTF", "type", "id", "'s", "are", "available", "for", "cross", "referece", "." ]

[ "BPF" ]

[]

[ "<s>", "bool", "P2InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Analyze Branch MBB: \"", ")", ";", "LLVM_DEBUG", "(", "MBB", ".", "dump", "(", ")", ")", ";", "int", "old_br_code", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "P2", "::", "JMPr", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "P2", "::", "JMP", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "assert", "(", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "\"Invalid conditional branch\"", ")", ";", "int", "BranchCode", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "1", ")", ")", ";", "old_br_code", "=", "BranchCode", ";", "continue", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", ")", ";", "assert", "(", "TBB", ")", ";", "if", "(", "TBB", "!=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", "return", "true", ";", "if", "(", "old_br_code", "==", "BranchCode", ")", "continue", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "P2", "P2", "\"Analyze Branch MBB: \"", "P2::JMPr", "P2::JMP", "0", "0", "0", "\"Invalid conditional branch\"", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createX86RetpolineThunksPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

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

[]

[ "<s>", "void", "UAS", "::", "Schedule", "(", ")", "{", "BuildSchedGraph", "(", "AA", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** UAS Scheduling **********\\n\"", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "AvailableQueue", ".", "initNodes", "(", "SUnits", ")", ";", "ScheduleTopDown", "(", ")", ";", "AvailableQueue", ".", "releaseState", "(", ")", ";", "EmitSchedule", "(", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "Order", "nodes", "according", "to", "selected", "style", ",", "filling", "in", "the", "Sequence", "member", "." ]

[ "TMS320C64X", "\"********** UAS Scheduling **********\\n\"", "0" ]

[]

[ "<s>", "static", "tree", "handle_int_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "x", "=", "*", "node", ";", "if", "(", "TREE_CODE", "(", "x", ")", "==", "FUNCTION_DECL", ")", "x", "=", "TREE_TYPE", "(", "x", ")", ";", "if", "(", "TREE_CODE", "(", "x", ")", "!=", "FUNCTION_TYPE", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "funkind", "(", "x", ")", "!=", "SUBROUTINE", ")", "error", "(", "\"multiple function type attributes specified\"", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "interrupt_handler", ",", "exception_handler", "and", "nmi_handler", "function", "attributes", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "bfin", "\"%qE attribute only applies to functions\"", "\"multiple function type attributes specified\"" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_uzp", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "odd", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out", ",", "in0", ",", "in1", ",", "x", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "vmode", ")", ">", "8", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "0", ")", "odd", "=", "0", ";", "else", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "1", ")", "odd", "=", "1", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "(", "i", "*", "2", "+", "odd", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "elt", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "odd", "=", "!", "odd", ";", "}", "out", "=", "d", "->", "target", ";", "if", "(", "odd", ")", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_uzp2v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_uzp2v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_uzp2v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_uzp2v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_uzp2v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_uzp2v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_uzp2v2di", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_uzp2v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_uzp2v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_uzp2v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "else", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_uzp1v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_uzp1v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_uzp1v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_uzp1v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_uzp1v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_uzp1v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_uzp1v2di", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_uzp1v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_uzp1v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_uzp1v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "emit_insn", "(", "gen", "(", "out", ",", "in0", ",", "in1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "suitable", "for", "the", "UZP", "instructions", "." ]

[ "aarch64", "8", "0", "0", "0", "0", "1", "1", "1", "2", "1", "0", "2" ]

[]

[ "<s>", "SDValue", "LC3bTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "return", "Chain", ";", "}", "</s>" ]

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

[ "LC3b", "LC3b", "ISD::InputArg" ]

[]

[ "<s>", "static", "void", "ia64_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "words", "=", "ia64_function_arg_words", "(", "type", ",", "mode", ")", ";", "int", "offset", "=", "ia64_function_arg_offset", "(", "cum", ",", "type", ",", "words", ")", ";", "machine_mode", "hfa_mode", "=", "VOIDmode", ";", "if", "(", "cum", "->", "words", ">=", "MAX_ARGUMENT_SLOTS", ")", "{", "cum", "->", "words", "+=", "words", "+", "offset", ";", "return", ";", "}", "cum", "->", "atypes", "[", "cum", "->", "words", "]", "=", "ia64_arg_type", "(", "mode", ")", ";", "cum", "->", "words", "+=", "words", "+", "offset", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "{", "cum", "->", "int_regs", "=", "cum", "->", "words", ";", "cum", "->", "fp_regs", "=", "cum", "->", "words", ";", "return", ";", "}", "if", "(", "type", ")", "hfa_mode", "=", "hfa_element_mode", "(", "type", ",", "0", ")", ";", "if", "(", "hfa_mode", "!=", "VOIDmode", "&&", "(", "!", "cum", "->", "prototype", "||", "named", ")", ")", "{", "int", "fp_regs", "=", "cum", "->", "fp_regs", ";", "int", "int_regs", "=", "cum", "->", "words", "-", "words", ";", "int", "hfa_size", "=", "GET_MODE_SIZE", "(", "hfa_mode", ")", ";", "int", "byte_size", ";", "int", "args_byte_size", ";", "byte_size", "=", "(", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "args_byte_size", "=", "int_regs", "*", "UNITS_PER_WORD", ";", "offset", "=", "0", ";", "for", "(", ";", "(", "offset", "<", "byte_size", "&&", "fp_regs", "<", "MAX_ARGUMENT_SLOTS", "&&", "args_byte_size", "<", "(", "MAX_ARGUMENT_SLOTS", "*", "UNITS_PER_WORD", ")", ")", ";", ")", "{", "offset", "+=", "hfa_size", ";", "args_byte_size", "+=", "hfa_size", ";", "fp_regs", "++", ";", "}", "cum", "->", "fp_regs", "=", "fp_regs", ";", "}", "else", "if", "(", "mode", "==", "TFmode", "||", "mode", "==", "TCmode", "||", "(", "!", "FLOAT_MODE_P", "(", "mode", ")", "||", "cum", "->", "fp_regs", "==", "MAX_ARGUMENT_SLOTS", ")", ")", "cum", "->", "int_regs", "=", "cum", "->", "words", ";", "else", "if", "(", "cum", "->", "prototype", ")", "{", "if", "(", "!", "named", ")", "cum", "->", "int_regs", "=", "cum", "->", "words", ";", "else", "cum", "->", "fp_regs", "+=", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "?", "2", ":", "1", ")", ";", "}", "else", "{", "cum", "->", "fp_regs", "+=", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "?", "2", ":", "1", ")", ";", "cum", "->", "int_regs", "=", "cum", "->", "words", ";", "}", "}", "</s>" ]

[ "Update", "CUM", "to", "point", "after", "this", "argument", ".", "This", "is", "patterned", "after", "ia64_function_arg", "." ]

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

[]

[ "<s>", "void", "NyuziInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "getMemOperand", "(", "MBB", ",", "FrameIndex", ",", "MachineMemOperand", "::", "MOStore", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "Nyuzi", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Nyuzi", "::", "SW", ";", "else", "if", "(", "Nyuzi", "::", "VR512RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Nyuzi", "::", "BLOCK_STOREI", ";", "else", "llvm_unreachable", "(", "\"unknown register class in storeRegToStack\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "0", "Nyuzi::GPR32RegClass", "Nyuzi::SW", "Nyuzi::VR512RegClass", "Nyuzi::BLOCK_STOREI", "\"unknown register class in storeRegToStack\"", "0" ]

[]

[ "<s>", "static", "section", "*", "iq2000_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "return", "mergeable_constant_section", "(", "mode", ",", "align", ",", "0", ")", ";", "}", "</s>" ]

[ "Choose", "the", "section", "to", "use", "for", "the", "constant", "rtx", "expression", "X", "that", "has", "mode", "MODE", "." ]

[ "iq2000", "0" ]

[]

[ "<s>", "const", "ARMBaseRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "dump", "(", ")", "const", "{", "if", "(", "Start", ")", "dbgs", "(", ")", "<<", "\"ARM Loops: Found Loop Start: \"", "<<", "*", "Start", ";", "if", "(", "Dec", ")", "dbgs", "(", ")", "<<", "\"ARM Loops: Found Loop Dec: \"", "<<", "*", "Dec", ";", "if", "(", "End", ")", "dbgs", "(", ")", "<<", "\"ARM Loops: Found Loop End: \"", "<<", "*", "End", ";", "if", "(", "VCTP", ")", "dbgs", "(", ")", "<<", "\"ARM Loops: Found VCTP: \"", "<<", "*", "VCTP", ";", "if", "(", "!", "FoundAllComponents", "(", ")", ")", "dbgs", "(", ")", "<<", "\"ARM Loops: Not a low-overhead loop.\\n\"", ";", "else", "if", "(", "!", "(", "Start", "&&", "Dec", "&&", "End", ")", ")", "dbgs", "(", ")", "<<", "\"ARM Loops: Failed to find all loop components.\\n\"", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "ARM", "\"ARM Loops: Found Loop Start: \"", "\"ARM Loops: Found Loop Dec: \"", "\"ARM Loops: Found Loop End: \"", "\"ARM Loops: Found VCTP: \"", "\"ARM Loops: Not a low-overhead loop.\\n\"", "\"ARM Loops: Failed to find all loop components.\\n\"" ]

[]

[ "<s>", "int", "SparcSubtarget", "::", "getAdjustedFrameSize", "(", "int", "frameSize", ")", "const", "{", "if", "(", "is64Bit", "(", ")", ")", "{", "frameSize", "+=", "128", ";", "assert", "(", "frameSize", "%", "16", "==", "0", "&&", "\"Stack size not 16-byte aligned\"", ")", ";", "}", "else", "{", "frameSize", "+=", "92", ";", "frameSize", "=", "RoundUpToAlignment", "(", "frameSize", ",", "8", ")", ";", "}", "return", "frameSize", ";", "}", "</s>" ]

[ "Given", "a", "actual", "stack", "size", "as", "determined", "by", "FrameInfo", ",", "this", "function", "returns", "adjusted", "framesize", "which", "includes", "space", "for", "RSA", ",", "return", "address", ",", "and", "frame", "poitner", "." ]

[ "Sparc", "Sparc", "128", "16", "0", "\"Stack size not 16-byte aligned\"", "92", "8" ]

[]

[ "<s>", "void", "aarch64_sls_emit_shared_blr_thunks", "(", "FILE", "*", "out_file", ")", "{", "if", "(", "!", "aarch64_sls_shared_thunks_needed", ")", "return", ";", "for", "(", "int", "regnum", "=", "0", ";", "regnum", "<", "30", ";", "++", "regnum", ")", "{", "tree", "decl", "=", "aarch64_sls_shared_thunks", "[", "regnum", "]", ";", "if", "(", "!", "decl", ")", "continue", ";", "const", "char", "*", "name", "=", "indirect_symbol_names", "[", "regnum", "]", ";", "switch_to_section", "(", "get_named_section", "(", "decl", ",", "NULL", ",", "0", ")", ")", ";", "ASM_OUTPUT_ALIGN", "(", "out_file", ",", "2", ")", ";", "targetm", ".", "asm_out", ".", "globalize_label", "(", "out_file", ",", "name", ")", ";", "targetm", ".", "asm_out", ".", "assemble_visibility", "(", "decl", ",", "VISIBILITY_HIDDEN", ")", ";", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "out_file", ",", "name", ",", "\"function\"", ")", ";", "ASM_OUTPUT_LABEL", "(", "out_file", ",", "name", ")", ";", "aarch64_sls_emit_function_stub", "(", "out_file", ",", "regnum", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\tdsb\\tsy\\n\\tisb\\n\"", ")", ";", "ASM_DECLARE_FUNCTION_SIZE", "(", "out_file", ",", "name", ",", "decl", ")", ";", "}", "}", "</s>" ]

[ "Emit", "shared", "BLR", "stubs", "for", "the", "current", "compilation", "unit", ".", "Over", "the", "course", "of", "compiling", "this", "unit", "we", "may", "have", "converted", "some", "BLR", "instructions", "to", "a", "BL", "to", "a", "shared", "stub", "function", ".", "This", "is", "where", "we", "emit", "those", "stub", "functions", ".", "This", "function", "is", "for", "the", "stubs", "shared", "between", "different", "functions", "in", "this", "compilation", "unit", ".", "We", "share", "when", "optimizing", "for", "size", "instead", "of", "speed", ".", "This", "function", "is", "called", "through", "the", "TARGET_ASM_FILE_END", "hook", "." ]

[ "aarch64", "0", "30", "0", "2", "\"function\"", "\"\\tdsb\\tsy\\n\\tisb\\n\"" ]

[]

[ "<s>", "static", "sbitmap", "aarch64_get_separate_components", "(", "void", ")", "{", "aarch64_layout_frame", "(", ")", ";", "sbitmap", "components", "=", "sbitmap_alloc", "(", "LAST_SAVED_REGNUM", "+", "1", ")", ";", "bitmap_clear", "(", "components", ")", ";", "for", "(", "unsigned", "regno", "=", "0", ";", "regno", "<=", "LAST_SAVED_REGNUM", ";", "regno", "++", ")", "if", "(", "aarch64_register_saved_on_entry", "(", "regno", ")", ")", "{", "HOST_WIDE_INT", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "if", "(", "!", "frame_pointer_needed", ")", "offset", "+=", "cfun", "->", "machine", "->", "frame", ".", "frame_size", "-", "cfun", "->", "machine", "->", "frame", ".", "hard_fp_offset", ";", "if", "(", "offset_12bit_unsigned_scaled_p", "(", "DImode", ",", "offset", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "bitmap_clear_bit", "(", "components", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "unsigned", "reg1", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", ";", "unsigned", "reg2", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ";", "if", "(", "reg2", "!=", "INVALID_REGNUM", ")", "bitmap_clear_bit", "(", "components", ",", "reg2", ")", ";", "if", "(", "reg1", "!=", "INVALID_REGNUM", ")", "bitmap_clear_bit", "(", "components", ",", "reg1", ")", ";", "bitmap_clear_bit", "(", "components", ",", "LR_REGNUM", ")", ";", "bitmap_clear_bit", "(", "components", ",", "SP_REGNUM", ")", ";", "return", "components", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS", "." ]

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

[]

[ "<s>", "void", "MipsAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "FK_Data_2", ":", "case", "Mips", "::", "fixup_Mips_16", ":", "case", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ":", "FullSize", "=", "2", ";", "break", ";", "case", "FK_Data_8", ":", "case", "Mips", "::", "fixup_Mips_64", ":", "FullSize", "=", "8", ";", "break", ";", "case", "FK_Data_4", ":", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "bool", "microMipsLEByteOrder", "=", "needsMMLEByteOrder", "(", "(", "unsigned", ")", "Kind", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "7", "8", "Mips::fixup_Mips_16", "Mips::fixup_MICROMIPS_PC10_S1", "2", "Mips::fixup_Mips_64", "8", "4", "0", "Mips", "0", "Mips", "1", "8", "1", "64", "0", "Mips", "1", "8", "0xff" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Don't know how to custom expand this!\"", ")", ";", "return", ";", "case", "ISD", "::", "BIT_CONVERT", ":", "Results", ".", "push_back", "(", "ExpandBIT_CONVERT", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "{", "SDValue", "Res", "=", "ExpandSRx", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"Don't know how to custom expand this!\"", "ISD::BIT_CONVERT", "ISD::SRL", "ISD::SRA" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_cmp", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "op_true", ",", "rtx", "op_false", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "cmp_ops_mode", "=", "GET_MODE", "(", "cmp_op0", ")", ";", "machine_mode", "cmp_mode", ";", "bool", "maskcmp", "=", "false", ";", "rtx", "x", ";", "if", "(", "ix86_use_mask_cmp_p", "(", "mode", ",", "cmp_ops_mode", ",", "op_true", ",", "op_false", ")", ")", "{", "unsigned", "int", "nbits", "=", "GET_MODE_NUNITS", "(", "cmp_ops_mode", ")", ";", "maskcmp", "=", "true", ";", "cmp_mode", "=", "nbits", ">", "8", "?", "int_mode_for_size", "(", "nbits", ",", "0", ")", ".", "require", "(", ")", ":", "E_QImode", ";", "}", "else", "cmp_mode", "=", "cmp_ops_mode", ";", "cmp_op0", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op0", ")", ";", "bool", "(", "*", "op1_predicate", ")", "(", "rtx", ",", "machine_mode", ")", "=", "VECTOR_MODE_P", "(", "cmp_ops_mode", ")", "?", "vector_operand", ":", "nonimmediate_operand", ";", "if", "(", "!", "op1_predicate", "(", "cmp_op1", ",", "cmp_ops_mode", ")", ")", "cmp_op1", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op1", ")", ";", "if", "(", "optimize", "||", "(", "maskcmp", "&&", "cmp_mode", "!=", "mode", ")", "||", "(", "op_true", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_true", ")", ")", "||", "(", "op_false", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_false", ")", ")", ")", "dest", "=", "gen_reg_rtx", "(", "maskcmp", "?", "cmp_mode", ":", "mode", ")", ";", "if", "(", "maskcmp", ")", "{", "bool", "ok", "=", "ix86_expand_mask_vec_cmp", "(", "dest", ",", "code", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "gcc_assert", "(", "ok", ")", ";", "return", "dest", ";", "}", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "cmp_mode", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "if", "(", "cmp_mode", "!=", "mode", ")", "{", "x", "=", "force_reg", "(", "cmp_ops_mode", ",", "x", ")", ";", "convert_move", "(", "dest", ",", "x", ",", "false", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "return", "dest", ";", "}", "</s>" ]

[ "Expand", "an", "sse", "vector", "comparison", ".", "Return", "the", "register", "with", "the", "result", "." ]

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

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "{", "auto", "Op", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Op", "==", "AArch64", "::", "INLINEASM", "||", "Op", "==", "AArch64", "::", "INLINEASM_BR", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "}", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "0", ";", "unsigned", "NumBytes", "=", "0", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "Desc", ".", "getSize", "(", ")", ")", "return", "Desc", ".", "getSize", "(", ")", ";", "NumBytes", "=", "4", ";", "break", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "NumBytes", "=", "StackMapOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "NumBytes", "=", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "STATEPOINT", ":", "NumBytes", "=", "StatepointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "if", "(", "NumBytes", "==", "0", ")", "NumBytes", "=", "4", ";", "break", ";", "case", "AArch64", "::", "SPACE", ":", "NumBytes", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "break", ";", "case", "TargetOpcode", "::", "BUNDLE", ":", "NumBytes", "=", "getInstBundleLength", "(", "MI", ")", ";", "break", ";", "}", "return", "NumBytes", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AArch64", "AArch64", "AArch64::INLINEASM", "AArch64::INLINEASM_BR", "0", "0", "0", "4", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "0", "4", "AArch64::SPACE", "1" ]

[]

[ "<s>", "static", "rtx", "gen_inlined_tls_plt", "(", "rtx", "addr", ")", "{", "rtx", "retval", ",", "dest", ";", "rtx", "picreg", "=", "get_hard_reg_initial_val", "(", "Pmode", ",", "FDPIC_REG", ")", ";", "dest", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "flag_pic", "==", "1", ")", "{", "emit_insn", "(", "gen_tls_lddi", "(", "dest", ",", "addr", ",", "picreg", ")", ")", ";", "}", "else", "{", "rtx", "reguse", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_tlsoff_hilo", "(", "reguse", ",", "addr", ",", "GEN_INT", "(", "R_FRV_GOTTLSDESCHI", ")", ")", ")", ";", "emit_insn", "(", "gen_tls_tlsdesc_ldd", "(", "dest", ",", "picreg", ",", "reguse", ",", "addr", ")", ")", ";", "}", "retval", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_tls_indirect_call", "(", "retval", ",", "addr", ",", "dest", ",", "picreg", ")", ")", ";", "return", "retval", ";", "}", "</s>" ]

[ "Given", "an", "ADDR", ",", "generate", "code", "to", "inline", "the", "PLT", "." ]

[ "frv", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "MSP430RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsIntr", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430", "MSP430" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "X86_MACHINEINSTR_PRINTER_PASS_NAME", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STM", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "STM", ".", "getRegisterInfo", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "STM", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SILoadStoreOptimizer\\n\"", ")", ";", "assert", "(", "!", "MRI", "->", "isSSA", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "\"Running SILoadStoreOptimizer\\n\"" ]

[]

[ "<s>", "void", "function_expander", "::", "add_ptrue_hint", "(", "unsigned", "int", "argno", ",", "machine_mode", "pred_mode", ")", "{", "rtx", "pred", "=", "gen_lowpart", "(", "pred_mode", ",", "args", "[", "argno", "]", ")", ";", "int", "hint", "=", "(", "pred", "==", "CONSTM1_RTX", "(", "pred_mode", ")", "?", "SVE_KNOWN_PTRUE", ":", "SVE_MAYBE_NOT_PTRUE", ")", ";", "args", ".", "quick_insert", "(", "argno", "+", "1", ",", "gen_int_mode", "(", "hint", ",", "SImode", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "dummy", "argument", "to", "indicate", "whether", "predicate", "argument", "ARGNO", "is", "all-true", "when", "interpreted", "in", "mode", "PRED_MODE", ".", "The", "hint", "goes", "immediately", "after", "ARGNO", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "unsigned", "NyuziInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "FBB", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Nyuzi", "::", "B", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Nyuzi", "::", "B", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "Nyuzi", "Nyuzi", "\"code size not handled\"", "0", "1", "Nyuzi::B", "2", "Nyuzi::B", "1", "0", "1", "1" ]

[]

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

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

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

[]

[ "<s>", "void", "MipsRegisterBankInfo", "::", "applyMappingImpl", "(", "const", "OperandsMapper", "&", "OpdMapper", ")", "const", "{", "MachineInstr", "&", "MI", "=", "OpdMapper", ".", "getMI", "(", ")", ";", "InstListTy", "NewInstrs", ";", "MachineIRBuilder", "B", "(", "MI", ")", ";", "MachineFunction", "*", "MF", "=", "MI", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "OpdMapper", ".", "getMRI", "(", ")", ";", "const", "LegalizerInfo", "&", "LegInfo", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getLegalizerInfo", "(", ")", ";", "InstManager", "NewInstrObserver", "(", "NewInstrs", ")", ";", "GISelObserverWrapper", "WrapperObserver", "(", "&", "NewInstrObserver", ")", ";", "LegalizerHelper", "Helper", "(", "*", "MF", ",", "WrapperObserver", ",", "B", ")", ";", "LegalizationArtifactCombiner", "ArtCombiner", "(", "B", ",", "MF", "->", "getRegInfo", "(", ")", ",", "LegInfo", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "case", "TargetOpcode", "::", "G_PHI", ":", "case", "TargetOpcode", "::", "G_SELECT", ":", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "{", "Helper", ".", "narrowScalar", "(", "MI", ",", "0", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "while", "(", "!", "NewInstrs", ".", "empty", "(", ")", ")", "{", "MachineInstr", "*", "NewMI", "=", "NewInstrs", ".", "pop_back_val", "(", ")", ";", "if", "(", "NewMI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_UNMERGE_VALUES", ")", "combineAwayG_UNMERGE_VALUES", "(", "ArtCombiner", ",", "*", "NewMI", ")", ";", "else", "if", "(", "NewMI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_MERGE_VALUES", ")", "continue", ";", "else", "setRegBank", "(", "*", "NewMI", ",", "MRI", ")", ";", "}", "return", ";", "}", "case", "TargetOpcode", "::", "G_UNMERGE_VALUES", ":", "combineAwayG_UNMERGE_VALUES", "(", "ArtCombiner", ",", "MI", ")", ";", "return", ";", "default", ":", "break", ";", "}", "return", "applyDefaultMapping", "(", "OpdMapper", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "32" ]

[]

[ "<s>", "SDValue", "HexagonSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "AlwaysInline", "||", "Alignment", "<", "Align", "(", "4", ")", "||", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "uint64_t", "SizeVal", "=", "ConstantSize", "->", "getZExtValue", "(", ")", ";", "if", "(", "SizeVal", "<", "32", "||", "(", "SizeVal", "%", "8", ")", "!=", "0", ")", "return", "SDValue", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "const", "char", "*", "SpecialMemcpyName", "=", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", ";", "const", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "bool", "LongCalls", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "useLongCalls", "(", ")", ";", "unsigned", "Flags", "=", "LongCalls", "?", "HexagonII", "::", "HMOTF_ConstExtended", ":", "0", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setLibCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getTargetExternalSymbol", "(", "SpecialMemcpyName", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ",", "Flags", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "Hexagon", "Hexagon", "4", "32", "8", "0", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", "Hexagon", "HexagonII::HMOTF_ConstExtended", "0" ]

[]

[ "<s>", "SchedBoundary", "(", "unsigned", "ID", ",", "const", "Twine", "&", "Name", ")", ":", "DAG", "(", "0", ")", ",", "SchedModel", "(", "0", ")", ",", "Available", "(", "ID", ",", "Name", "+", "\".A\"", ")", ",", "Pending", "(", "ID", "<<", "ConvergingVLIWScheduler", "::", "LogMaxQID", ",", "Name", "+", "\".P\"", ")", ",", "CheckPending", "(", "false", ")", ",", "HazardRec", "(", "0", ")", ",", "ResourceModel", "(", "0", ")", ",", "CurrCycle", "(", "0", ")", ",", "IssueCount", "(", "0", ")", ",", "MinReadyCycle", "(", "UINT_MAX", ")", ",", "MaxMinLatency", "(", "0", ")", "{", "}", "</s>" ]

[ "Pending", "queues", "extend", "the", "ready", "queues", "with", "the", "same", "ID", "and", "the", "PendingFlag", "set", "." ]

[ "Hexagon", "0", "0", "\".A\"", "\".P\"", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "StackAlign", "=", "RI", "->", "needsStackRealignment", "(", "MF", ")", "?", "MFI", ".", "getMaxAlignment", "(", ")", ":", "getStackAlignment", "(", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

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

[]

[ "<s>", "static", "void", "ix86_set_current_function", "(", "tree", "fndecl", ")", "{", "if", "(", "fndecl", "==", "ix86_previous_fndecl", ")", "{", "if", "(", "fndecl", "!=", "NULL_TREE", ")", "{", "ix86_set_func_type", "(", "fndecl", ")", ";", "ix86_set_indirect_branch_type", "(", "fndecl", ")", ";", "}", "return", ";", "}", "tree", "old_tree", ";", "if", "(", "ix86_previous_fndecl", "==", "NULL_TREE", ")", "old_tree", "=", "target_option_current_node", ";", "else", "if", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "ix86_previous_fndecl", ")", ")", "old_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "ix86_previous_fndecl", ")", ";", "else", "old_tree", "=", "target_option_default_node", ";", "if", "(", "fndecl", "==", "NULL_TREE", ")", "{", "if", "(", "old_tree", "!=", "target_option_current_node", ")", "ix86_reset_previous_fndecl", "(", ")", ";", "return", ";", "}", "ix86_set_func_type", "(", "fndecl", ")", ";", "ix86_set_indirect_branch_type", "(", "fndecl", ")", ";", "tree", "new_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "new_tree", "==", "NULL_TREE", ")", "new_tree", "=", "target_option_default_node", ";", "if", "(", "old_tree", "!=", "new_tree", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "ix86_previous_fndecl", "=", "fndecl", ";", "static", "bool", "prev_no_caller_saved_registers", ";", "if", "(", "TARGET_64BIT", "&&", "(", "call_used_regs", "[", "SI_REG", "]", "==", "(", "cfun", "->", "machine", "->", "call_abi", "==", "MS_ABI", ")", ")", ")", "reinit_regs", "(", ")", ";", "else", "if", "(", "prev_no_caller_saved_registers", "!=", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "reinit_regs", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", "||", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "{", "const", "char", "*", "isa", ";", "if", "(", "TARGET_MPX", ")", "isa", "=", "\"MPX\"", ";", "else", "if", "(", "TARGET_SSE", ")", "isa", "=", "\"SSE\"", ";", "else", "if", "(", "TARGET_MMX", ")", "isa", "=", "\"MMX/3Dnow\"", ";", "else", "if", "(", "TARGET_80387", ")", "isa", "=", "\"80387\"", ";", "else", "isa", "=", "NULL", ";", "if", "(", "isa", "!=", "NULL", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "sorry", "(", "\"%s instructions aren't allowed in %s service routine\"", ",", "isa", ",", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_EXCEPTION", "?", "\"exception\"", ":", "\"interrupt\"", ")", ")", ";", "else", "sorry", "(", "\"%s instructions aren't allowed in function with \"", "\"no_caller_saved_registers attribute\"", ",", "isa", ")", ";", "cfun", "->", "machine", "->", "func_type", "=", "TYPE_NORMAL", ";", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "false", ";", "}", "}", "prev_no_caller_saved_registers", "=", "cfun", "->", "machine", "->", "no_caller_saved_registers", ";", "}", "</s>" ]

[ "Establish", "appropriate", "back-end", "context", "for", "processing", "the", "function", "FNDECL", ".", "The", "argument", "might", "be", "NULL", "to", "indicate", "processing", "at", "top", "level", ",", "outside", "of", "any", "function", "scope", "." ]

[ "i386", "\"MPX\"", "\"SSE\"", "\"MMX/3Dnow\"", "\"80387\"", "\"%s instructions aren't allowed in %s service routine\"", "\"exception\"", "\"interrupt\"", "\"%s instructions aren't allowed in function with \"", "\"no_caller_saved_registers attribute\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "override", "{", "if", "(", "RC", "==", "&", "AArch64", "::", "tcGPR64RegClass", ")", "return", "&", "AArch64", "::", "GPR64RegClass", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "AArch64", "AArch64::tcGPR64RegClass", "AArch64::GPR64RegClass" ]

[]

[ "<s>", "int", "MipsRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "llvm_unreachable", "(", "\"What is the dwarf register number\"", ")", ";", "return", "-", "1", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"What is the dwarf register number\"", "1" ]

[]

[ "<s>", "static", "int", "ix86_fp_comparison_sahf_cost", "(", "enum", "rtx_code", "code", ")", "{", "enum", "rtx_code", "bypass_code", ",", "first_code", ",", "second_code", ";", "if", "(", "!", "TARGET_USE_SAHF", "&&", "!", "optimize_size", ")", "return", "1024", ";", "ix86_fp_comparison_codes", "(", "code", ",", "&", "bypass_code", ",", "&", "first_code", ",", "&", "second_code", ")", ";", "return", "(", "bypass_code", "!=", "UNKNOWN", "||", "second_code", "!=", "UNKNOWN", ")", "+", "3", ";", "}", "</s>" ]

[ "Return", "cost", "of", "comparison", "done", "using", "sahf", "operation", ".", "See", "ix86_fp_comparison_arithmetics_cost", "for", "the", "metrics", "." ]

[ "i386", "1024", "3" ]

[]

[ "<s>", "const", "RISCVSubtarget", "*", "RISCVTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "std", "::", "string", "Key", "=", "CPU", "+", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "auto", "ABIName", "=", "Options", ".", "MCOptions", ".", "getABIName", "(", ")", ";", "if", "(", "const", "MDString", "*", "ModuleTargetABI", "=", "dyn_cast_or_null", "<", "MDString", ">", "(", "F", ".", "getParent", "(", ")", "->", "getModuleFlag", "(", "\"target-abi\"", ")", ")", ")", "{", "auto", "TargetABI", "=", "RISCVABI", "::", "getTargetABI", "(", "ABIName", ")", ";", "if", "(", "TargetABI", "!=", "RISCVABI", "::", "ABI_Unknown", "&&", "ModuleTargetABI", "->", "getString", "(", ")", "!=", "ABIName", ")", "{", "report_fatal_error", "(", "\"-target-abi option != target-abi module flag\"", ")", ";", "}", "ABIName", "=", "ModuleTargetABI", "->", "getString", "(", ")", ";", "}", "I", "=", "std", "::", "make_unique", "<", "RISCVSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "ABIName", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "\"target-cpu\"", "\"target-features\"", "\"target-abi\"", "RISCVABI::getTargetABI", "RISCVABI::ABI_Unknown", "\"-target-abi option != target-abi module flag\"", "RISCV" ]

[]

[ "<s>", "bool", "hasFPU", "(", ")", "const", "{", "return", "HasFPU", ";", "}", "</s>" ]

[ "Floating", "point", "support", "." ]

[ "PowerPC" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "std", "::", "max", "(", "(", "VT", ".", "getSizeInBits", "(", ")", "/", "(", "Subtarget", ".", "isABI_O32", "(", ")", "?", "32", ":", "64", ")", ")", ",", "1U", ")", ";", "return", "MipsTargetLowering", "::", "getNumRegisters", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "Mips", "Mips", "32", "64", "1U", "Mips" ]

[]

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

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

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

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "EXT", ":", "case", "Mips", "::", "EXT_MM", ":", "case", "Mips", "::", "INS", ":", "case", "Mips", "::", "INS_MM", ":", "case", "Mips", "::", "DINS", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "0", ",", "32", ",", "0", ",", "32", ",", "0", ",", "32", ")", ";", "case", "Mips", "::", "DINSM", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "0", ",", "32", ",", "1", ",", "64", ",", "32", ",", "64", ")", ";", "case", "Mips", "::", "DINSU", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "32", ",", "64", ",", "0", ",", "32", ",", "32", ",", "64", ")", ";", "case", "Mips", "::", "DEXT", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "0", ",", "32", ",", "0", ",", "32", ",", "0", ",", "63", ")", ";", "case", "Mips", "::", "DEXTM", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "0", ",", "32", ",", "32", ",", "64", ",", "32", ",", "64", ")", ";", "case", "Mips", "::", "DEXTU", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "32", ",", "64", ",", "0", ",", "32", ",", "32", ",", "64", ")", ";", "case", "Mips", "::", "TAILCALLREG", ":", "case", "Mips", "::", "PseudoIndirectBranch", ":", "case", "Mips", "::", "JR", ":", "case", "Mips", "::", "JR64", ":", "case", "Mips", "::", "JALR", ":", "case", "Mips", "::", "JALR64", ":", "case", "Mips", "::", "JALRPseudo", ":", "if", "(", "!", "Subtarget", ".", "useIndirectJumpsHazard", "(", ")", ")", "return", "true", ";", "ErrInfo", "=", "\"invalid instruction when using jump guards!\"", ";", "return", "false", ";", "default", ":", "return", "true", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::EXT", "Mips::EXT_MM", "Mips::INS", "Mips::INS_MM", "Mips::DINS", "0", "32", "0", "32", "0", "32", "Mips::DINSM", "0", "32", "1", "64", "32", "64", "Mips::DINSU", "32", "64", "0", "32", "32", "64", "Mips::DEXT", "0", "32", "0", "32", "0", "63", "Mips::DEXTM", "0", "32", "32", "64", "32", "64", "Mips::DEXTU", "32", "64", "0", "32", "32", "64", "Mips::TAILCALLREG", "Mips::PseudoIndirectBranch", "Mips::JR", "Mips::JR64", "Mips::JALR", "Mips::JALR64", "Mips::JALRPseudo", "\"invalid instruction when using jump guards!\"" ]

[]

[ "<s>", "static", "insn_code", "elemrev_icode", "(", "rs6000_gen_builtins", "fcode", ")", "{", "switch", "(", "fcode", ")", "{", "case", "RS6000_BIF_ST_ELEMREV_V1TI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_store_v1ti", ":", "CODE_FOR_vsx_st_elemrev_v1ti", ";", "case", "RS6000_BIF_ST_ELEMREV_V2DF", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_store_v2df", ":", "CODE_FOR_vsx_st_elemrev_v2df", ";", "case", "RS6000_BIF_ST_ELEMREV_V2DI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_store_v2di", ":", "CODE_FOR_vsx_st_elemrev_v2di", ";", "case", "RS6000_BIF_ST_ELEMREV_V4SF", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_store_v4sf", ":", "CODE_FOR_vsx_st_elemrev_v4sf", ";", "case", "RS6000_BIF_ST_ELEMREV_V4SI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_store_v4si", ":", "CODE_FOR_vsx_st_elemrev_v4si", ";", "case", "RS6000_BIF_ST_ELEMREV_V8HI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_store_v8hi", ":", "CODE_FOR_vsx_st_elemrev_v8hi", ";", "case", "RS6000_BIF_ST_ELEMREV_V16QI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_store_v16qi", ":", "CODE_FOR_vsx_st_elemrev_v16qi", ";", "case", "RS6000_BIF_LD_ELEMREV_V2DF", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_load_v2df", ":", "CODE_FOR_vsx_ld_elemrev_v2df", ";", "case", "RS6000_BIF_LD_ELEMREV_V1TI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_load_v1ti", ":", "CODE_FOR_vsx_ld_elemrev_v1ti", ";", "case", "RS6000_BIF_LD_ELEMREV_V2DI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_load_v2di", ":", "CODE_FOR_vsx_ld_elemrev_v2di", ";", "case", "RS6000_BIF_LD_ELEMREV_V4SF", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_load_v4sf", ":", "CODE_FOR_vsx_ld_elemrev_v4sf", ";", "case", "RS6000_BIF_LD_ELEMREV_V4SI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_load_v4si", ":", "CODE_FOR_vsx_ld_elemrev_v4si", ";", "case", "RS6000_BIF_LD_ELEMREV_V8HI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_load_v8hi", ":", "CODE_FOR_vsx_ld_elemrev_v8hi", ";", "case", "RS6000_BIF_LD_ELEMREV_V16QI", ":", "return", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_vsx_load_v16qi", ":", "CODE_FOR_vsx_ld_elemrev_v16qi", ";", "default", ":", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "For", "the", "element-reversing", "load/store", "built-ins", ",", "produce", "the", "correct", "insn_code", "depending", "on", "the", "target", "endianness", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "functionArgumentNeedsConsecutiveRegisters", "(", "Type", "*", "Ty", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ")", "const", "{", "if", "(", "Ty", "->", "isArrayTy", "(", ")", ")", "return", "true", ";", "const", "TypeSize", "&", "TySize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "TySize", ".", "isScalable", "(", ")", "&&", "TySize", ".", "getKnownMinSize", "(", ")", ">", "128", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "an", "argument", "of", "type", "Ty", "needs", "to", "be", "passed", "in", "a", "contiguous", "block", "of", "registers", "in", "calling", "convention", "CallConv", "." ]

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

[]

[ "<s>", "static", "bool", "expand_vec_perm_1", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "nelt", "=", "d", "->", "nelt", ";", "unsigned", "char", "perm2", "[", "MAX_VECT_LEN", "]", ";", "if", "(", "d", "->", "one_operand_p", ")", "{", "if", "(", "expand_vec_perm_identity", "(", "d", ")", ")", "return", "true", ";", "if", "(", "expand_vselect", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "perm", ",", "nelt", ")", ")", "return", "true", ";", "}", "if", "(", "expand_vselect_vconcat", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "d", "->", "perm", ",", "nelt", ")", ")", "return", "true", ";", "if", "(", "!", "d", "->", "one_operand_p", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "e", "=", "d", "->", "perm", "[", "i", "]", ";", "if", "(", "e", ">=", "nelt", ")", "e", "-=", "nelt", ";", "else", "e", "+=", "nelt", ";", "perm2", "[", "i", "]", "=", "e", ";", "}", "if", "(", "expand_vselect_vconcat", "(", "d", "->", "target", ",", "d", "->", "op1", ",", "d", "->", "op0", ",", "perm2", ",", "nelt", ")", ")", "return", "true", ";", "}", "if", "(", "expand_vec_perm_shrp", "(", "d", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Try", "to", "instantiate", "D", "in", "a", "single", "instruction", "." ]

[ "ia64", "0" ]

[]

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

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

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

[]

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

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

[ "OR1K", "0", "0" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'y'", ":", "{", "const", "char", "*", "RegName", "=", "\"r0\"", ";", "if", "(", "!", "Subtarget", ".", "isDarwin", "(", ")", ")", "RegName", "=", "stripRegisterPrefix", "(", "RegName", ")", ";", "O", "<<", "RegName", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "}", "}", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "1", "0", "0", "\"r0\"", "\", \"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "static", "void", "ix86_output_indirect_branch_via_reg", "(", "rtx", "call_op", ",", "bool", "sibcall_p", ")", "{", "char", "thunk_name_buf", "[", "32", "]", ";", "char", "*", "thunk_name", ";", "enum", "indirect_thunk_prefix", "need_prefix", "=", "indirect_thunk_need_prefix", "(", "current_output_insn", ")", ";", "int", "regno", "=", "REGNO", "(", "call_op", ")", ";", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "!=", "indirect_branch_thunk_inline", ")", "{", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk", ")", "{", "int", "i", "=", "regno", ";", "if", "(", "i", ">=", "FIRST_REX_INT_REG", ")", "i", "-=", "(", "FIRST_REX_INT_REG", "-", "LAST_INT_REG", "-", "1", ")", ";", "indirect_thunks_used", "|=", "1", "<<", "i", ";", "}", "indirect_thunk_name", "(", "thunk_name_buf", ",", "regno", ",", "need_prefix", ",", "false", ")", ";", "thunk_name", "=", "thunk_name_buf", ";", "}", "else", "thunk_name", "=", "NULL", ";", "if", "(", "sibcall_p", ")", "{", "if", "(", "thunk_name", "!=", "NULL", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "else", "output_indirect_thunk", "(", "regno", ")", ";", "}", "else", "{", "if", "(", "thunk_name", "!=", "NULL", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\tcall\\t%s\\n\"", ",", "thunk_name", ")", ";", "return", ";", "}", "char", "indirectlabel1", "[", "32", "]", ";", "char", "indirectlabel2", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel1", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel2", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "fputs", "(", "\"\\tjmp\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "if", "(", "thunk_name", "!=", "NULL", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "else", "output_indirect_thunk", "(", "regno", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputs", "(", "\"\\tcall\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "}", "</s>" ]

[ "Output", "indirect", "branch", "via", "a", "call", "and", "return", "thunk", ".", "CALL_OP", "is", "a", "register", "which", "contains", "the", "branch", "target", ".", "XASM", "is", "the", "assembly", "template", "for", "CALL_OP", ".", "Branch", "is", "a", "tail", "call", "if", "SIBCALL_P", "is", "true", ".", "A", "normal", "call", "is", "converted", "to", ":", "call", "__x86_indirect_thunk_reg", "and", "a", "tail", "call", "is", "converted", "to", ":", "jmp", "__x86_indirect_thunk_reg" ]

[ "i386", "32", "1", "1", "\"\\tjmp\\t%s\\n\"", "\"\\tcall\\t%s\\n\"", "32", "32", "\"\\tjmp\\t\"", "\"\\tjmp\\t%s\\n\"", "\"\\tcall\\t\"" ]

[]

[ "<s>", "unsigned", "PPCTTI", "::", "getNumberOfRegisters", "(", "bool", "Vector", ")", "const", "{", "if", "(", "Vector", "&&", "!", "ST", "->", "hasAltivec", "(", ")", ")", "return", "0", ";", "return", "ST", "->", "hasVSX", "(", ")", "?", "64", ":", "32", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "64", "32" ]

[]

[ "<s>", "static", "bool", "mips_mode_ok_for_mov_fmt_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "CCFmode", ":", "case", "SFmode", ":", "return", "TARGET_HARD_FLOAT", ";", "case", "DFmode", ":", "return", "TARGET_HARD_FLOAT", "&&", "TARGET_DOUBLE_FLOAT", ";", "case", "V2SFmode", ":", "return", "TARGET_HARD_FLOAT", "&&", "TARGET_PAIRED_SINGLE_FLOAT", ";", "default", ":", "return", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "moves", "in", "mode", "MODE", "can", "use", "the", "FPU", "'s", "mov.fmt", "instruction", "." ]

[ "mips" ]

[]

[ "<s>", "static", "int", "rs6000_issue_rate", "(", "void", ")", "{", "if", "(", "!", "reload_completed", "&&", "!", "flag_sched_pressure", ")", "return", "1", ";", "switch", "(", "rs6000_cpu_attr", ")", "{", "case", "CPU_RS64A", ":", "case", "CPU_PPC601", ":", "case", "CPU_PPC7450", ":", "return", "3", ";", "case", "CPU_PPC440", ":", "case", "CPU_PPC603", ":", "case", "CPU_PPC750", ":", "case", "CPU_PPC7400", ":", "case", "CPU_PPC8540", ":", "case", "CPU_PPC8548", ":", "case", "CPU_CELL", ":", "case", "CPU_PPCE300C2", ":", "case", "CPU_PPCE300C3", ":", "case", "CPU_PPCE500MC", ":", "case", "CPU_PPCE500MC64", ":", "case", "CPU_PPCE5500", ":", "case", "CPU_PPCE6500", ":", "case", "CPU_TITAN", ":", "return", "2", ";", "case", "CPU_PPC476", ":", "case", "CPU_PPC604", ":", "case", "CPU_PPC604E", ":", "case", "CPU_PPC620", ":", "case", "CPU_PPC630", ":", "return", "4", ";", "case", "CPU_POWER4", ":", "case", "CPU_POWER5", ":", "case", "CPU_POWER6", ":", "case", "CPU_POWER7", ":", "return", "5", ";", "case", "CPU_POWER8", ":", "return", "7", ";", "case", "CPU_POWER9", ":", "return", "6", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "how", "many", "instructions", "the", "machine", "can", "issue", "per", "cycle", "." ]

[ "rs6000", "1", "3", "2", "4", "5", "7", "6", "1" ]

[]

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

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

[ "XCore", "XCore" ]

[]

[ "<s>", "void", "ix86_expand_convert_sign_didf_sse", "(", "rtx", "target", ",", "rtx", "input", ")", "{", "REAL_VALUE_TYPE", "TWO32r", ";", "rtx", "fp_lo", ",", "fp_hi", ",", "x", ";", "fp_lo", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "fp_hi", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "emit_insn", "(", "gen_floatsidf2", "(", "fp_hi", ",", "gen_highpart", "(", "SImode", ",", "input", ")", ")", ")", ";", "real_ldexp", "(", "&", "TWO32r", ",", "&", "dconst1", ",", "32", ")", ";", "x", "=", "const_double_from_real_value", "(", "TWO32r", ",", "DFmode", ")", ";", "fp_hi", "=", "expand_simple_binop", "(", "DFmode", ",", "MULT", ",", "fp_hi", ",", "x", ",", "fp_hi", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "ix86_expand_convert_uns_sidf_sse", "(", "fp_lo", ",", "gen_lowpart", "(", "SImode", ",", "input", ")", ")", ";", "x", "=", "expand_simple_binop", "(", "DFmode", ",", "PLUS", ",", "fp_hi", ",", "fp_lo", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "x", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "x", ")", ";", "}", "</s>" ]

[ "Convert", "a", "signed", "DImode", "value", "into", "a", "DFmode", ".", "Only", "used", "for", "SSE", "in", "32-bit", "mode", ";", "otherwise", "we", "have", "a", "direct", "convert", "instruction", "." ]

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

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "assert", "(", "!", "isTargetCOFF", "(", ")", ")", ";", "if", "(", "isTargetELF", "(", ")", ")", "return", "X86II", "::", "MO_PLT", ";", "if", "(", "is64Bit", "(", ")", ")", "{", "auto", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86II::MO_PLT", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isBinOp", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "X86ISD", "::", "PMULUDQ", ":", "case", "X86ISD", "::", "FMAX", ":", "case", "X86ISD", "::", "FMIN", ":", "case", "X86ISD", "::", "FMAXC", ":", "case", "X86ISD", "::", "FMINC", ":", "case", "X86ISD", "::", "FAND", ":", "case", "X86ISD", "::", "FANDN", ":", "case", "X86ISD", "::", "FOR", ":", "case", "X86ISD", "::", "FXOR", ":", "return", "true", ";", "}", "return", "TargetLoweringBase", "::", "isBinOp", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "Add", "x86-specific", "opcodes", "to", "the", "default", "list", "." ]

[ "X86", "X86", "X86ISD::PMULUDQ", "X86ISD::FMAX", "X86ISD::FMIN", "X86ISD::FMAXC", "X86ISD::FMINC", "X86ISD::FAND", "X86ISD::FANDN", "X86ISD::FOR", "X86ISD::FXOR" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "HII", "->", "isPredicated", "(", "MI", ")", "||", "!", "HII", "->", "isPredicable", "(", "MI", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MI", "->", "mayStore", "(", ")", ")", "return", "false", ";", "bool", "HasDef", "=", "false", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", ")", "continue", ";", "if", "(", "HasDef", ")", "return", "false", ";", "HasDef", "=", "true", ";", "}", "for", "(", "auto", "&", "Mo", ":", "MI", "->", "memoperands", "(", ")", ")", "if", "(", "Mo", "->", "isVolatile", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "bool", "hwloop_optimize", "(", "hwloop_info", "loop", ")", "{", "int", "i", ";", "edge", "entry_edge", ";", "basic_block", "entry_bb", ";", "rtx", "iter_reg", ";", "rtx_insn", "*", "insn", ",", "*", "seq", ",", "*", "entry_after", ";", "if", "(", "loop", "->", "depth", ">", "1", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d is not innermost\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "if", "(", "!", "loop", "->", "incoming_dest", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d has more than one entry\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "if", "(", "loop", "->", "incoming_dest", "!=", "loop", "->", "head", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d is not entered from head\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "if", "(", "loop", "->", "has_call", "||", "loop", "->", "has_asm", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d has invalid insn\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "if", "(", "loop", "->", "iter_reg_used", "||", "loop", "->", "iter_reg_used_outside", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d uses iterator\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "insn", "=", "loop", "->", "start_label", ";", "while", "(", "insn", "&&", "insn", "!=", "loop", "->", "loop_end", ")", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "!", "insn", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d start_label not before loop_end\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "iter_reg", "=", "loop", "->", "iter_reg", ";", "gcc_assert", "(", "REG_P", "(", "iter_reg", ")", ")", ";", "entry_edge", "=", "NULL", ";", "FOR_EACH_VEC_SAFE_ELT", "(", "loop", "->", "incoming", ",", "i", ",", "entry_edge", ")", "if", "(", "entry_edge", "->", "flags", "&", "EDGE_FALLTHRU", ")", "break", ";", "if", "(", "entry_edge", "==", "NULL", ")", "return", "false", ";", "entry_bb", "=", "entry_edge", "->", "src", ";", "start_sequence", "(", ")", ";", "insn", "=", "emit_insn", "(", "gen_zero_cost_loop_start", "(", "loop", "->", "iter_reg", ",", "loop", "->", "start_label", ",", "loop", "->", "iter_reg", ")", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "if", "(", "!", "single_succ_p", "(", "entry_bb", ")", "||", "vec_safe_length", "(", "loop", "->", "incoming", ")", ">", "1", ")", "{", "basic_block", "new_bb", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "emit_insn_before", "(", "seq", ",", "BB_HEAD", "(", "loop", "->", "head", ")", ")", ";", "seq", "=", "emit_label_before", "(", "gen_label_rtx", "(", ")", ",", "seq", ")", ";", "new_bb", "=", "create_basic_block", "(", "seq", ",", "insn", ",", "entry_bb", ")", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "loop", "->", "incoming", ")", "{", "if", "(", "!", "(", "e", "->", "flags", "&", "EDGE_FALLTHRU", ")", ")", "redirect_edge_and_branch_force", "(", "e", ",", "new_bb", ")", ";", "else", "redirect_edge_succ", "(", "e", ",", "new_bb", ")", ";", "}", "make_edge", "(", "new_bb", ",", "loop", "->", "head", ",", "0", ")", ";", "}", "else", "{", "entry_after", "=", "BB_END", "(", "entry_bb", ")", ";", "while", "(", "DEBUG_INSN_P", "(", "entry_after", ")", "||", "(", "NOTE_P", "(", "entry_after", ")", "&&", "NOTE_KIND", "(", "entry_after", ")", "!=", "NOTE_INSN_BASIC_BLOCK", "&&", "NOTE_KIND", "(", "entry_after", ")", "!=", "NOTE_INSN_CALL_ARG_LOCATION", ")", ")", "entry_after", "=", "PREV_INSN", "(", "entry_after", ")", ";", "emit_insn_after", "(", "seq", ",", "entry_after", ")", ";", "}", "end_sequence", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "callback", "for", "the", "hw-doloop", "pass", ".", "Called", "to", "optimize", "LOOP", "in", "a", "machine-specific", "fashion", ";", "returns", "true", "if", "successful", "and", "false", "if", "the", "hwloop_fail", "function", "should", "be", "called", "." ]

[ "xtensa", "1", "\";; loop %d is not innermost\\n\"", "\";; loop %d has more than one entry\\n\"", "\";; loop %d is not entered from head\\n\"", "\";; loop %d has invalid insn\\n\"", "\";; loop %d uses iterator\\n\"", "\";; loop %d start_label not before loop_end\\n\"", "1", "0" ]

[]

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

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

[ "RI5CY" ]

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isTargetAndroid", "(", ")", ")", "return", "TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRB", ")", ";", "unsigned", "AddressSpace", ",", "Offset", ";", "Offset", "=", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "?", "0x48", ":", "0x24", ";", "AddressSpace", "=", "getAddressSpace", "(", ")", ";", "return", "ConstantExpr", "::", "getIntToPtr", "(", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "IRB", ".", "getContext", "(", ")", ")", ",", "Offset", ")", ",", "Type", "::", "getInt8PtrTy", "(", "IRB", ".", "getContext", "(", ")", ")", "->", "getPointerTo", "(", "AddressSpace", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "stores", "SafeStack", "pointer", "at", "a", "fixed", "offset", "in", "some", "non-standard", "address", "space", ",", "and", "populates", "the", "address", "space", "and", "offset", "as", "appropriate", "." ]

[ "X86", "X86", "0x48", "0x24" ]

[]

[ "<s>", "bool", "SIFoldOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "!", "isSafeToFold", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "unsigned", "OpSize", "=", "TII", "->", "getOpSize", "(", "MI", ",", "1", ")", ";", "MachineOperand", "&", "OpToFold", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "bool", "FoldingImm", "=", "OpToFold", ".", "isImm", "(", ")", ";", "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "FoldingImm", "&&", "!", "TII", "->", "isInlineConstant", "(", "OpToFold", ",", "OpSize", ")", "&&", "!", "MRI", ".", "hasOneUse", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "OpToFold", ".", "getReg", "(", ")", ")", ")", "continue", ";", "MachineOperand", "&", "Dst", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Dst", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Dst", ".", "getReg", "(", ")", ")", ")", "continue", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "CopiesToReplace", ";", "std", "::", "vector", "<", "FoldCandidate", ">", "FoldList", ";", "for", "(", "MachineRegisterInfo", "::", "use_iterator", "Use", "=", "MRI", ".", "use_begin", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ",", "E", "=", "MRI", ".", "use_end", "(", ")", ";", "Use", "!=", "E", ";", "++", "Use", ")", "{", "MachineInstr", "*", "UseMI", "=", "Use", "->", "getParent", "(", ")", ";", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "Use", ".", "getOperandNo", "(", ")", ",", "FoldList", ",", "CopiesToReplace", ",", "TII", ",", "TRI", ",", "MRI", ")", ";", "}", "for", "(", "MachineInstr", "*", "Copy", ":", "CopiesToReplace", ")", "Copy", "->", "addImplicitDefUseOperands", "(", "MF", ")", ";", "for", "(", "FoldCandidate", "&", "Fold", ":", "FoldList", ")", "{", "if", "(", "updateOperand", "(", "Fold", ",", "TRI", ")", ")", "{", "if", "(", "!", "Fold", ".", "isImm", "(", ")", ")", "{", "assert", "(", "Fold", ".", "OpToFold", "&&", "Fold", ".", "OpToFold", "->", "isReg", "(", ")", ")", ";", "MRI", ".", "clearKillFlags", "(", "Fold", ".", "OpToFold", "->", "getReg", "(", ")", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Folded source from \"", "<<", "MI", "<<", "\" into OpNo \"", "<<", "Fold", ".", "UseOpNo", "<<", "\" of \"", "<<", "*", "Fold", ".", "UseMI", "<<", "'\\n'", ")", ";", "}", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "1", "1", "0", "0", "4", "0", "\"Folded source from \"", "\" into OpNo \"", "\" of \"" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "bool", "is64", "=", "getPointerSize", "(", ")", "==", "8", ";", "return", "createPPCELFObjectWriter", "(", "OS", ",", "is64", ",", "isLittleEndian", "(", ")", ",", "OSABI", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

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

[]

[ "<s>", "void", "AMDGPUTTI", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "UnrollingPreferences", "&", "UP", ")", "const", "{", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", "||", "GEP", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "continue", ";", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ")", ")", ";", "if", "(", "Alloca", ")", "{", "UP", ".", "Threshold", "=", "500", ";", "}", "}", "}", "}", "</s>" ]

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

[ "R600", "AMDGPUAS::PRIVATE_ADDRESS", "500" ]

[]

[ "<s>", "void", "s390_function_profiler", "(", "FILE", "*", "file", ",", "int", "labelno", ")", "{", "rtx", "op", "[", "7", "]", ";", "char", "label", "[", "128", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "label", ",", "\"LP\"", ",", "labelno", ")", ";", "fprintf", "(", "file", ",", "\"# function profiler \\n\"", ")", ";", "op", "[", "0", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_REGNUM", ")", ";", "op", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "op", "[", "1", "]", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "op", "[", "1", "]", ",", "UNITS_PER_WORD", ")", ")", ";", "op", "[", "2", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "op", "[", "3", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "label", ")", ";", "SYMBOL_REF_FLAGS", "(", "op", "[", "3", "]", ")", "=", "SYMBOL_FLAG_LOCAL", ";", "op", "[", "4", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_mcount\"", ")", ";", "if", "(", "flag_pic", ")", "{", "op", "[", "4", "]", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "op", "[", "4", "]", ")", ",", "UNSPEC_PLT", ")", ";", "op", "[", "4", "]", "=", "gen_rtx_CONST", "(", "Pmode", ",", "op", "[", "4", "]", ")", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "output_asm_insn", "(", "\"stg\\t%0,%1\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"larl\\t%2,%3\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"brasl\\t%0,%4\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"lg\\t%0,%1\"", ",", "op", ")", ";", "}", "else", "if", "(", "!", "flag_pic", ")", "{", "op", "[", "6", "]", "=", "gen_label_rtx", "(", ")", ";", "output_asm_insn", "(", "\"st\\t%0,%1\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"bras\\t%2,%l6\"", ",", "op", ")", ";", "output_asm_insn", "(", "\".long\\t%4\"", ",", "op", ")", ";", "output_asm_insn", "(", "\".long\\t%3\"", ",", "op", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "op", "[", "6", "]", ")", ")", ";", "output_asm_insn", "(", "\"l\\t%0,0(%2)\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"l\\t%2,4(%2)\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"basr\\t%0,%0\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"l\\t%0,%1\"", ",", "op", ")", ";", "}", "else", "{", "op", "[", "5", "]", "=", "gen_label_rtx", "(", ")", ";", "op", "[", "6", "]", "=", "gen_label_rtx", "(", ")", ";", "output_asm_insn", "(", "\"st\\t%0,%1\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"bras\\t%2,%l6\"", ",", "op", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "op", "[", "5", "]", ")", ")", ";", "output_asm_insn", "(", "\".long\\t%4-%l5\"", ",", "op", ")", ";", "output_asm_insn", "(", "\".long\\t%3-%l5\"", ",", "op", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "op", "[", "6", "]", ")", ")", ";", "output_asm_insn", "(", "\"lr\\t%0,%2\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"a\\t%0,0(%2)\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"a\\t%2,4(%2)\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"basr\\t%0,%0\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"l\\t%0,%1\"", ",", "op", ")", ";", "}", "}", "</s>" ]

[ "Output", "assembler", "code", "to", "FILE", "to", "call", "a", "profiler", "hook", "." ]

[ "s390", "7", "128", "\"LP\"", "\"# function profiler \\n\"", "0", "1", "1", "1", "2", "1", "3", "3", "4", "\"_mcount\"", "4", "1", "4", "4", "4", "\"stg\\t%0,%1\"", "\"larl\\t%2,%3\"", "\"brasl\\t%0,%4\"", "\"lg\\t%0,%1\"", "6", "\"st\\t%0,%1\"", "\"bras\\t%2,%l6\"", "\".long\\t%4\"", "\".long\\t%3\"", "\"L\"", "6", "\"l\\t%0,0(%2)\"", "\"l\\t%2,4(%2)\"", "\"basr\\t%0,%0\"", "\"l\\t%0,%1\"", "5", "6", "\"st\\t%0,%1\"", "\"bras\\t%2,%l6\"", "\"L\"", "5", "\".long\\t%4-%l5\"", "\".long\\t%3-%l5\"", "\"L\"", "6", "\"lr\\t%0,%2\"", "\"a\\t%0,0(%2)\"", "\"a\\t%2,4(%2)\"", "\"basr\\t%0,%0\"", "\"l\\t%0,%1\"" ]

[]

[ "<s>", "void", "LanaiAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", ",", "MCContext", "&", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "static_cast", "<", "unsigned", ">", "(", "Kind", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", "=", "4", ";", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "static_cast", "<", "uint64_t", ">", "(", "static_cast", "<", "uint8_t", ">", "(", "Data", "[", "Offset", "+", "Idx", "]", ")", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "static_cast", "<", "uint64_t", ">", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "static_cast", "<", "uint8_t", ">", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Lanai", "Lanai", "7", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "x86_extended_reg_mentioned_p", "(", "rtx", "insn", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "INSN_P", "(", "insn", ")", "?", "PATTERN", "(", "insn", ")", ":", "insn", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "REX_INT_REGNO_P", "(", "REGNO", "(", "x", ")", ")", "||", "REX_SSE_REGNO_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "INSN", "mentions", "register", "that", "must", "be", "encoded", "using", "REX", "prefix", "." ]

[ "i386" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "*", "getAMDGPUTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "initializeSIFixControlFlowLiveIntervalsPass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIFixControlFlowLiveIntervalsID", ")", ";", "}", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", "&&", "ST", ".", "loadStoreOptEnabled", "(", ")", ")", "{", "initializeSILoadStoreOptimizerPass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SILoadStoreOptimizerID", ")", ";", "}", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSIFixSGPRLiveRangesPass", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "R600", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "SimplifyCFGOptions", "(", ")", ".", "hoistCommonInsts", "(", "true", ")", ".", "sinkCommonInsts", "(", "true", ")", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "addPass", "(", "createMVEGatherScatterLoweringPass", "(", ")", ")", ";", "addPass", "(", "createMVELaneInterleavingPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "addPass", "(", "createARMParallelDSPPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "if", "(", "TM", "->", "Options", ".", "JMCInstrument", ")", "addPass", "(", "createJMCInstrumenterPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "ARM64", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "ARM64", "ARM64::NumTargetFixupKinds" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "InfosBE", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ppc_br24\"", ",", "6", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_brcond14\"", ",", "16", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_br24abs\"", ",", "6", ",", "24", ",", "0", "}", ",", "{", "\"fixup_ppc_brcond14abs\"", ",", "16", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_half16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_half16ds\"", ",", "0", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_nofixup\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "const", "static", "MCFixupKindInfo", "InfosLE", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ppc_br24\"", ",", "2", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_brcond14\"", ",", "2", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_br24abs\"", ",", "2", ",", "24", ",", "0", "}", ",", "{", "\"fixup_ppc_brcond14abs\"", ",", "2", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_half16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_half16ds\"", ",", "2", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_nofixup\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "(", "IsLittleEndian", "?", "InfosLE", ":", "InfosBE", ")", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC::NumTargetFixupKinds", "\"fixup_ppc_br24\"", "6", "24", "\"fixup_ppc_brcond14\"", "16", "14", "\"fixup_ppc_br24abs\"", "6", "24", "0", "\"fixup_ppc_brcond14abs\"", "16", "14", "0", "\"fixup_ppc_half16\"", "0", "16", "0", "\"fixup_ppc_half16ds\"", "0", "14", "0", "\"fixup_ppc_nofixup\"", "0", "0", "0", "PPC::NumTargetFixupKinds", "\"fixup_ppc_br24\"", "2", "24", "\"fixup_ppc_brcond14\"", "2", "14", "\"fixup_ppc_br24abs\"", "2", "24", "0", "\"fixup_ppc_brcond14abs\"", "2", "14", "0", "\"fixup_ppc_half16\"", "0", "16", "0", "\"fixup_ppc_half16ds\"", "2", "14", "0", "\"fixup_ppc_nofixup\"", "0", "0", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "validate_condition_mode", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "(", "GET_RTX_CLASS", "(", "code", ")", "==", "RTX_COMPARE", "||", "GET_RTX_CLASS", "(", "code", ")", "==", "RTX_COMM_COMPARE", ")", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", ";", "gcc_assert", "(", "(", "code", "!=", "GT", "&&", "code", "!=", "LT", "&&", "code", "!=", "GE", "&&", "code", "!=", "LE", ")", "||", "mode", "!=", "CCUNSmode", ")", ";", "gcc_assert", "(", "(", "code", "!=", "GTU", "&&", "code", "!=", "LTU", "&&", "code", "!=", "GEU", "&&", "code", "!=", "LEU", ")", "||", "mode", "==", "CCUNSmode", ")", ";", "gcc_assert", "(", "mode", "==", "CCFPmode", "||", "(", "code", "!=", "ORDERED", "&&", "code", "!=", "UNORDERED", "&&", "code", "!=", "UNEQ", "&&", "code", "!=", "LTGT", "&&", "code", "!=", "UNGT", "&&", "code", "!=", "UNLT", "&&", "code", "!=", "UNGE", "&&", "code", "!=", "UNLE", ")", ")", ";", "gcc_assert", "(", "mode", "!=", "CCFPmode", "||", "flag_finite_math_only", "||", "(", "code", "!=", "LE", "&&", "code", "!=", "GE", "&&", "code", "!=", "UNEQ", "&&", "code", "!=", "LTGT", "&&", "code", "!=", "UNGT", "&&", "code", "!=", "UNLT", ")", ")", ";", "gcc_assert", "(", "mode", "!=", "CCEQmode", "||", "code", "==", "EQ", "||", "code", "==", "NE", ")", ";", "}", "</s>" ]

[ "A", "validation", "routine", ":", "say", "whether", "CODE", ",", "a", "condition", "code", ",", "and", "MODE", "match", ".", "The", "other", "alternatives", "either", "do", "n't", "make", "sense", "or", "should", "never", "be", "generated", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "void", "aarch64_simd_emit_reg_reg_move", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ",", "unsigned", "int", "count", ")", "{", "unsigned", "int", "i", ";", "int", "rdest", "=", "REGNO", "(", "operands", "[", "0", "]", ")", ";", "int", "rsrc", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", "||", "rdest", "<", "rsrc", ")", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "mode", ",", "rdest", "+", "i", ")", ",", "gen_rtx_REG", "(", "mode", ",", "rsrc", "+", "i", ")", ")", ";", "else", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "mode", ",", "rdest", "+", "count", "-", "i", "-", "1", ")", ",", "gen_rtx_REG", "(", "mode", ",", "rsrc", "+", "count", "-", "i", "-", "1", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "register", "copy", "from", "operand", "to", "operand", ",", "taking", "care", "not", "to", "early-clobber", "source", "registers", "in", "the", "process", ".", "COUNT", "is", "the", "number", "of", "components", "into", "which", "the", "copy", "needs", "to", "be", "decomposed", "." ]

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

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "case", "PPC", "::", "SPILL_CR", ":", "case", "PPC", "::", "SPILL_CRBIT", ":", "case", "PPC", "::", "STVX", ":", "case", "PPC", "::", "STXVD2X", ":", "case", "PPC", "::", "QVSTFDX", ":", "case", "PPC", "::", "QVSTFSXs", ":", "case", "PPC", "::", "QVSTFDXb", ":", "case", "PPC", "::", "SPILL_VRSAVE", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::STD", "PPC::STW", "PPC::STFS", "PPC::STFD", "PPC::SPILL_CR", "PPC::SPILL_CRBIT", "PPC::STVX", "PPC::STXVD2X", "PPC::QVSTFDX", "PPC::QVSTFSXs", "PPC::QVSTFDXb", "PPC::SPILL_VRSAVE", "1", "1", "2", "2", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "assert", "(", "MI", ".", "getNumOperands", "(", ")", ">=", "2", "&&", "\"All AArch64 cmps should have 2 operands\"", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "PTEST_PP", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "SUBSWrr", ":", "case", "AArch64", "::", "SUBSWrs", ":", "case", "AArch64", "::", "SUBSWrx", ":", "case", "AArch64", "::", "SUBSXrr", ":", "case", "AArch64", "::", "SUBSXrs", ":", "case", "AArch64", "::", "SUBSXrx", ":", "case", "AArch64", "::", "ADDSWrr", ":", "case", "AArch64", "::", "ADDSWrs", ":", "case", "AArch64", "::", "ADDSWrx", ":", "case", "AArch64", "::", "ADDSXrr", ":", "case", "AArch64", "::", "ADDSXrs", ":", "case", "AArch64", "::", "ADDSXrx", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "SUBSWri", ":", "case", "AArch64", "::", "ADDSWri", ":", "case", "AArch64", "::", "SUBSXri", ":", "case", "AArch64", "::", "ADDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "!=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "ANDSWri", ":", "case", "AArch64", "::", "ANDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "AArch64_AM", "::", "decodeLogicalImmediate", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ",", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ANDSWri", "?", "32", ":", "64", ")", "!=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "AArch64", "AArch64", "2", "\"All AArch64 cmps should have 2 operands\"", "1", "AArch64::PTEST_PP", "0", "1", "0", "0", "AArch64::SUBSWrr", "AArch64::SUBSWrs", "AArch64::SUBSWrx", "AArch64::SUBSXrr", "AArch64::SUBSXrs", "AArch64::SUBSXrx", "AArch64::ADDSWrr", "AArch64::ADDSWrs", "AArch64::ADDSWrx", "AArch64::ADDSXrr", "AArch64::ADDSXrs", "AArch64::ADDSXrx", "1", "2", "0", "0", "AArch64::SUBSWri", "AArch64::ADDSWri", "AArch64::SUBSXri", "AArch64::ADDSXri", "1", "0", "0", "2", "0", "AArch64::ANDSWri", "AArch64::ANDSXri", "1", "0", "0", "AArch64_AM::decodeLogicalImmediate", "2", "AArch64::ANDSWri", "32", "64", "0" ]

[]

[ "<s>", "unsigned", "CSKYAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "CSKYOperand", "&", "Op", "=", "static_cast", "<", "CSKYOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "MCRegister", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "if", "(", "CSKYMCRegisterClasses", "[", "CSKY", "::", "FPR32RegClassID", "]", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "Kind", "==", "MCK_FPR64", "||", "Kind", "==", "MCK_sFPR64", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR32ToFPR64", "(", "Reg", ")", ";", "if", "(", "Kind", "==", "MCK_sFPR64", "&&", "(", "Op", ".", "Reg", ".", "RegNum", "<", "CSKY", "::", "F0_64", "||", "Op", ".", "Reg", ".", "RegNum", ">", "CSKY", "::", "F15_64", ")", ")", "return", "Match_InvalidRegOutOfRange", ";", "if", "(", "Kind", "==", "MCK_FPR64", "&&", "(", "Op", ".", "Reg", ".", "RegNum", "<", "CSKY", "::", "F0_64", "||", "Op", ".", "Reg", ".", "RegNum", ">", "CSKY", "::", "F31_64", ")", ")", "return", "Match_InvalidRegOutOfRange", ";", "return", "Match_Success", ";", "}", "}", "if", "(", "CSKYMCRegisterClasses", "[", "CSKY", "::", "GPRRegClassID", "]", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "Kind", "==", "MCK_GPRPair", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "MRI", "->", "getEncodingValue", "(", "Reg", ")", "+", "CSKY", "::", "R0_R1", ";", "return", "Match_Success", ";", "}", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY::FPR32RegClassID", "CSKY::F0_64", "CSKY::F15_64", "CSKY::F0_64", "CSKY::F31_64", "CSKY", "CSKY::GPRRegClassID", "CSKY::R0_R1" ]

[]

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

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

[ "arm", "\"Advanced SIMD type\"", "\"Advanced SIMD type\"", "0", "0", "1", "\"long_call\"", "\"long_call\"", "\"short_call\"", "\"short_call\"", "0", "0", "\"isr\"", "\"interrupt\"", "\"isr\"", "\"interrupt\"", "0", "\"cmse_nonsecure_call\"", "\"cmse_nonsecure_call\"", "0", "1" ]

[]

[ "<s>", "static", "const", "predefined_function_abi", "&", "aarch64_fntype_abi", "(", "const_tree", "fntype", ")", "{", "if", "(", "lookup_attribute", "(", "\"aarch64_vector_pcs\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "return", "aarch64_simd_abi", "(", ")", ";", "if", "(", "aarch64_returns_value_in_sve_regs_p", "(", "fntype", ")", "||", "aarch64_takes_arguments_in_sve_regs_p", "(", "fntype", ")", ")", "return", "aarch64_sve_abi", "(", ")", ";", "return", "default_function_abi", ";", "}", "</s>" ]

[ "Implement", "TARGET_FNTYPE_ABI", "." ]

[ "aarch64", "\"aarch64_vector_pcs\"" ]

[]

[ "<s>", "bool", "aarch64_pad_reg_upward", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "first", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "BYTES_BIG_ENDIAN", "&&", "aarch64_composite_type_p", "(", "type", ",", "mode", ")", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ";", "if", "(", "size", "<", "2", "*", "UNITS_PER_WORD", ")", "return", "true", ";", "}", "return", "!", "BYTES_BIG_ENDIAN", ";", "}", "</s>" ]

[ "Similarly", ",", "for", "use", "by", "BLOCK_REG_PADDING", "(", "MODE", ",", "TYPE", ",", "FIRST", ")", ".", "It", "specifies", "padding", "for", "the", "last", "(", "may", "also", "be", "the", "only", ")", "element", "of", "a", "block", "move", "between", "registers", "and", "memory", ".", "If", "assuming", "the", "block", "is", "in", "the", "memory", ",", "padding", "upward", "means", "that", "the", "last", "element", "is", "padded", "after", "its", "highest", "significant", "byte", ",", "while", "in", "downward", "padding", ",", "the", "last", "element", "is", "padded", "at", "the", "its", "least", "significant", "byte", "side", ".", "Small", "aggregates", "and", "small", "complex", "types", "are", "always", "padded", "upwards", ".", "We", "do", "n't", "need", "to", "worry", "about", "homogeneous", "floating-point", "or", "short-vector", "aggregates", ";", "their", "move", "is", "not", "affected", "by", "the", "padding", "direction", "determined", "here", ".", "Regardless", "of", "endianness", ",", "each", "element", "of", "such", "an", "aggregate", "is", "put", "in", "the", "least", "significant", "bits", "of", "a", "fp/simd", "register", ".", "Return", "!", "BYTES_BIG_ENDIAN", "if", "the", "least", "significant", "byte", "of", "the", "register", "has", "useful", "data", ",", "and", "return", "the", "opposite", "if", "the", "most", "significant", "byte", "does", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "static", "int", "thumb2_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict_p", ")", "{", "bool", "use_ldrd", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "arm_address_register_rtx_p", "(", "x", ",", "strict_p", ")", ")", "return", "1", ";", "use_ldrd", "=", "(", "TARGET_LDRD", "&&", "(", "mode", "==", "DImode", "||", "(", "mode", "==", "DFmode", "&&", "(", "TARGET_SOFT_FLOAT", "||", "TARGET_VFP", ")", ")", ")", ")", ";", "if", "(", "code", "==", "POST_INC", "||", "code", "==", "PRE_DEC", "||", "(", "(", "code", "==", "PRE_INC", "||", "code", "==", "POST_DEC", ")", "&&", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", ";", "else", "if", "(", "(", "code", "==", "POST_MODIFY", "||", "code", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "rtx", "addend", "=", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "!", "CONST_INT_P", "(", "addend", ")", ")", "return", "0", ";", "offset", "=", "INTVAL", "(", "addend", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "return", "(", "offset", ">", "-", "256", "&&", "offset", "<", "256", ")", ";", "return", "(", "use_ldrd", "&&", "offset", ">", "-", "1024", "&&", "offset", "<", "1024", "&&", "(", "offset", "&", "3", ")", "==", "0", ")", ";", "}", "else", "if", "(", "reload_completed", "&&", "(", "code", "==", "LABEL_REF", "||", "(", "code", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "1", ";", "else", "if", "(", "mode", "==", "TImode", "||", "(", "TARGET_NEON", "&&", "VALID_NEON_STRUCT_MODE", "(", "mode", ")", ")", ")", "return", "0", ";", "else", "if", "(", "code", "==", "PLUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "(", "thumb2_legitimate_index_p", "(", "mode", ",", "xop1", ",", "strict_p", ")", "||", "(", "!", "strict_p", "&&", "will_be_in_index_register", "(", "xop1", ")", ")", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xop1", ",", "strict_p", ")", "&&", "thumb2_legitimate_index_p", "(", "mode", ",", "xop0", ",", "strict_p", ")", ")", ")", ";", "}", "else", "if", "(", "arm_disable_literal_pool", "&&", "code", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "return", "0", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "&&", "code", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", "&&", "!", "(", "flag_pic", "&&", "symbol_mentioned_p", "(", "get_pool_constant", "(", "x", ")", ")", "&&", "!", "pcrel_constant_p", "(", "get_pool_constant", "(", "x", ")", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "is", "a", "valid", "Thumb-2", "address", "operand", "." ]

[ "arm", "1", "4", "0", "0", "1", "1", "0", "0", "1", "1", "0", "4", "256", "256", "1024", "1024", "3", "0", "0", "0", "0", "0", "1", "1", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "nvptx_emit_joining", "(", "unsigned", "mask", ",", "bool", "is_call", ")", "{", "mask", "&=", "(", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", "|", "GOMP_DIM_MASK", "(", "GOMP_DIM_VECTOR", ")", ")", ";", "if", "(", "mask", ")", "{", "rtx", "op", "=", "GEN_INT", "(", "mask", "|", "(", "is_call", "<<", "GOMP_DIM_MAX", ")", ")", ";", "if", "(", "!", "is_call", ")", "emit_insn", "(", "gen_nvptx_joining", "(", "op", ")", ")", ";", "emit_insn", "(", "gen_nvptx_join", "(", "op", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "joining", "instructions", "for", "MASK", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "bool", "is_costly_group", "(", "rtx", "*", "group_insns", ",", "rtx", "next_insn", ")", "{", "int", "i", ";", "rtx", "link", ";", "int", "cost", ";", "int", "issue_rate", "=", "rs6000_issue_rate", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "rtx", "insn", "=", "group_insns", "[", "i", "]", ";", "if", "(", "!", "insn", ")", "continue", ";", "for", "(", "link", "=", "INSN_DEPEND", "(", "insn", ")", ";", "link", "!=", "0", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "{", "rtx", "next", "=", "XEXP", "(", "link", ",", "0", ")", ";", "if", "(", "next", "==", "next_insn", ")", "{", "cost", "=", "insn_cost", "(", "insn", ",", "link", ",", "next_insn", ")", ";", "if", "(", "rs6000_is_costly_dependence", "(", "insn", ",", "next_insn", ",", "link", ",", "cost", ",", "0", ")", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "recommended", "to", "keep", "NEXT_INSN", "``", "far", "''", "(", "in", "a", "separate", "dispatch", "group", ")", "from", "the", "insns", "in", "GROUP_INSNS", ".", "Return", "false", "otherwise", "." ]

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

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "PPC", "::", "NOP", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "PowerPC", "PPC", "PPC::NOP" ]

[]

[ "<s>", "static", "bool", "isSigned", "(", "Kind", "Cmp", ")", "{", "return", "(", "Cmp", "&", "(", "L", "|", "G", ")", "&&", "!", "(", "Cmp", "&", "U", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "all", "source", "operands", "of", "the", "recurrence", "are", "SExtInsts", "." ]

[ "Hexagon" ]

[]