Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Alpha Machine Code Emitter\"", ";", "}", "</s>" ]

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

[ "Alpha", "\"Alpha Machine Code Emitter\"" ]

[]

[ "<s>", "static", "void", "aarch64_analyze_bb_vinfo", "(", "bb_vec_info", "bb_vinfo", ",", "aarch64_vector_costs", "*", "costs", ")", "{", "costs", "->", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "bb_vinfo", "->", "vector_mode", ")", ";", "}", "</s>" ]

[ "Do", "one-time", "initialization", "of", "COSTS", "given", "that", "we", "'re", "costing", "the", "block", "vectorization", "described", "by", "BB_VINFO", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "ix86_expand_reduc_v4sf", "(", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ",", "rtx", "dest", ",", "rtx", "in", ")", "{", "rtx", "tmp1", ",", "tmp2", ",", "tmp3", ";", "tmp1", "=", "gen_reg_rtx", "(", "V4SFmode", ")", ";", "tmp2", "=", "gen_reg_rtx", "(", "V4SFmode", ")", ";", "tmp3", "=", "gen_reg_rtx", "(", "V4SFmode", ")", ";", "emit_insn", "(", "gen_sse_movhlps", "(", "tmp1", ",", "in", ",", "in", ")", ")", ";", "emit_insn", "(", "fn", "(", "tmp2", ",", "tmp1", ",", "in", ")", ")", ";", "emit_insn", "(", "gen_sse_shufps_1", "(", "tmp3", ",", "tmp2", ",", "tmp2", ",", "GEN_INT", "(", "1", ")", ",", "GEN_INT", "(", "1", ")", ",", "GEN_INT", "(", "1", "+", "4", ")", ",", "GEN_INT", "(", "1", "+", "4", ")", ")", ")", ";", "emit_insn", "(", "fn", "(", "dest", ",", "tmp2", ",", "tmp3", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "reduction", "on", "V4SFmode", "for", "SSE1", ".", "FN", "is", "the", "binary", "pattern", "to", "reduce", ";", "DEST", "is", "the", "destination", ";", "IN", "is", "the", "input", "vector", "." ]

[ "i386", "1", "1", "1", "4", "1", "4" ]

[]

[ "<s>", "bool", "WebAssembly", "::", "mayThrow", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "THROW", ":", "case", "WebAssembly", "::", "THROW_S", ":", "case", "WebAssembly", "::", "RETHROW", ":", "case", "WebAssembly", "::", "RETHROW_S", ":", "return", "true", ";", "}", "if", "(", "isCallIndirect", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "getCalleeOpNo", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", ";", "assert", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", ";", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"memcpy\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"memmove\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"memset\"", ")", "==", "0", ")", "return", "false", ";", "return", "true", ";", "}", "const", "auto", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "if", "(", "!", "F", ")", "return", "true", ";", "if", "(", "F", "->", "doesNotThrow", "(", ")", ")", "return", "false", ";", "if", "(", "F", "->", "getName", "(", ")", "==", "CxaBeginCatchFn", "||", "F", "->", "getName", "(", ")", "==", "PersonalityWrapperFn", "||", "F", "->", "getName", "(", ")", "==", "ClangCallTerminateFn", "||", "F", "->", "getName", "(", ")", "==", "StdTerminateFn", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "may", "throw", "an", "exception", "." ]

[ "WebAssembly", "WebAssembly::mayThrow", "WebAssembly::THROW", "WebAssembly::THROW_S", "WebAssembly::RETHROW", "WebAssembly::RETHROW_S", "\"memcpy\"", "0", "\"memmove\"", "0", "\"memset\"", "0" ]

[]

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

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

[ "Dcpu16", "DCPU16" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Aggressive", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "EnableBranchTargets", ")", "addPass", "(", "createAArch64BranchTargetsPass", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "addPass", "(", "createAArch64ExpandHardenedPseudosPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "nullptr", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "mips_get_compress_off_name", "(", "unsigned", "int", "flags", ")", "{", "if", "(", "flags", "==", "MASK_MIPS16", ")", "return", "\"nomips16\"", ";", "if", "(", "flags", "==", "MASK_MICROMIPS", ")", "return", "\"nomicromips\"", ";", "return", "\"nocompression\"", ";", "}", "</s>" ]

[ "Return", "the", "attribute", "name", "that", "forbids", "MASK_MIPS16", "and", "MASK_MICROMIPS", "flags", "FLAGS", "." ]

[ "mips", "\"nomips16\"", "\"nomicromips\"", "\"nocompression\"" ]

[]

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

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

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "static", "bool", "rs6000_must_pass_in_stack", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", "||", "TARGET_64BIT", ")", "return", "must_pass_in_stack_var_size", "(", "mode", ",", "type", ")", ";", "else", "return", "must_pass_in_stack_var_size_or_pad", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "must", "be", "passed", "on", "the", "stack", "and", "not", "in", "registers", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "LOAD_STACK_GUARD", ":", "{", "assert", "(", "Subtarget", ".", "isTargetLinux", "(", ")", "&&", "\"Only Linux target is expected to contain LOAD_STACK_GUARD\"", ")", ";", "const", "int64_t", "Offset", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "-", "0x7010", ":", "-", "0x7008", ";", "const", "unsigned", "Reg", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "X13", ":", "PPC", "::", "R2", ";", "MI", ".", "setDesc", "(", "get", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "LD", ":", "PPC", "::", "LWZ", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "Reg", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Only Linux target is expected to contain LOAD_STACK_GUARD\"", "PPC", "0x7010", "0x7008", "PPC", "PPC::X13", "PPC::R2", "PPC", "PPC::LD", "PPC::LWZ" ]

[]

[ "<s>", "static", "void", "c6x_option_override", "(", "void", ")", "{", "unsigned", "i", ";", "if", "(", "global_options_set", ".", "x_c6x_arch_option", ")", "{", "c6x_arch", "=", "all_isas", "[", "c6x_arch_option", "]", ".", "type", ";", "c6x_insn_mask", "&=", "~", "C6X_INSNS_ALL_CPU_BITS", ";", "c6x_insn_mask", "|=", "all_isas", "[", "c6x_arch_option", "]", ".", "features", ";", "}", "c6x_flag_schedule_insns2", "=", "flag_schedule_insns_after_reload", ";", "flag_schedule_insns_after_reload", "=", "0", ";", "c6x_flag_modulo_sched", "=", "flag_modulo_sched", ";", "flag_modulo_sched", "=", "0", ";", "init_machine_status", "=", "c6x_init_machine_status", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "c6x_unit_names", ")", ";", "i", "++", ")", "c6x_unit_codes", "[", "i", "]", "=", "get_cpu_unit_code", "(", "c6x_unit_names", "[", "i", "]", ")", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_DSBT", ")", "{", "error", "(", "\"-fpic and -fPIC not supported without -mdsbt on this target\"", ")", ";", "flag_pic", "=", "0", ";", "}", "c6x_initial_flag_pic", "=", "flag_pic", ";", "if", "(", "TARGET_DSBT", "&&", "!", "flag_pic", ")", "flag_pic", "=", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "c6x", "0", "0", "0", "\"-fpic and -fPIC not supported without -mdsbt on this target\"", "0", "1" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "NumBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "Idx", "*", "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", "." ]

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

[]

[ "<s>", "void", "addImm", "(", "int64_t", "imm", ")", "{", "Imm", "+=", "imm", ";", "}", "</s>" ]

[ "Add", "a", "new", "integer", "immediate", "operand", "." ]

[ "X86" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64ISD", "::", "CSEL", ":", "{", "KnownBits", "Known2", ";", "Known", "=", "DAG", ".", "computeKnownBits", "(", "Op", "->", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "Known2", "=", "DAG", ".", "computeKnownBits", "(", "Op", "->", "getOperand", "(", "1", ")", ",", "Depth", "+", "1", ")", ";", "Known", ".", "Zero", "&=", "Known2", ".", "Zero", ";", "Known", ".", "One", "&=", "Known2", ".", "One", ";", "break", ";", "}", "case", "AArch64ISD", "::", "LOADgot", ":", "case", "AArch64ISD", "::", "ADDlow", ":", "{", "if", "(", "!", "Subtarget", "->", "isTargetILP32", "(", ")", ")", "break", ";", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "64", ",", "32", ")", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "aarch64_ldaxr", ":", "case", "Intrinsic", "::", "aarch64_ldxr", ":", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "Known", ".", "Zero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_VOID", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_neon_umaxv", ":", "case", "Intrinsic", "::", "aarch64_neon_uminv", ":", "{", "MVT", "VT", "=", "Op", ".", "getOperand", "(", "1", ")", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v8i8", "||", "VT", "==", "MVT", "::", "v16i8", ")", "{", "assert", "(", "BitWidth", ">=", "8", "&&", "\"Unexpected width!\"", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "8", ")", ";", "Known", ".", "Zero", "|=", "Mask", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "v4i16", "||", "VT", "==", "MVT", "::", "v8i16", ")", "{", "assert", "(", "BitWidth", ">=", "16", "&&", "\"Unexpected width!\"", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "16", ")", ";", "Known", ".", "Zero", "|=", "Mask", ";", "}", "break", ";", "}", "break", ";", "}", "}", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64ISD::CSEL", "0", "1", "1", "1", "AArch64ISD::LOADgot", "AArch64ISD::ADDlow", "64", "32", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "0", "Intrinsic::aarch64_neon_umaxv", "Intrinsic::aarch64_neon_uminv", "1", "MVT::v8i8", "MVT::v16i8", "8", "\"Unexpected width!\"", "8", "MVT::v4i16", "MVT::v8i16", "16", "\"Unexpected width!\"", "16" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "if", "(", "Subtarget", ".", "hasVector", "(", ")", ")", "VerifyVectorTypes", "(", "Outs", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RetLocs", ";", "CCState", "RetCCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RetLocs", ",", "Context", ")", ";", "return", "RetCCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_SystemZ", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "SystemZ", "SystemZ", "ISD::OutputArg", "16", "SystemZ" ]

[]

[ "<s>", "void", "OR1KInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "OR1K", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "OR1K", "::", "ORI", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K::GPRRegClass", "OR1K::ORI", "0", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createPPCPreEmitPeepholePass", "(", ")", ")", ";", "addPass", "(", "createPPCExpandISELPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCEarlyReturnPass", "(", ")", ")", ";", "addPass", "(", "createPPCBranchSelectionPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", "||", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "if", "(", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", ")", "return", "nullptr", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "MI", "->", "getOperand", "(", "2", ")", ".", "isFPImm", "(", ")", "||", "(", "!", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "!", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "abs", ")", ")", ".", "getImm", "(", ")", "||", "MI", "->", "getOperand", "(", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "neg", ")", ")", ".", "getImm", "(", ")", ")", ")", "return", "nullptr", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "ChangeToImmediate", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "commuteOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "R600", "SI", "3", "1", "1", "1", "2", "2", "1", "1", "1", "2", "2", "2" ]

[]

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

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "AVR" ]

[]

[ "<s>", "unsigned", "RV16KInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "&&", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "0", ";", "I", "->", "eraseFromParent", "(", ")", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "1", ";", "I", "->", "eraseFromParent", "(", ")", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "0", "0", "0", "1", "1", "2" ]

[]

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

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

[ "AArch64", "64" ]

[]

[ "<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "i", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_CC", ":", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "break", ";", "default", ":", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "i", "<", "60", ")", "arc_regno_reg_class", "[", "i", "]", "=", "GENERAL_REGS", ";", "else", "if", "(", "i", "==", "60", ")", "arc_regno_reg_class", "[", "i", "]", "=", "LPCOUNT_REG", ";", "else", "if", "(", "i", "==", "61", ")", "arc_regno_reg_class", "[", "i", "]", "=", "NO_REGS", ";", "else", "arc_regno_reg_class", "[", "i", "]", "=", "NO_REGS", ";", "}", "}", "</s>" ]

[ "Initialize", "the", "arc_mode_class", "array", "." ]

[ "arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "1", "0", "0", "60", "60", "61" ]

[]

[ "<s>", "void", "TeeRISCFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TeeRISCInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "TeeRISCInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TeeRISCMachineFunctionInfo", "*", "TFI", "=", "MF", ".", "getInfo", "<", "TeeRISCMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "determineFrameLayout", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "int", "FPOffset", "=", "TFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "TFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TeeRISC", "::", "ADD_IMM", ")", ",", "TeeRISC", "::", "SP", ")", ".", "addReg", "(", "TeeRISC", "::", "SP", ")", ".", "addImm", "(", "StackSize", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TeeRISC", "::", "ST", ")", ",", "TeeRISC", "::", "SP", ")", ".", "addReg", "(", "TeeRISC", "::", "LR", ")", ".", "addImm", "(", "RAOffset", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TeeRISC", "::", "ST", ")", ",", "TeeRISC", "::", "FP", ")", ".", "addReg", "(", "TeeRISC", "::", "SP", ")", ".", "addImm", "(", "FPOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TeeRISC", "::", "ADD", ")", ",", "TeeRISC", "::", "FP", ")", ".", "addReg", "(", "TeeRISC", "::", "SP", ")", ".", "addReg", "(", "TeeRISC", "::", "ZERO", ")", ";", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "TeeRISC", "TeeRISC", "TeeRISC", "TeeRISC", "TeeRISC", "TeeRISC", "0", "TeeRISC::ADD_IMM", "TeeRISC::SP", "TeeRISC::SP", "TeeRISC::ST", "TeeRISC::SP", "TeeRISC::LR", "TeeRISC::ST", "TeeRISC::FP", "TeeRISC::SP", "TeeRISC::ADD", "TeeRISC::FP", "TeeRISC::SP", "TeeRISC::ZERO" ]

[]

[ "<s>", "bool", "SparcFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "bool", "rs6000_discover_homogeneous_aggregate", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "machine_mode", "*", "elt_mode", ",", "int", "*", "n_elts", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "machine_mode", "field_mode", "=", "VOIDmode", ";", "int", "field_count", "=", "rs6000_aggregate_candidate", "(", "type", ",", "&", "field_mode", ")", ";", "if", "(", "field_count", ">", "0", ")", "{", "int", "n_regs", "=", "(", "SCALAR_FLOAT_MODE_P", "(", "field_mode", ")", "?", "(", "GET_MODE_SIZE", "(", "field_mode", ")", "+", "7", ")", ">>", "3", ":", "1", ")", ";", "if", "(", "field_count", "*", "n_regs", "<=", "AGGR_ARG_NUM_REG", ")", "{", "if", "(", "elt_mode", ")", "*", "elt_mode", "=", "field_mode", ";", "if", "(", "n_elts", ")", "*", "n_elts", "=", "field_count", ";", "return", "true", ";", "}", "}", "}", "if", "(", "elt_mode", ")", "*", "elt_mode", "=", "mode", ";", "if", "(", "n_elts", ")", "*", "n_elts", "=", "1", ";", "return", "false", ";", "}", "</s>" ]

[ "If", "an", "argument", ",", "whose", "type", "is", "described", "by", "TYPE", "and", "MODE", ",", "is", "a", "homogeneous", "float", "or", "vector", "aggregate", "that", "shall", "be", "passed", "in", "FP/vector", "registers", "according", "to", "the", "ELFv2", "ABI", ",", "return", "the", "homogeneous", "element", "mode", "in", "*", "ELT_MODE", "and", "the", "number", "of", "elements", "in", "*", "N_ELTS", ",", "and", "return", "TRUE", ".", "Otherwise", ",", "set", "*", "ELT_MODE", "to", "MODE", "and", "*", "N_ELTS", "to", "1", ",", "and", "return", "FALSE", "." ]

[ "rs6000", "0", "7", "3", "1", "1" ]

[]

[ "<s>", "void", "HexagonEarlyIfConversion", "::", "removeBlock", "(", "MachineBasicBlock", "*", "B", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Removing block \"", "<<", "PrintMB", "(", "B", ")", "<<", "\"\\n\"", ")", ";", "MachineDomTreeNode", "*", "N", "=", "MDT", "->", "getNode", "(", "B", ")", ";", "MachineDomTreeNode", "*", "IDN", "=", "N", "->", "getIDom", "(", ")", ";", "if", "(", "IDN", ")", "{", "MachineBasicBlock", "*", "IDB", "=", "IDN", "->", "getBlock", "(", ")", ";", "using", "GTN", "=", "GraphTraits", "<", "MachineDomTreeNode", "*", ">", ";", "using", "DTNodeVectType", "=", "SmallVector", "<", "MachineDomTreeNode", "*", ",", "4", ">", ";", "DTNodeVectType", "Cn", "(", "GTN", "::", "child_begin", "(", "N", ")", ",", "GTN", "::", "child_end", "(", "N", ")", ")", ";", "for", "(", "DTNodeVectType", "::", "iterator", "I", "=", "Cn", ".", "begin", "(", ")", ",", "E", "=", "Cn", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineBasicBlock", "*", "SB", "=", "(", "*", "I", ")", "->", "getBlock", "(", ")", ";", "MDT", "->", "changeImmediateDominator", "(", "SB", ",", "IDB", ")", ";", "}", "}", "while", "(", "B", "->", "succ_size", "(", ")", ">", "0", ")", "B", "->", "removeSuccessor", "(", "B", "->", "succ_begin", "(", ")", ")", ";", "for", "(", "auto", "I", "=", "B", "->", "pred_begin", "(", ")", ",", "E", "=", "B", "->", "pred_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "(", "*", "I", ")", "->", "removeSuccessor", "(", "B", ",", "true", ")", ";", "Deleted", ".", "insert", "(", "B", ")", ";", "MDT", "->", "eraseNode", "(", "B", ")", ";", "MFN", "->", "erase", "(", "B", "->", "getIterator", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "completely", "removes", "BB", "from", "all", "data", "structures", ",", "including", "all", "of", "the", "Loop", "objects", "it", "is", "nested", "in", "and", "our", "mapping", "from", "MachineBasicBlocks", "to", "loops", "." ]

[ "Hexagon", "Hexagon", "\"Removing block \"", "\"\\n\"", "4", "0" ]

[]

[ "<s>", "static", "opt_machine_mode", "aarch64_vectorize_related_mode", "(", "machine_mode", "vector_mode", ",", "scalar_mode", "element_mode", ",", "poly_uint64", "nunits", ")", "{", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "vector_mode", ")", ";", "poly_uint64", "sve_nunits", ";", "if", "(", "(", "vec_flags", "&", "VEC_SVE_DATA", ")", "&&", "multiple_p", "(", "BYTES_PER_SVE_VECTOR", ",", "GET_MODE_SIZE", "(", "element_mode", ")", ",", "&", "sve_nunits", ")", ")", "{", "machine_mode", "sve_mode", ";", "if", "(", "maybe_ne", "(", "nunits", ",", "0U", ")", ")", "{", "if", "(", "multiple_p", "(", "sve_nunits", ",", "nunits", ")", "&&", "aarch64_sve_data_mode", "(", "element_mode", ",", "nunits", ")", ".", "exists", "(", "&", "sve_mode", ")", ")", "return", "sve_mode", ";", "}", "else", "{", "sve_nunits", "=", "ordered_min", "(", "sve_nunits", ",", "GET_MODE_SIZE", "(", "vector_mode", ")", ")", ";", "if", "(", "aarch64_sve_data_mode", "(", "element_mode", ",", "sve_nunits", ")", ".", "exists", "(", "&", "sve_mode", ")", ")", "return", "sve_mode", ";", "}", "}", "if", "(", "(", "vec_flags", "&", "VEC_ADVSIMD", ")", "&&", "known_eq", "(", "nunits", ",", "0U", ")", "&&", "known_eq", "(", "GET_MODE_BITSIZE", "(", "vector_mode", ")", ",", "64U", ")", "&&", "maybe_ge", "(", "GET_MODE_BITSIZE", "(", "element_mode", ")", "*", "GET_MODE_NUNITS", "(", "vector_mode", ")", ",", "128U", ")", ")", "{", "machine_mode", "res", "=", "aarch64_simd_container_mode", "(", "element_mode", ",", "128", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "res", ")", ")", "return", "res", ";", "}", "return", "default_vectorize_related_mode", "(", "vector_mode", ",", "element_mode", ",", "nunits", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_RELATED_MODE", "." ]

[ "aarch64", "0U", "0U", "64U", "128U", "128" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "if", "(", "Triple", "(", "TM", "->", "getTargetTriple", "(", ")", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", "&&", "!", "DisableVSXSwapRemoval", ")", "addPass", "(", "createPPCVSXSwapRemovalPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "AARCH64_DEAD_REG_DEF_NAME", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "static", "int", "stackSlotSize", "(", ")", "{", "return", "4", ";", "}", "</s>" ]

[ "Stack", "slot", "size", "(", "4", "bytes", ")" ]

[ "TOY", "4" ]

[]

[ "<s>", "bool", "TeakInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TBB", ",", "unsigned", "TCycles", ",", "unsigned", "TExtra", ",", "MachineBasicBlock", "&", "FBB", ",", "unsigned", "FCycles", ",", "unsigned", "FExtra", ",", "BranchProbability", "Probability", ")", "const", "{", "dbgs", "(", ")", "<<", "\"isProfitableToIfCvt TF\\n\"", ";", "return", "true", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "Teak", "Teak", "\"isProfitableToIfCvt TF\\n\"" ]

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "int", "rs6000_loop_align", "(", "rtx", "label", ")", "{", "basic_block", "bb", ";", "int", "ninsns", ";", "if", "(", "!", "can_override_loop_align", ")", "return", "align_loops_log", ";", "bb", "=", "BLOCK_FOR_INSN", "(", "label", ")", ";", "ninsns", "=", "num_loop_insns", "(", "bb", "->", "loop_father", ")", ";", "if", "(", "ninsns", ">", "4", "&&", "ninsns", "<=", "8", "&&", "(", "rs6000_cpu", "==", "PROCESSOR_POWER4", "||", "rs6000_cpu", "==", "PROCESSOR_POWER5", "||", "rs6000_cpu", "==", "PROCESSOR_POWER6", "||", "rs6000_cpu", "==", "PROCESSOR_POWER7", "||", "rs6000_cpu", "==", "PROCESSOR_POWER8", "||", "rs6000_cpu", "==", "PROCESSOR_POWER9", ")", ")", "return", "5", ";", "else", "return", "align_loops_log", ";", "}", "</s>" ]

[ "Implement", "LOOP_ALIGN", "." ]

[ "powerpcspe", "4", "8", "5" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "MachineInstr", "*", "FirstLdSt", ",", "MachineInstr", "*", "SecondLdSt", ",", "unsigned", "NumLoads", ")", "const", "{", "if", "(", "NumLoads", ">", "1", ")", "return", "false", ";", "unsigned", "FirstOpc", "=", "FirstLdSt", "->", "getOpcode", "(", ")", ";", "unsigned", "SecondOpc", "=", "SecondLdSt", "->", "getOpcode", "(", ")", ";", "if", "(", "!", "canPairLdStOpc", "(", "FirstOpc", ",", "SecondOpc", ")", ")", "return", "false", ";", "if", "(", "!", "isCandidateToMergeOrPair", "(", "FirstLdSt", ")", "||", "!", "isCandidateToMergeOrPair", "(", "SecondLdSt", ")", ")", "return", "false", ";", "int64_t", "Offset1", "=", "FirstLdSt", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "assert", "(", "Offset1", "<=", "Offset2", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "return", "Offset1", "+", "1", "==", "Offset2", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AArch64", "AArch64", "1", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isIntDivCheap", "(", "EVT", "VT", ",", "AttributeList", "Attr", ")", "const", "{", "bool", "OptSize", "=", "Attr", ".", "hasFnAttr", "(", "Attribute", "::", "MinSize", ")", ";", "return", "OptSize", "&&", "!", "VT", ".", "isVector", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "divide", "is", "usually", "cheaper", "than", "a", "sequence", "of", "several", "shifts", ",", "adds", ",", "and", "multiplies", "for", "this", "target", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "int", "first_jump_index", "(", "int", "clock_var", ")", "{", "int", "retval", "=", "-", "1", ";", "int", "n", "=", "0", ";", "for", "(", ";", ";", ")", "{", "int", "t", "=", "get_jump_cycle", "(", "n", ")", ";", "if", "(", "t", "<=", "clock_var", ")", "break", ";", "retval", "=", "n", ";", "n", "++", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Return", "the", "index", "of", "the", "first", "jump", "that", "occurs", "after", "CLOCK_VAR", ".", "If", "no", "jump", "has", "delay", "slots", "beyond", "CLOCK_VAR", ",", "return", "-1", "." ]

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

[]

[ "<s>", "static", "void", "write_function_decl_and_comment", "(", "std", "::", "stringstream", "&", "s", ",", "const", "char", "*", "name", ",", "const_tree", "decl", ")", "{", "s", "<<", "\"// BEGIN\"", ";", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "s", "<<", "\" GLOBAL\"", ";", "s", "<<", "\" FUNCTION DECL: \"", ";", "if", "(", "name", "[", "0", "]", "==", "'*'", ")", "s", "<<", "(", "name", "+", "1", ")", ";", "else", "s", "<<", "name", ";", "s", "<<", "\"\\n\"", ";", "nvptx_write_function_decl", "(", "s", ",", "name", ",", "decl", ")", ";", "s", "<<", "\";\\n\"", ";", "}", "</s>" ]

[ "Write", "a", ".func", "or", ".kernel", "declaration", "(", "not", "a", "definition", ")", "along", "with", "a", "helper", "comment", "for", "use", "by", "ld", ".", "S", "is", "the", "stream", "to", "write", "to", ",", "DECL", "the", "decl", "for", "the", "function", "with", "name", "NAME", "." ]

[ "nvptx", "\"// BEGIN\"", "\" GLOBAL\"", "\" FUNCTION DECL: \"", "0", "1", "\"\\n\"", "\";\\n\"" ]

[]

[ "<s>", "rtx", "avr_incoming_return_addr_rtx", "(", "void", ")", "{", "return", "gen_frame_mem", "(", "HImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Implement", "`", "INCOMING_RETURN_ADDR_RTX", "'", "." ]

[ "avr", "1" ]

[]

[ "<s>", "bool", "EvexToVexInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasAVX512", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "Changed", "|=", "CompressEvexToVexImpl", "(", "MI", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MBlazeAsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "\"\\t.frame\\t\"", "+", "Twine", "(", "getRegisterName", "(", "stackReg", ")", ")", "+", "\",\"", "+", "Twine", "(", "stackSize", ")", "+", "\",\"", "+", "Twine", "(", "getRegisterName", "(", "returnReg", ")", ")", ")", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "MBlaze", "MBlaze", "\"\\t.frame\\t\"", "\",\"", "\",\"" ]

[]

[ "<s>", "static", "rtx", "s390_emit_compare_and_swap", "(", "enum", "rtx_code", "code", ",", "rtx", "old", ",", "rtx", "mem", ",", "rtx", "cmp", ",", "rtx", "new_rtx", ")", "{", "emit_insn", "(", "gen_atomic_compare_and_swapsi_internal", "(", "old", ",", "mem", ",", "cmp", ",", "new_rtx", ")", ")", ";", "return", "s390_emit_compare", "(", "code", ",", "gen_rtx_REG", "(", "CCZ1mode", ",", "CC_REGNUM", ")", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "a", "SImode", "compare", "and", "swap", "instruction", "setting", "MEM", "to", "NEW_RTX", "if", "OLD", "matches", "CMP", ".", "Return", "the", "correct", "condition", "RTL", "to", "be", "placed", "in", "the", "IF_THEN_ELSE", "of", "the", "conditional", "branch", "testing", "the", "result", "." ]

[ "s390" ]

[]

[ "<s>", "static", "int", "microblaze_must_save_register", "(", "int", "regno", ")", "{", "if", "(", "pic_offset_table_rtx", "&&", "(", "regno", "==", "MB_ABI_PIC_ADDR_REGNUM", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "1", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "return", "1", ";", "if", "(", "frame_pointer_needed", "&&", "(", "regno", "==", "HARD_FRAME_POINTER_REGNUM", ")", ")", "return", "1", ";", "if", "(", "!", "crtl", "->", "is_leaf", ")", "{", "if", "(", "regno", "==", "MB_ABI_SUB_RETURN_ADDR_REGNUM", ")", "return", "1", ";", "if", "(", "(", "microblaze_is_interrupt_variant", "(", ")", "||", "save_volatiles", ")", "&&", "(", "regno", ">=", "3", "&&", "regno", "<=", "12", ")", ")", "return", "1", ";", "}", "if", "(", "microblaze_is_interrupt_variant", "(", ")", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "regno", "==", "MB_ABI_MSR_SAVE_REG", "||", "(", "interrupt_handler", "&&", "(", "regno", "==", "MB_ABI_ASM_TEMP_REGNUM", "||", "regno", "==", "MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM", ")", ")", ")", "return", "1", ";", "}", "if", "(", "save_volatiles", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "regno", "==", "MB_ABI_ASM_TEMP_REGNUM", "||", "regno", "==", "MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Determine", "of", "register", "must", "be", "saved/restored", "in", "call", "." ]

[ "microblaze", "1", "1", "1", "1", "3", "12", "1", "1", "1", "0" ]

[]

[ "<s>", "static", "bool", "arc_cannot_force_const_mem", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "return", "!", "arc_legitimate_constant_p", "(", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "Determine", "if", "it", "'s", "legal", "to", "put", "X", "into", "the", "constant", "pool", "." ]

[ "arc" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createAArch64ExpandPseudoPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Optional", "<", "MCDisassembler", "::", "DecodeStatus", ">", "WebAssemblyDisassembler", "::", "onSymbolStart", "(", "SymbolInfoTy", "&", "Symbol", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "Size", "=", "0", ";", "if", "(", "Address", "==", "0", ")", "{", "int64_t", "FunctionCount", ";", "if", "(", "!", "nextLEB", "(", "FunctionCount", ",", "Bytes", ",", "Size", ",", "false", ")", ")", "return", "None", ";", "outs", "(", ")", "<<", "\" # \"", "<<", "FunctionCount", "<<", "\" functions in section.\"", ";", "}", "else", "{", "int64_t", "BodySize", ",", "LocalEntryCount", ";", "if", "(", "!", "nextLEB", "(", "BodySize", ",", "Bytes", ",", "Size", ",", "false", ")", "||", "!", "nextLEB", "(", "LocalEntryCount", ",", "Bytes", ",", "Size", ",", "false", ")", ")", "return", "None", ";", "if", "(", "LocalEntryCount", ")", "{", "outs", "(", ")", "<<", "\" .local \"", ";", "for", "(", "int64_t", "I", "=", "0", ";", "I", "<", "LocalEntryCount", ";", "I", "++", ")", "{", "int64_t", "Count", ",", "Type", ";", "if", "(", "!", "nextLEB", "(", "Count", ",", "Bytes", ",", "Size", ",", "false", ")", "||", "!", "nextLEB", "(", "Type", ",", "Bytes", ",", "Size", ",", "false", ")", ")", "return", "None", ";", "for", "(", "int64_t", "J", "=", "0", ";", "J", "<", "Count", ";", "J", "++", ")", "{", "if", "(", "I", "||", "J", ")", "outs", "(", ")", "<<", "\", \"", ";", "outs", "(", ")", "<<", "WebAssembly", "::", "anyTypeToString", "(", "Type", ")", ";", "}", "}", "}", "}", "outs", "(", ")", "<<", "\"\\n\"", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "</s>" ]

[ "Used", "to", "perform", "separate", "target", "specific", "disassembly", "for", "a", "particular", "symbol", "." ]

[ "WebAssembly", "WebAssembly", "0", "0", "\" # \"", "\" functions in section.\"", "\" .local \"", "0", "0", "\", \"", "WebAssembly::anyTypeToString", "\"\\n\"" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_mask_for_load", "(", "void", ")", "{", "if", "(", "TARGET_ALTIVEC", "||", "TARGET_VSX", ")", "return", "altivec_builtin_mask_for_load", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_mask_for_load", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "getTargetStreamer", "(", ")", "&&", "!", "getTargetStreamer", "(", ")", "->", "getTargetID", "(", ")", ")", "initializeTargetID", "(", "M", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDHSA", "&&", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDPAL", ")", "return", ";", "if", "(", "isHsaAbiVersion3Or4", "(", "getGlobalSTI", "(", ")", ")", ")", "getTargetStreamer", "(", ")", "->", "EmitDirectiveAMDGCNTarget", "(", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "HSAMetadataStream", "->", "begin", "(", "M", ",", "*", "getTargetStreamer", "(", ")", "->", "getTargetID", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDPAL", ")", "getTargetStreamer", "(", ")", "->", "getPALMetadata", "(", ")", "->", "readFromIR", "(", "M", ")", ";", "if", "(", "isHsaAbiVersion3Or4", "(", "getGlobalSTI", "(", ")", ")", ")", "return", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "getTargetStreamer", "(", ")", "->", "EmitDirectiveHSACodeObjectVersion", "(", "2", ",", "1", ")", ";", "IsaVersion", "Version", "=", "getIsaVersion", "(", "getGlobalSTI", "(", ")", "->", "getCPU", "(", ")", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitDirectiveHSACodeObjectISAV2", "(", "Version", ".", "Major", ",", "Version", ".", "Minor", ",", "Version", ".", "Stepping", ",", "\"AMD\"", ",", "\"AMDGPU\"", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "AMDGPU", "AMDGPU", "2", "1", "\"AMD\"", "\"AMDGPU\"" ]

[]

[ "<s>", "SDNode", "*", "MipsDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "nullptr", ";", "}", "std", "::", "pair", "<", "bool", ",", "SDNode", "*", ">", "Ret", "=", "selectNode", "(", "Node", ")", ";", "if", "(", "Ret", ".", "first", ")", "return", "Ret", ".", "second", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "assert", "(", "(", "Subtarget", ".", "systemSupportsUnalignedAccess", "(", ")", "||", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", "<=", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getAlignment", "(", ")", ")", "&&", "\"Unexpected unaligned loads/stores.\"", ")", ";", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "nullptr", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::GLOBAL_OFFSET_TABLE", "ISD::LOAD", "ISD::STORE", "8", "\"Unexpected unaligned loads/stores.\"", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "static", "bool", "mips_no_speculation_in_delay_slots_p", "(", ")", "{", "return", "TARGET_CB_MAYBE", ";", "}", "</s>" ]

[ "Implement", "TARGET_NO_SPECULATION_IN_DELAY_SLOTS_P", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "c4x_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.version\\t%d\\n\"", ",", "c4x_cpu_version", ")", ";", "fputs", "(", "\"\\n\\t.data\\ndata_sec:\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "We", "need", "to", "have", "a", "data", "section", "we", "can", "identify", "so", "that", "we", "can", "set", "the", "DP", "register", "back", "to", "a", "data", "pointer", "in", "the", "small", "memory", "model", ".", "This", "is", "only", "required", "for", "ISRs", "if", "we", "are", "paranoid", "that", "someone", "may", "have", "quietly", "changed", "this", "register", "on", "the", "sly", "." ]

[ "c4x", "\"\\t.version\\t%d\\n\"", "\"\\n\\t.data\\ndata_sec:\\n\"" ]

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Advance cycle, clear state\\n\"", ")", ";", "Resources", "->", "clearResources", "(", ")", ";", "if", "(", "DotCurPNum", "!=", "-", "1", "&&", "DotCurPNum", "!=", "(", "int", ")", "PacketNum", ")", "{", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "}", "UsesLoad", "=", "false", ";", "PrefVectorStoreNew", "=", "nullptr", ";", "PacketNum", "++", ";", "RegDefs", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "Hexagon", "Hexagon", "\"Advance cycle, clear state\\n\"", "1", "1" ]

[]

[ "<s>", "bool", "MipsTargetELFStreamer", "::", "emitDirectiveCpRestore", "(", "int", "Offset", ",", "function_ref", "<", "unsigned", "(", ")", ">", "GetATReg", ",", "SMLoc", "IDLoc", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "{", "MipsTargetStreamer", "::", "emitDirectiveCpRestore", "(", "Offset", ",", "GetATReg", ",", "IDLoc", ",", "STI", ")", ";", "if", "(", "!", "Pic", "||", "(", "getABI", "(", ")", ".", "IsN32", "(", ")", "||", "getABI", "(", ")", ".", "IsN64", "(", ")", ")", ")", "return", "true", ";", "emitStoreWithImmOffset", "(", "Mips", "::", "SW", ",", "Mips", "::", "GP", ",", "Mips", "::", "SP", ",", "Offset", ",", "GetATReg", ",", "IDLoc", ",", "STI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "a", ".cprestore", "directive", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorClearMaskLegal", "(", "ArrayRef", "<", "int", ">", "Mask", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasAVX2", "(", ")", ")", "if", "(", "VT", "==", "MVT", "::", "v32i8", "||", "VT", "==", "MVT", "::", "v16i16", ")", "return", "false", ";", "return", "isShuffleMaskLegal", "(", "Mask", ",", "VT", ")", ";", "}", "</s>" ]

[ "Similar", "to", "isShuffleMaskLegal", "." ]

[ "X86", "X86", "MVT::v32i8", "MVT::v16i16" ]

[]

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

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

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

[]

[ "<s>", "AVRTargetLowering", "::", "ConstraintType", "AVRTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'a'", ":", "case", "'b'", ":", "case", "'d'", ":", "case", "'l'", ":", "case", "'e'", ":", "case", "'q'", ":", "case", "'r'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'t'", ":", "case", "'x'", ":", "case", "'X'", ":", "case", "'y'", ":", "case", "'Y'", ":", "case", "'z'", ":", "case", "'Z'", ":", "return", "C_Register", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "case", "'G'", ":", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "case", "'R'", ":", "return", "C_Immediate", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "1", "0" ]

[]

[ "<s>", "static", "bool", "prologue_saved_reg_p", "(", "unsigned", "regno", ")", "{", "gcc_assert", "(", "GP_REG_P", "(", "regno", ")", ")", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "regno", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "return", "true", ";", "if", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "crtl", "->", "uses_pic_offset_table", ")", "return", "true", ";", "if", "(", "regno", "==", "RA_REGNO", "&&", "df_regs_ever_live_p", "(", "RA_REGNO", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "REGNO", "should", "be", "saved", "in", "the", "prologue", "." ]

[ "nios2" ]

[]

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

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

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

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableARMLoadStoreOpt", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "addPass", "(", "new", "ARMExecutionDepsFix", "(", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ".", "restrictIT", "(", ")", ";", "}", ")", ")", ";", "addPass", "(", "createIfConverter", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "!", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "}", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MSP430", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "MSP430", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other", "0" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"[\"", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "\"unexpected inline asm memory operand\"", "\"[\"", "AArch64", "\"]\"" ]

[]

[ "<s>", "static", "void", "arm_elf_asm_constructor", "(", "rtx", "symbol", ",", "int", "priority", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "TARGET_AAPCS_BASED", ")", "{", "default_named_section_asm_out_constructor", "(", "symbol", ",", "priority", ")", ";", "return", ";", "}", "ctors_section", "(", ")", ";", "assemble_align", "(", "POINTER_SIZE", ")", ";", "fputs", "(", "\"\\t.word\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "symbol", ")", ";", "fputs", "(", "\"(target1)\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Add", "a", "function", "to", "the", "list", "of", "static", "constructors", "." ]

[ "arm", "\"\\t.word\\t\"", "\"(target1)\\n\"" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "initializeSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", ";", "PPCFunctionInfo", "*", "PFI", "=", "Entry", "->", "getParent", "(", ")", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "PFI", "->", "setIsSplitCSR", "(", "true", ")", ";", "}", "</s>" ]

[ "Perform", "necessary", "initialization", "to", "handle", "a", "subset", "of", "CSRs", "explicitly", "via", "copies", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "VESubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "VE", "VE" ]

[]

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

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

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

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldSinkOperands", "(", "Instruction", "*", "I", ",", "SmallVectorImpl", "<", "Use", "*", ">", "&", "Ops", ")", "const", "{", "if", "(", "!", "I", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "if", "(", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "I", ")", ")", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "aarch64_neon_umull", ":", "if", "(", "!", "areExtractShuffleVectors", "(", "II", "->", "getOperand", "(", "0", ")", ",", "II", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "Ops", ".", "push_back", "(", "&", "II", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "II", "->", "getOperandUse", "(", "1", ")", ")", ";", "return", "true", ";", "case", "Intrinsic", "::", "aarch64_neon_pmull64", ":", "if", "(", "!", "areOperandsOfVmullHighP64", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "II", "->", "getArgOperand", "(", "1", ")", ")", ")", "return", "false", ";", "Ops", ".", "push_back", "(", "&", "II", "->", "getArgOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "II", "->", "getArgOperandUse", "(", "1", ")", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Add", ":", "{", "if", "(", "!", "areExtractExts", "(", "I", "->", "getOperand", "(", "0", ")", ",", "I", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "auto", "Ext1", "=", "cast", "<", "Instruction", ">", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "auto", "Ext2", "=", "cast", "<", "Instruction", ">", "(", "I", "->", "getOperand", "(", "1", ")", ")", ";", "if", "(", "areExtractShuffleVectors", "(", "Ext1", ",", "Ext2", ")", ")", "{", "Ops", ".", "push_back", "(", "&", "Ext1", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "Ext2", "->", "getOperandUse", "(", "0", ")", ")", ";", "}", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "1", ")", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "sinking", "I", "'s", "operands", "to", "the", "same", "basic", "block", "as", "I", "is", "profitable", ",", "e.g", "." ]

[ "AArch64", "AArch64", "Intrinsic::aarch64_neon_umull", "0", "1", "0", "1", "Intrinsic::aarch64_neon_pmull64", "0", "1", "0", "1", "0", "1", "0", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "Cpu0InstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "'$'", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "Z80oldTargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "8", ">", "(", "Imm", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "8" ]

[]

[ "<s>", "bool", "HexagonConstEvaluator", "::", "evaluate", "(", "const", "MachineInstr", "&", "BrI", ",", "const", "CellMap", "&", "Inputs", ",", "SetVector", "<", "const", "MachineBasicBlock", "*", ">", "&", "Targets", ",", "bool", "&", "FallsThru", ")", "{", "unsigned", "Opc", "=", "BrI", ".", "getOpcode", "(", ")", ";", "bool", "SimpleBranch", "=", "false", ";", "bool", "Negated", "=", "false", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "J2_jumpf", ":", "case", "Hexagon", "::", "J2_jumpfnew", ":", "case", "Hexagon", "::", "J2_jumpfnewpt", ":", "Negated", "=", "true", ";", "case", "Hexagon", "::", "J2_jumpt", ":", "case", "Hexagon", "::", "J2_jumptnew", ":", "case", "Hexagon", "::", "J2_jumptnewpt", ":", "SimpleBranch", "=", "true", ";", "break", ";", "case", "Hexagon", "::", "J2_jump", ":", "Targets", ".", "insert", "(", "BrI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ";", "FallsThru", "=", "false", ";", "return", "true", ";", "default", ":", "Undetermined", ":", "FallsThru", "=", "!", "BrI", ".", "isUnconditionalBranch", "(", ")", ";", "return", "false", ";", "}", "if", "(", "SimpleBranch", ")", "{", "const", "MachineOperand", "&", "MD", "=", "BrI", ".", "getOperand", "(", "0", ")", ";", "Register", "PR", "(", "MD", ")", ";", "if", "(", "PR", ".", "SubReg", ")", "goto", "Undetermined", ";", "assert", "(", "Inputs", ".", "has", "(", "PR", ".", "Reg", ")", ")", ";", "const", "LatticeCell", "&", "PredC", "=", "Inputs", ".", "get", "(", "PR", ".", "Reg", ")", ";", "if", "(", "PredC", ".", "isBottom", "(", ")", ")", "goto", "Undetermined", ";", "uint32_t", "Props", "=", "PredC", ".", "properties", "(", ")", ";", "bool", "CTrue", "=", "false", ",", "CFalse", "=", "false", ";", "if", "(", "Props", "&", "ConstantProperties", "::", "Zero", ")", "CFalse", "=", "true", ";", "else", "if", "(", "Props", "&", "ConstantProperties", "::", "NonZero", ")", "CTrue", "=", "true", ";", "if", "(", "!", "CTrue", "&&", "!", "CFalse", ")", "goto", "Undetermined", ";", "const", "MachineBasicBlock", "*", "BranchTarget", "=", "BrI", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "FallsThru", "=", "false", ";", "if", "(", "(", "!", "Negated", "&&", "CTrue", ")", "||", "(", "Negated", "&&", "CFalse", ")", ")", "Targets", ".", "insert", "(", "BranchTarget", ")", ";", "else", "if", "(", "(", "!", "Negated", "&&", "CFalse", ")", "||", "(", "Negated", "&&", "CTrue", ")", ")", "FallsThru", "=", "true", ";", "else", "goto", "Undetermined", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "evaluate", "-", "Evaluate", "Expr", "and", "append", "the", "resulting", "set", "to", "Elts", "." ]

[ "Hexagon", "Hexagon", "Hexagon::J2_jumpf", "Hexagon::J2_jumpfnew", "Hexagon::J2_jumpfnewpt", "Hexagon::J2_jumpt", "Hexagon::J2_jumptnew", "Hexagon::J2_jumptnewpt", "Hexagon::J2_jump", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "rs6000_debug_secondary_memory_needed", "(", "enum", "reg_class", "from_class", ",", "enum", "reg_class", "to_class", ",", "machine_mode", "mode", ")", "{", "bool", "ret", "=", "rs6000_secondary_memory_needed", "(", "from_class", ",", "to_class", ",", "mode", ")", ";", "fprintf", "(", "stderr", ",", "\"rs6000_secondary_memory_needed, return: %s, from_class = %s, \"", "\"to_class = %s, mode = %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ",", "reg_class_names", "[", "from_class", "]", ",", "reg_class_names", "[", "to_class", "]", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_secondary_memory_needed", "." ]

[ "rs6000", "\"rs6000_secondary_memory_needed, return: %s, from_class = %s, \"", "\"to_class = %s, mode = %s\\n\"", "\"true\"", "\"false\"" ]

[]

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

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

[ "FISC" ]

[]

[ "<s>", "int", "arm_const_double_inline_cost", "(", "rtx", "val", ")", "{", "rtx", "lowpart", ",", "highpart", ";", "enum", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "val", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "DImode", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ";", "lowpart", "=", "gen_lowpart", "(", "SImode", ",", "val", ")", ";", "highpart", "=", "gen_highpart_mode", "(", "SImode", ",", "mode", ",", "val", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "lowpart", ")", "==", "CONST_INT", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "highpart", ")", "==", "CONST_INT", ")", ";", "return", "(", "arm_gen_constant", "(", "SET", ",", "SImode", ",", "NULL_RTX", ",", "INTVAL", "(", "lowpart", ")", ",", "NULL_RTX", ",", "NULL_RTX", ",", "0", ",", "0", ")", "+", "arm_gen_constant", "(", "SET", ",", "SImode", ",", "NULL_RTX", ",", "INTVAL", "(", "highpart", ")", ",", "NULL_RTX", ",", "NULL_RTX", ",", "0", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "synthesizing", "a", "64-bit", "constant", "VAL", "inline", ".", "Returns", "the", "number", "of", "insns", "needed", ",", "or", "99", "if", "we", "do", "n't", "know", "how", "to", "do", "it", "." ]

[ "arm", "8", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "unsigned", "riscv_save_libcall_count", "(", "unsigned", "mask", ")", "{", "for", "(", "unsigned", "n", "=", "GP_REG_LAST", ";", "n", ">", "GP_REG_FIRST", ";", "n", "--", ")", "if", "(", "BITSET_P", "(", "mask", ",", "n", ")", ")", "return", "CALLEE_SAVED_REG_NUMBER", "(", "n", ")", "+", "1", ";", "abort", "(", ")", ";", "}", "</s>" ]

[ "Determine", "which", "GPR", "save/restore", "routine", "to", "call", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "bool", "SPIRVPreTranslationLegalizer", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "std", "::", "vector", "<", "Function", "*", ">", "FuncsWorklist", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "F", ":", "M", ")", "FuncsWorklist", ".", "push_back", "(", "&", "F", ")", ";", "for", "(", "auto", "*", "Func", ":", "FuncsWorklist", ")", "{", "auto", "*", "F", "=", "processFunctionSignature", "(", "Func", ")", ";", "bool", "CreatedNewF", "=", "F", "!=", "Func", ";", "if", "(", "Func", "->", "isDeclaration", "(", ")", ")", "{", "Changed", "|=", "CreatedNewF", ";", "continue", ";", "}", "if", "(", "CreatedNewF", ")", "Func", "->", "eraseFromParent", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV" ]

[]

[ "<s>", "bool", "TPCTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AddrSpace", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseOffs", "&&", "!", "(", "Subtarget", "->", "getFeatureBits", "(", ")", "[", "TPC", "::", "FeatureAddr2", "]", "&&", "AddrSpace", "==", "LOCAL_VECTOR", ")", ")", "return", "false", ";", "break", ";", "case", "2", ":", "if", "(", "AM", ".", "HasBaseReg", "||", "AM", ".", "BaseOffs", ")", "return", "false", ";", "if", "(", "!", "Subtarget", "->", "getFeatureBits", "(", ")", "[", "TPC", "::", "FeatureAddr2", "]", "||", "AddrSpace", "!=", "LOCAL_VECTOR", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "0", "1", "TPC::FeatureAddr2", "2", "TPC::FeatureAddr2" ]

[]

[ "<s>", "void", "ix86_expand_trunc", "(", "rtx", "operand0", ",", "rtx", "operand1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "xa", ",", "xi", ",", "TWO52", ",", "res", ",", "mask", ";", "rtx_code_label", "*", "label", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "res", "=", "copy_to_reg", "(", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "mask", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "xi", "=", "gen_reg_rtx", "(", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ")", ";", "expand_fix", "(", "xi", ",", "res", ",", "0", ")", ";", "expand_float", "(", "xa", ",", "xi", ",", "0", ")", ";", "if", "(", "HONOR_SIGNED_ZEROS", "(", "mode", ")", ")", "ix86_sse_copysign_to_positive", "(", "xa", ",", "xa", ",", "res", ",", "mask", ")", ";", "emit_move_insn", "(", "res", ",", "xa", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "SSE", "sequence", "for", "computing", "trunc", "from", "OPERAND1", "storing", "into", "OPERAND0", "." ]

[ "i386", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "pru_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "!", "frame_pointer_needed", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_ELIMINATE", "." ]

[ "pru" ]

[]

[ "<s>", "bool", "mprocInstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "MI", "->", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "isBranch", "(", ")", "&&", "!", "MI", "->", "isBarrier", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MI", "->", "isPredicable", "(", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "mproc", "mproc" ]

[]

[ "<s>", "static", "int", "write_arg_type", "(", "std", "::", "stringstream", "&", "s", ",", "int", "for_reg", ",", "int", "argno", ",", "tree", "type", ",", "bool", "prototyped", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "argno", ";", "if", "(", "pass_in_memory", "(", "mode", ",", "type", ",", "false", ")", ")", "mode", "=", "Pmode", ";", "else", "{", "bool", "split", "=", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ";", "if", "(", "split", ")", "{", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "prototyped", "=", "true", ";", "}", "mode", "=", "promote_arg", "(", "mode", ",", "prototyped", ")", ";", "if", "(", "split", ")", "argno", "=", "write_arg_mode", "(", "s", ",", "for_reg", ",", "argno", ",", "mode", ")", ";", "}", "return", "write_arg_mode", "(", "s", ",", "for_reg", ",", "argno", ",", "mode", ")", ";", "}", "</s>" ]

[ "Process", "function", "parameter", "TYPE", "to", "emit", "one", "or", "more", "PTX", "arguments", ".", "S", ",", "FOR_REG", "and", "ARGNO", "as", "for", "write_arg_mode", ".", "PROTOTYPED", "is", "true", ",", "if", "this", "is", "a", "prototyped", "function", ",", "rather", "than", "an", "old-style", "C", "declaration", ".", "Returns", "the", "next", "argument", "number", "to", "use", ".", "The", "promotion", "behavior", "here", "must", "match", "the", "regular", "GCC", "function", "parameter", "marshalling", "machinery", "." ]

[ "nvptx" ]

[]

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

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

[ "TPC", "TPC", "TPC::NumTargetFixupKinds" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "int", "PIdx", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", "{", "MI", ".", "getOperand", "(", "8", ")", ".", "setImm", "(", "0", ")", ";", "return", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "DOT_4", ")", "{", "MI", ".", "getOperand", "(", "getOperandIdx", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "pred_sel_X", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "getOperandIdx", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "pred_sel_Y", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "getOperandIdx", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "pred_sel_Z", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "getOperandIdx", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "pred_sel_W", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "MIB", ".", "addReg", "(", "AMDGPU", "::", "PREDICATE_BIT", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "PIdx", "!=", "-", "1", ")", "{", "MachineOperand", "&", "PMO", "=", "MI", ".", "getOperand", "(", "PIdx", ")", ";", "PMO", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "MIB", ".", "addReg", "(", "AMDGPU", "::", "PREDICATE_BIT", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "AMDGPU", "R600", "AMDGPU::CF_ALU", "8", "0", "AMDGPU::DOT_4", "AMDGPU::OpName", "2", "AMDGPU::OpName", "2", "AMDGPU::OpName", "2", "AMDGPU::OpName", "2", "AMDGPU::PREDICATE_BIT", "1", "2", "AMDGPU::PREDICATE_BIT" ]

[]

[ "<s>", "void", "nvptx_expand_oacc_fork", "(", "unsigned", "mode", ")", "{", "nvptx_emit_forking", "(", "GOMP_DIM_MASK", "(", "mode", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "Expand", "the", "oacc", "fork", "&", "join", "primitive", "into", "ptx-required", "unspecs", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "isPredicate", "(", ")", "const", "{", "return", "Kind", "==", "OpKind", "::", "Predicate", ";", "}", "</s>" ]

[ "Set", "if", "this", "is", "one", "of", "the", "operands", "that", "made", "up", "of", "the", "predicate", "operand", "that", "controls", "an", "isPredicable", "(", ")", "instruction", "." ]

[ "TPC" ]

[]

[ "<s>", "rtx", "alpha_emit_setcc", "(", "enum", "rtx_code", "code", ")", "{", "enum", "rtx_code", "cmp_code", ";", "rtx", "op0", "=", "alpha_compare", ".", "op0", ",", "op1", "=", "alpha_compare", ".", "op1", ";", "int", "fp_p", "=", "alpha_compare", ".", "fp_p", ";", "rtx", "tmp", ";", "memset", "(", "&", "alpha_compare", ",", "0", ",", "sizeof", "(", "alpha_compare", ")", ")", ";", "if", "(", "fp_p", "&&", "GET_MODE", "(", "op0", ")", "==", "TFmode", ")", "{", "op0", "=", "alpha_emit_xfloating_compare", "(", "&", "code", ",", "op0", ",", "op1", ")", ";", "op1", "=", "const0_rtx", ";", "fp_p", "=", "0", ";", "}", "if", "(", "fp_p", "&&", "!", "TARGET_FIX", ")", "return", "NULL_RTX", ";", "cmp_code", "=", "UNKNOWN", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "case", "UNORDERED", ":", "if", "(", "fp_p", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "break", ";", "case", "NE", ":", "if", "(", "!", "fp_p", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "reverse_condition", "(", "code", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "if", "(", "!", "fp_p", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "fp_p", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "fp_p", ")", "{", "if", "(", "!", "register_operand", "(", "op0", ",", "DImode", ")", ")", "op0", "=", "force_reg", "(", "DImode", ",", "op0", ")", ";", "if", "(", "!", "reg_or_8bit_operand", "(", "op1", ",", "DImode", ")", ")", "op1", "=", "force_reg", "(", "DImode", ",", "op1", ")", ";", "}", "if", "(", "cmp_code", "!=", "UNKNOWN", ")", "{", "enum", "machine_mode", "mode", "=", "fp_p", "?", "DFmode", ":", "DImode", ";", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_fmt_ee", "(", "cmp_code", ",", "mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "op0", "=", "fp_p", "?", "gen_lowpart", "(", "DImode", ",", "tmp", ")", ":", "tmp", ";", "op1", "=", "const0_rtx", ";", "}", "return", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "op0", ",", "op1", ")", ";", "}", "</s>" ]

[ "Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "." ]

[ "alpha", "0", "0" ]

[]

[ "<s>", "void", "split_subsi", "(", "rtx", "*", "operands", ")", "{", "int", "val", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "satisfies_constraint_Rcq", "(", "operands", "[", "0", "]", ")", "&&", "satisfies_constraint_Rcq", "(", "operands", "[", "2", "]", ")", ")", "{", "if", "(", "val", ">=", "-", "31", "&&", "val", "<=", "127", ")", "{", "operands", "[", "3", "]", "=", "gen_rtx_NEG", "(", "SImode", ",", "operands", "[", "2", "]", ")", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "return", ";", "}", "else", "if", "(", "val", ">=", "0", "&&", "val", "<", "255", ")", "{", "operands", "[", "3", "]", "=", "operands", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_MINUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "return", ";", "}", "}", "operands", "[", "3", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_MINUS", "(", "SImode", ",", "operands", "[", "1", "]", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "nds32_legitimate_index_p", "(", "machine_mode", "outer_mode", ",", "rtx", "index", ",", "bool", "strict", ")", "{", "int", "regno", ";", "rtx", "op0", ";", "rtx", "op1", ";", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "REG", ":", "regno", "=", "REGNO", "(", "index", ")", ";", "if", "(", "strict", ")", "return", "REGNO_OK_FOR_INDEX_P", "(", "regno", ")", ";", "else", "return", "true", ";", "case", "CONST_INT", ":", "switch", "(", "GET_MODE_SIZE", "(", "outer_mode", ")", ")", "{", "case", "1", ":", "if", "(", "satisfies_constraint_Is15", "(", "index", ")", ")", "return", "true", ";", "break", ";", "case", "2", ":", "if", "(", "satisfies_constraint_Is16", "(", "index", ")", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "strict_aligned_p", ")", "return", "true", ";", "else", "if", "(", "NDS32_HALF_WORD_ALIGN_P", "(", "INTVAL", "(", "index", ")", ")", ")", "return", "true", ";", "}", "break", ";", "case", "4", ":", "if", "(", "satisfies_constraint_Is17", "(", "index", ")", ")", "{", "if", "(", "(", "TARGET_FPU_SINGLE", "||", "TARGET_FPU_DOUBLE", ")", ")", "{", "if", "(", "!", "satisfies_constraint_Is14", "(", "index", ")", ")", "return", "false", ";", "}", "if", "(", "!", "cfun", "->", "machine", "->", "strict_aligned_p", ")", "return", "true", ";", "else", "if", "(", "NDS32_SINGLE_WORD_ALIGN_P", "(", "INTVAL", "(", "index", ")", ")", ")", "return", "true", ";", "}", "break", ";", "case", "8", ":", "if", "(", "satisfies_constraint_Is17", "(", "gen_int_mode", "(", "INTVAL", "(", "index", ")", "+", "4", ",", "SImode", ")", ")", ")", "{", "if", "(", "(", "TARGET_FPU_SINGLE", "||", "TARGET_FPU_DOUBLE", ")", ")", "{", "if", "(", "!", "satisfies_constraint_Is14", "(", "index", ")", ")", "return", "false", ";", "}", "if", "(", "!", "cfun", "->", "machine", "->", "strict_aligned_p", ")", "return", "true", ";", "else", "if", "(", "NDS32_SINGLE_WORD_ALIGN_P", "(", "INTVAL", "(", "index", ")", ")", ")", "return", "true", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "return", "false", ";", "case", "MULT", ":", "op0", "=", "XEXP", "(", "index", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "index", ",", "1", ")", ";", "if", "(", "REG_P", "(", "op0", ")", "&&", "CONST_INT_P", "(", "op1", ")", ")", "{", "int", "multiplier", ";", "multiplier", "=", "INTVAL", "(", "op1", ")", ";", "if", "(", "multiplier", "!=", "1", "&&", "multiplier", "!=", "2", "&&", "multiplier", "!=", "4", "&&", "multiplier", "!=", "8", ")", "return", "false", ";", "regno", "=", "REGNO", "(", "op0", ")", ";", "if", "(", "strict", ")", "return", "REGNO_OK_FOR_INDEX_P", "(", "regno", ")", ";", "else", "return", "true", ";", "}", "return", "false", ";", "case", "ASHIFT", ":", "op0", "=", "XEXP", "(", "index", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "index", ",", "1", ")", ";", "if", "(", "REG_P", "(", "op0", ")", "&&", "CONST_INT_P", "(", "op1", ")", ")", "{", "int", "sv", ";", "sv", "=", "INTVAL", "(", "op1", ")", ";", "if", "(", "sv", "!=", "0", "&&", "sv", "!=", "1", "&&", "sv", "!=", "2", "&&", "sv", "!=", "3", ")", "return", "false", ";", "regno", "=", "REGNO", "(", "op0", ")", ";", "if", "(", "strict", ")", "return", "REGNO_OK_FOR_INDEX_P", "(", "regno", ")", ";", "else", "return", "true", ";", "}", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Function", "that", "check", "if", "'INDEX", "'", "is", "valid", "to", "be", "a", "index", "rtx", "for", "address", ".", "OUTER_MODE", ":", "Machine", "mode", "of", "outer", "address", "rtx", ".", "INDEX", ":", "Check", "if", "this", "rtx", "is", "valid", "to", "be", "a", "index", "for", "address", ".", "STRICT", ":", "If", "it", "is", "true", ",", "we", "are", "in", "reload", "pass", "or", "after", "reload", "pass", "." ]

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

[]

[ "<s>", "static", "void", "s390_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "{", "if", "(", "DECL_USER_ALIGN", "(", "decl", ")", "&&", "DECL_ALIGN", "(", "decl", ")", "<", "16", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "SYMBOL_FLAG_ALIGN1", ";", "if", "(", "!", "DECL_SIZE", "(", "decl", ")", "||", "!", "DECL_ALIGN", "(", "decl", ")", "||", "!", "tree_fits_shwi_p", "(", "DECL_SIZE", "(", "decl", ")", ")", "||", "(", "DECL_ALIGN", "(", "decl", ")", "<=", "64", "&&", "DECL_ALIGN", "(", "decl", ")", "!=", "tree_to_shwi", "(", "DECL_SIZE", "(", "decl", ")", ")", ")", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "SYMBOL_FLAG_NOT_NATURALLY_ALIGNED", ";", "}", "if", "(", "MEM_P", "(", "rtl", ")", "&&", "GET_CODE", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "TREE_CONSTANT_POOL_ADDRESS_P", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "&&", "(", "MEM_ALIGN", "(", "rtl", ")", "==", "0", "||", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "rtl", ")", ")", "==", "0", "||", "MEM_ALIGN", "(", "rtl", ")", "<", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "rtl", ")", ")", ")", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "SYMBOL_FLAG_NOT_NATURALLY_ALIGNED", ";", "}", "</s>" ]

[ "Encode", "symbol", "attributes", "(", "local", "vs.", "global", ",", "tls", "model", ")", "of", "a", "SYMBOL_REF", "into", "its", "SYMBOL_REF_FLAGS", "." ]

[ "s390", "16", "0", "64", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", "{", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "FrameIdx", "=", "0", ";", "else", "{", "const", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "FrameIdx", "=", "FI", "->", "getCRSpillFrameIndex", "(", ")", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC::CR2", "PPC::CR4", "PPC", "0", "PPC", "PPC" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_vcond_mask_insn", "(", "insn_code", "icode", ",", "unsigned", "int", "merge_argno", ")", "{", "machine_mode", "mode", "=", "vector_mode", "(", "0", ")", ";", "unsigned", "int", "opno", "=", "0", ";", "rtx", "false_arg", "=", "get_fallback_value", "(", "mode", ",", "1", ",", "merge_argno", ",", "opno", ")", ";", "rtx", "pred_arg", "=", "args", "[", "opno", "++", "]", ";", "rtx", "true_arg", "=", "args", "[", "opno", "++", "]", ";", "add_output_operand", "(", "icode", ")", ";", "add_input_operand", "(", "icode", ",", "true_arg", ")", ";", "add_input_operand", "(", "icode", ",", "false_arg", ")", ";", "add_input_operand", "(", "icode", ",", "pred_arg", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "which", "is", "a", "select-like", "operation", "with", "the", "following", "operands", ":", "0", ":", "output", "1", ":", "true", "value", "2", ":", "false", "value", "3", ":", "predicate", "MERGE_ARGNO", "is", "the", "argument", "that", "provides", "the", "``", "false", "''", "value", "for", "_m", "functions", ",", "or", "DEFAULT_MERGE_ARGNO", "if", "we", "should", "apply", "the", "usual", "rules", "." ]

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

[]

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

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

[ "Mips", "Mips", "Mips" ]

[]

[ "<s>", "const", "char", "*", "sh_symbian_strip_name_encoding", "(", "const", "char", "*", "name", ")", "{", "int", "skip", ";", "while", "(", "(", "skip", "=", "sh_symbian_get_strip_length", "(", "*", "name", ")", ")", ")", "name", "+=", "skip", ";", "return", "name", ";", "}", "</s>" ]

[ "Return", "a", "pointer", "to", "a", "function", "'s", "name", "with", "any", "and", "all", "prefix", "encodings", "stripped", "from", "it", "." ]

[ "sh" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DT", "=", "&", "getAnalysis", "<", "DominatorTree", ">", "(", ")", ";", "for", "(", "df_iterator", "<", "BasicBlock", "*", ">", "I", "=", "df_begin", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ",", "E", "=", "df_end", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BranchInst", "*", "Term", "=", "dyn_cast", "<", "BranchInst", ">", "(", "(", "*", "I", ")", "->", "getTerminator", "(", ")", ")", ";", "if", "(", "!", "Term", "||", "Term", "->", "isUnconditional", "(", ")", ")", "{", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "closeControlFlow", "(", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", ".", "nodeVisited", "(", "Term", "->", "getSuccessor", "(", "1", ")", ")", ")", "{", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "closeControlFlow", "(", "*", "I", ")", ";", "handleLoop", "(", "Term", ")", ";", "continue", ";", "}", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "{", "PHINode", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "Term", "->", "getCondition", "(", ")", ")", ";", "if", "(", "Phi", "&&", "Phi", "->", "getParent", "(", ")", "==", "*", "I", "&&", "isElse", "(", "Phi", ")", ")", "{", "insertElse", "(", "Term", ")", ";", "eraseIfUnused", "(", "Phi", ")", ";", "continue", ";", "}", "closeControlFlow", "(", "*", "I", ")", ";", "}", "openIf", "(", "Term", ")", ";", "}", "assert", "(", "Stack", ".", "empty", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "pa_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "!=", "GET_MODE_CLASS", "(", "mode2", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "it", "is", "a", "good", "idea", "to", "tie", "two", "pseudo", "registers", "when", "one", "has", "mode", "MODE1", "and", "one", "has", "mode", "MODE2", ".", "If", "HARD_REGNO_MODE_OK", "could", "produce", "different", "values", "for", "MODE1", "and", "MODE2", ",", "for", "any", "hard", "reg", ",", "then", "this", "must", "be", "FALSE", "for", "correct", "output", ".", "We", "should", "return", "FALSE", "for", "QImode", "and", "HImode", "because", "these", "modes", "are", "not", "ok", "in", "the", "floating-point", "registers", ".", "However", ",", "this", "prevents", "tieing", "these", "modes", "to", "SImode", "and", "DImode", "in", "the", "general", "registers", ".", "So", ",", "this", "is", "n't", "a", "good", "idea", ".", "We", "rely", "on", "HARD_REGNO_MODE_OK", "and", "CANNOT_CHANGE_MODE_CLASS", "to", "prevent", "these", "modes", "from", "being", "used", "in", "the", "floating-point", "registers", "." ]

[ "pa" ]

[]

[ "<s>", "bool", "Z80TargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "0", "1" ]

[]

[ "<s>", "static", "void", "nios2_handle_custom_fpu_insn_option", "(", "int", "fpu_insn_index", ")", "{", "int", "param", "=", "N2FPU_N", "(", "fpu_insn_index", ")", ";", "if", "(", "param", ">=", "0", "&&", "param", "<=", "255", ")", "nios2_register_custom_code", "(", "param", ",", "CCS_FPU", ",", "fpu_insn_index", ")", ";", "else", "if", "(", "param", "!=", "-", "1", ")", "error", "(", "\"switch %<-mcustom-%s%> value %d must be between 0 and 255\"", ",", "N2FPU_NAME", "(", "fpu_insn_index", ")", ",", "param", ")", ";", "}", "</s>" ]

[ "Check", "individual", "FPU", "insn", "options", ",", "and", "register", "custom", "code", "." ]

[ "nios2", "0", "255", "1", "\"switch %<-mcustom-%s%> value %d must be between 0 and 255\"" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "X86RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "RegInfo", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "RegInfo", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "getFrameIndexOffset", "(", "MF", ",", "FI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "tree", "xstormy16_build_va_list", "(", ")", "{", "tree", "f_1", ",", "f_2", ",", "record", ",", "type_decl", ";", "record", "=", "make_lang_type", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_1", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"base\"", ")", ",", "ptr_type_node", ")", ";", "f_2", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"count\"", ")", ",", "unsigned_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_1", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_2", ")", "=", "record", ";", "TREE_CHAIN", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_1", ";", "TREE_CHAIN", "(", "f_1", ")", "=", "f_2", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "</s>" ]

[ "Build", "the", "va_list", "type", ".", "For", "this", "chip", ",", "va_list", "is", "a", "record", "containing", "a", "counter", "and", "a", "pointer", ".", "The", "counter", "is", "of", "type", "'int", "'", "and", "indicates", "how", "many", "bytes", "have", "been", "used", "to", "date", ".", "The", "pointer", "indicates", "the", "stack", "position", "for", "arguments", "that", "have", "not", "been", "passed", "in", "registers", ".", "To", "keep", "the", "layout", "nice", ",", "the", "pointer", "is", "first", "in", "the", "structure", "." ]

[ "stormy16", "\"__va_list_tag\"", "\"base\"", "\"count\"" ]

[]

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

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

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

[]

[ "<s>", "tree", "s390_valid_target_attribute_tree", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ",", "const", "struct", "gcc_options", "*", "opts_set", ",", "bool", "force_pragma", ")", "{", "tree", "t", "=", "NULL_TREE", ";", "struct", "gcc_options", "new_opts_set", ";", "memset", "(", "&", "new_opts_set", ",", "0", ",", "sizeof", "(", "new_opts_set", ")", ")", ";", "if", "(", "!", "s390_valid_target_attribute_inner_p", "(", "args", ",", "opts", ",", "&", "new_opts_set", ",", "force_pragma", ")", ")", "return", "error_mark_node", ";", "if", "(", "new_opts_set", ".", "x_target_flags", "||", "new_opts_set", ".", "x_s390_arch", "||", "new_opts_set", ".", "x_s390_tune", "||", "new_opts_set", ".", "x_s390_stack_guard", "||", "new_opts_set", ".", "x_s390_stack_size", "||", "new_opts_set", ".", "x_s390_branch_cost", "||", "new_opts_set", ".", "x_s390_warn_framesize", "||", "new_opts_set", ".", "x_s390_warn_dynamicstack_p", ")", "{", "const", "unsigned", "char", "*", "src", "=", "(", "const", "unsigned", "char", "*", ")", "opts_set", ";", "unsigned", "char", "*", "dest", "=", "(", "unsigned", "char", "*", ")", "&", "new_opts_set", ";", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "*", "opts_set", ")", ";", "i", "++", ")", "dest", "[", "i", "]", "|=", "src", "[", "i", "]", ";", "s390_option_override_internal", "(", "false", ",", "opts", ",", "&", "new_opts_set", ")", ";", "t", "=", "build_target_option_node", "(", "opts", ")", ";", "}", "return", "t", ";", "}", "</s>" ]

[ "Return", "a", "TARGET_OPTION_NODE", "tree", "of", "the", "target", "options", "listed", "or", "NULL", "." ]

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

[]

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

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

[ "X86", "X86", "10", "10", "0x90", "0x66", "0x90", "0x0f", "0x1f", "0x00", "0x0f", "0x1f", "0x40", "0x00", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x0f", "0x1f", "0x80", "0x00", "0x00", "0x00", "0x00", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x2e", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0", "0x90", "10", "0", "10", "0", "0x66", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "arm_sched_fusion_priority", "(", "rtx_insn", "*", "insn", ",", "int", "max_pri", ",", "int", "*", "fusion_pri", ",", "int", "*", "pri", ")", "{", "int", "tmp", ",", "off_val", ";", "bool", "is_load", ";", "rtx", "base", ",", "offset", ";", "gcc_assert", "(", "INSN_P", "(", "insn", ")", ")", ";", "tmp", "=", "max_pri", "-", "1", ";", "if", "(", "!", "fusion_load_store", "(", "insn", ",", "&", "base", ",", "&", "offset", ",", "&", "is_load", ")", ")", "{", "*", "pri", "=", "tmp", ";", "*", "fusion_pri", "=", "tmp", ";", "return", ";", "}", "if", "(", "is_load", ")", "*", "fusion_pri", "=", "tmp", "-", "1", ";", "else", "*", "fusion_pri", "=", "tmp", "-", "2", ";", "tmp", "/=", "2", ";", "tmp", "-=", "(", "(", "REGNO", "(", "base", ")", "&", "0xff", ")", "<<", "20", ")", ";", "off_val", "=", "(", "int", ")", "(", "INTVAL", "(", "offset", ")", ")", ";", "if", "(", "off_val", ">=", "0", ")", "tmp", "-=", "(", "off_val", "&", "0xfffff", ")", ";", "else", "tmp", "+=", "(", "(", "-", "off_val", ")", "&", "0xfffff", ")", ";", "*", "pri", "=", "tmp", ";", "return", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_SCHED_FUSION_PRIORITY", "hook", ".", "Currently", "we", "only", "support", "to", "fuse", "ldr", "or", "str", "instructions", ",", "so", "FUSION_PRI", "and", "PRI", "are", "only", "calculated", "for", "these", "instructions", ".", "For", "other", "instruction", ",", "FUSION_PRI", "and", "PRI", "are", "simply", "set", "to", "MAX_PRI", ".", "In", "the", "future", ",", "other", "kind", "instruction", "fusion", "can", "be", "supported", "by", "returning", "different", "priorities", ".", "It", "'s", "important", "that", "irrelevant", "instructions", "get", "the", "largest", "FUSION_PRI", "." ]

[ "arm", "1", "1", "2", "2", "0xff", "20", "0", "0xfffff", "0xfffff" ]

[]