Datasets:

---

docz1105

/

ComBack

like 9

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

[ "Have", "v_trunc_f64", ",", "v_ceil_f64", ",", "v_rndne_f64", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "MachineModulePass", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addPreserved", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "(", "\"scalar-evolution\"", ")", ";", "AU", ".", "addPreserved", "(", "\"iv-users\"", ")", ";", "AU", ".", "addPreserved", "(", "\"memdep\"", ")", ";", "AU", ".", "addPreserved", "(", "\"live-values\"", ")", ";", "AU", ".", "addPreserved", "(", "\"domtree\"", ")", ";", "AU", ".", "addPreserved", "(", "\"domfrontier\"", ")", ";", "AU", ".", "addPreserved", "(", "\"loops\"", ")", ";", "AU", ".", "addPreserved", "(", "\"lda\"", ")", ";", "ModulePass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Patmos", "\"scalar-evolution\"", "\"iv-users\"", "\"memdep\"", "\"live-values\"", "\"domtree\"", "\"domfrontier\"", "\"loops\"", "\"lda\"" ]

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "WDC65816TargetStreamer", "&", "streamer", "=", "getTargetStreamer", "(", ")", ";", "streamer", ".", "EmitInstruction", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "WDC65816", "128", "WDC" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "2", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "0", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "2", "0" ]

[]

[ "<s>", "SDValue", "VideocoreTargetLowering", "::", "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", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_VC4", ")", ";", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "VCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "VCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "ISD::OutputArg", "16", "VC", "0", "\"Can only return in registers!\"", "\"Unknown loc info!\"", "ISD::ANY_EXTEND", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "1", "VCISD::RET_FLAG", "MVT::Other", "VCISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "unsigned", "ARM64TTI", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "OperandValueKind", "Opd1Info", ",", "OperandValueKind", "Opd2Info", ")", "const", "{", "std", "::", "pair", "<", "unsigned", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "Ty", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "TargetTransformInfo", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "AND", ":", "return", "1", "*", "LT", ".", "first", ";", "}", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "ARM64", "ARM64TTI::getArithmeticInstrCost", "ISD::ADD", "ISD::MUL", "ISD::XOR", "ISD::OR", "ISD::AND", "1" ]

[]

[ "<s>", "void", "AArch64TargetELFStreamer", "::", "emitDirectiveVariantPCS", "(", "MCSymbol", "*", "Symbol", ")", "{", "getStreamer", "(", ")", ".", "getAssembler", "(", ")", ".", "registerSymbol", "(", "*", "Symbol", ")", ";", "cast", "<", "MCSymbolELF", ">", "(", "Symbol", ")", "->", "setOther", "(", "ELF", "::", "STO_AARCH64_VARIANT_PCS", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".variant_pcs", "directive", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "add", "(", "TransformItem", "*", "TI", ")", "{", "assert", "(", "mayAdd", "(", "TI", ")", ")", ";", "if", "(", "Items", ".", "empty", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"new item\\n\"", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"merged to:\\n\"", ";", "Items", ".", "back", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "Mask", "|=", "(", "1", "<<", "TI", "->", "getIndex", "(", ")", ")", ";", "Items", ".", "push_back", "(", "TI", ")", ";", "}", "</s>" ]

[ "Add", "a", "string", "to", "the", "builder", "." ]

[ "TPC", "\"new item\\n\"", "\"merged to:\\n\"", "1" ]

[]

[ "<s>", "static", "bool", "c6x_pass_by_reference", "(", "cumulative_args_t", "cum_v", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "size", "=", "-", "1", ";", "if", "(", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "if", "(", "mode", "!=", "VOIDmode", ")", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "size", ">", "2", "*", "UNITS_PER_WORD", "||", "size", "==", "-", "1", ";", "}", "</s>" ]

[ "Types", "larger", "than", "64", "bit", ",", "and", "variable", "sized", "types", ",", "are", "passed", "by", "reference", ".", "The", "callee", "must", "copy", "them", ";", "see", "c6x_callee_copies", "." ]

[ "c6x", "1", "2", "1" ]

[]

[ "<s>", "void", "MCS51MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "assert", "(", "Size", ">", "0", "&&", "\"Instruction size cannot be zero\"", ")", ";", "uint64_t", "BinaryOpCode", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "emitInstruction", "(", "BinaryOpCode", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "MCS51", "MCS51", "0", "\"Instruction size cannot be zero\"" ]

[]

[ "<s>", "bool", "has_merge_operand_p", "(", ")", "const", "override", "{", "if", "(", "UNSPEC", "==", "UNSPEC_VSLIDEUP", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "We", "choose", "to", "return", "true", "by", "default", "since", "most", "of", "the", "intrinsics", "use", "has", "merge", "operand", "." ]

[ "riscv" ]

[]

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

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "SystemZMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MI", "->", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "I", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isImplicit", "(", ")", ")", "OutMI", ".", "addOperand", "(", "lowerOperand", "(", "MO", ")", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_evpc_sve_tbl", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "HOST_WIDE_INT", "nelt", ";", "if", "(", "!", "d", "->", "one_vector_p", "&&", "!", "d", "->", "perm", ".", "length", "(", ")", ".", "is_constant", "(", "&", "nelt", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "machine_mode", "sel_mode", "=", "mode_for_int_vector", "(", "d", "->", "vmode", ")", ".", "require", "(", ")", ";", "rtx", "sel", "=", "vec_perm_indices_to_rtx", "(", "sel_mode", ",", "d", "->", "perm", ")", ";", "aarch64_expand_sve_vec_perm", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "sel", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "implement", "D", "using", "an", "SVE", "TBL", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ISelDAGToDAG **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "ForCodeSize", "=", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"********** ISelDAGToDAG **********\\n\"", "\"********** Function: \"", "WebAssembly" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "I", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::POP16r" ]

[]

[ "<s>", "void", "emitAssignment", "(", "MCSymbol", "*", "S", ",", "const", "MCExpr", "*", "Value", ")", "override", "{", "auto", "*", "Symbol", "=", "cast", "<", "MCSymbolELF", ">", "(", "S", ")", ";", "if", "(", "Value", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "SymbolRef", ")", "return", ";", "const", "auto", "&", "RhsSym", "=", "cast", "<", "MCSymbolELF", ">", "(", "static_cast", "<", "const", "MCSymbolRefExpr", "*", ">", "(", "Value", ")", "->", "getSymbol", "(", ")", ")", ";", "unsigned", "Other", "=", "Symbol", "->", "getOther", "(", ")", ";", "Other", "&=", "~", "ELF", "::", "STO_PPC64_LOCAL_MASK", ";", "Other", "|=", "RhsSym", ".", "getOther", "(", ")", "&", "ELF", "::", "STO_PPC64_LOCAL_MASK", ";", "Symbol", "->", "setOther", "(", "Other", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assignment", "of", "Value", "to", "Symbol", "." ]

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

[]

[ "<s>", "static", "void", "output_movsi", "(", "rtx", "operands", "[", "2", "]", ")", "{", "output_asm_insn", "(", "singlemove_string", "(", "operands", ")", ",", "operands", ")", ";", "}", "</s>" ]

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

[ "m68k", "2" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "PerformCMOVCombine", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Cmp", "=", "N", "->", "getOperand", "(", "4", ")", ";", "if", "(", "Cmp", ".", "getOpcode", "(", ")", "!=", "ARMISD", "::", "CMPZ", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "LHS", "=", "Cmp", ".", "getOperand", "(", "0", ")", ";", "SDValue", "RHS", "=", "Cmp", ".", "getOperand", "(", "1", ")", ";", "SDValue", "FalseVal", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "TrueVal", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "ARMcc", "=", "N", "->", "getOperand", "(", "2", ")", ";", "ARMCC", "::", "CondCodes", "CC", "=", "(", "ARMCC", "::", "CondCodes", ")", "cast", "<", "ConstantSDNode", ">", "(", "ARMcc", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "isThumb1Only", "(", ")", "&&", "Subtarget", "->", "hasV6T2Ops", "(", ")", ")", "{", "SDValue", "R", "=", "PerformCMOVToBFICombine", "(", "N", ",", "DAG", ")", ";", "if", "(", "R", ")", "return", "R", ";", "}", "SDValue", "Res", ";", "if", "(", "CC", "==", "ARMCC", "::", "NE", "&&", "FalseVal", "==", "RHS", "&&", "FalseVal", "!=", "LHS", ")", "{", "Res", "=", "DAG", ".", "getNode", "(", "ARMISD", "::", "CMOV", ",", "dl", ",", "VT", ",", "LHS", ",", "TrueVal", ",", "ARMcc", ",", "N", "->", "getOperand", "(", "3", ")", ",", "Cmp", ")", ";", "}", "else", "if", "(", "CC", "==", "ARMCC", "::", "EQ", "&&", "TrueVal", "==", "RHS", ")", "{", "SDValue", "ARMcc", ";", "SDValue", "NewCmp", "=", "getARMCmp", "(", "LHS", ",", "RHS", ",", "ISD", "::", "SETNE", ",", "ARMcc", ",", "DAG", ",", "dl", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ARMISD", "::", "CMOV", ",", "dl", ",", "VT", ",", "LHS", ",", "FalseVal", ",", "ARMcc", ",", "N", "->", "getOperand", "(", "3", ")", ",", "NewCmp", ")", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "{", "APInt", "KnownZero", ",", "KnownOne", ";", "DAG", ".", "computeKnownBits", "(", "SDValue", "(", "N", ",", "0", ")", ",", "KnownZero", ",", "KnownOne", ")", ";", "if", "(", "KnownZero", "==", "0xfffffffe", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "MVT", "::", "i32", ",", "Res", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i1", ")", ")", ";", "else", "if", "(", "KnownZero", "==", "0xffffff00", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "MVT", "::", "i32", ",", "Res", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i8", ")", ")", ";", "else", "if", "(", "KnownZero", "==", "0xffff0000", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "MVT", "::", "i32", ",", "Res", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i16", ")", ")", ";", "}", "return", "Res", ";", "}", "</s>" ]

[ "PerformCMOVCombine", "-", "Target-specific", "DAG", "combining", "for", "ARMISD", ":", ":CMOV", "." ]

[ "ARM", "ARM", "4", "ARMISD::CMPZ", "0", "0", "1", "0", "1", "ARM", "2", "ARMCC::CondCodes", "ARMCC::CondCodes", "ARM", "ARMCC::NE", "ARMISD::CMOV", "ARM", "3", "ARMCC::EQ", "ARM", "ARM", "ISD::SETNE", "ARM", "ARMISD::CMOV", "ARM", "3", "0", "0xfffffffe", "ISD::AssertZext", "MVT::i32", "MVT::i1", "0xffffff00", "ISD::AssertZext", "MVT::i32", "MVT::i8", "0xffff0000", "ISD::AssertZext", "MVT::i32", "MVT::i16" ]

[]

[ "<s>", "void", "ix86_add_new_builtins", "(", "HOST_WIDE_INT", "isa", ",", "HOST_WIDE_INT", "isa2", ")", "{", "isa", "&=", "~", "OPTION_MASK_ISA_64BIT", ";", "if", "(", "(", "isa", "&", "deferred_isa_values", ")", "==", "0", "&&", "(", "isa2", "&", "deferred_isa_values2", ")", "==", "0", "&&", "(", "(", "deferred_isa_values", "&", "OPTION_MASK_ISA_MMX", ")", "==", "0", "||", "!", "(", "TARGET_64BIT", "&&", "(", "isa", "&", "OPTION_MASK_ISA_SSE2", ")", "!=", "0", ")", ")", ")", "return", ";", "deferred_isa_values", "&=", "~", "isa", ";", "deferred_isa_values2", "&=", "~", "isa2", ";", "if", "(", "TARGET_64BIT", "&&", "(", "isa", "&", "OPTION_MASK_ISA_SSE2", ")", "!=", "0", ")", "deferred_isa_values", "&=", "~", "OPTION_MASK_ISA_MMX", ";", "int", "i", ";", "tree", "saved_current_target_pragma", "=", "current_target_pragma", ";", "current_target_pragma", "=", "NULL_TREE", ";", "for", "(", "i", "=", "0", ";", "i", "<", "(", "int", ")", "IX86_BUILTIN_MAX", ";", "i", "++", ")", "{", "if", "(", "(", "(", "ix86_builtins_isa", "[", "i", "]", ".", "isa", "&", "isa", ")", "!=", "0", "||", "(", "ix86_builtins_isa", "[", "i", "]", ".", "isa2", "&", "isa2", ")", "!=", "0", "||", "(", "(", "ix86_builtins_isa", "[", "i", "]", ".", "isa", "&", "OPTION_MASK_ISA_MMX", ")", "!=", "0", "&&", "TARGET_64BIT", "&&", "(", "isa", "&", "OPTION_MASK_ISA_SSE2", ")", "!=", "0", ")", ")", "&&", "ix86_builtins_isa", "[", "i", "]", ".", "set_and_not_built_p", ")", "{", "tree", "decl", ",", "type", ";", "ix86_builtins_isa", "[", "i", "]", ".", "set_and_not_built_p", "=", "false", ";", "type", "=", "ix86_get_builtin_func_type", "(", "ix86_builtins_isa", "[", "i", "]", ".", "tcode", ")", ";", "decl", "=", "add_builtin_function_ext_scope", "(", "ix86_builtins_isa", "[", "i", "]", ".", "name", ",", "type", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "ix86_builtins", "[", "i", "]", "=", "decl", ";", "if", "(", "ix86_builtins_isa", "[", "i", "]", ".", "const_p", ")", "TREE_READONLY", "(", "decl", ")", "=", "1", ";", "}", "}", "current_target_pragma", "=", "saved_current_target_pragma", ";", "}", "</s>" ]

[ "Add", "any", "new", "builtin", "functions", "for", "a", "given", "ISA", "that", "may", "not", "have", "been", "declared", ".", "This", "saves", "a", "bit", "of", "space", "compared", "to", "adding", "all", "of", "the", "declarations", "to", "the", "tree", ",", "even", "if", "we", "did", "n't", "use", "them", "." ]

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

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "PrintSymbolOperand", "(", "const", "MachineOperand", "&", "MO", ",", "raw_ostream", "&", "O", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"caller should check MO.isGlobal\"", ")", ";", "unsigned", "TF", "=", "MO", ".", "getTargetFlags", "(", ")", ";", "if", "(", "TF", "&", "ARMII", "::", "MO_LO16", ")", "O", "<<", "\":lower16:\"", ";", "else", "if", "(", "TF", "&", "ARMII", "::", "MO_HI16", ")", "O", "<<", "\":upper16:\"", ";", "GetARMGVSymbol", "(", "MO", ".", "getGlobal", "(", ")", ",", "TF", ")", "->", "print", "(", "O", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "O", ")", ";", "}", "</s>" ]

[ "Print", "the", "MachineOperand", "as", "a", "symbol", "." ]

[ "ARM", "ARM", "\"caller should check MO.isGlobal\"", "ARMII::MO_LO16", "\":lower16:\"", "ARMII::MO_HI16", "\":upper16:\"", "ARM" ]

[]

[ "<s>", "bool", "avr_mem_flash_p", "(", "rtx", "x", ")", "{", "return", "(", "MEM_P", "(", "x", ")", "&&", "!", "ADDR_SPACE_GENERIC_P", "(", "MEM_ADDR_SPACE", "(", "x", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "is", "a", "MEM", "rtx", "located", "in", "flash", "and", "FALSE", ",", "otherwise", "." ]

[ "avr" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "GPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tcGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "rGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "GPRnopcRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "SrcReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_rGPRRegClass", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "SrcReg", ",", "ARM", "::", "gsub_0", ",", "getKillRegState", "(", "isKill", ")", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "SrcReg", ",", "ARM", "::", "gsub_1", ",", "0", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::tGPRRegClass", "ARM::tcGPRRegClass", "ARM::rGPRRegClass", "ARM::GPRnopcRegClass", "ARM::t2STRi12", "0", "ARMCC::AL", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_rGPRRegClass", "ARM::t2STRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "0", "ARMCC::AL", "ARM" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "rtx_insn", "*", "s390_load_got", "(", "void", ")", "{", "rtx_insn", "*", "insns", ";", "rtx", "got_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "emit_move_insn", "(", "got_rtx", ",", "s390_got_symbol", "(", ")", ")", ";", "}", "else", "{", "rtx", "offset", ";", "offset", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "s390_got_symbol", "(", ")", ")", ",", "UNSPEC_LTREL_OFFSET", ")", ";", "offset", "=", "gen_rtx_CONST", "(", "Pmode", ",", "offset", ")", ";", "offset", "=", "force_const_mem", "(", "Pmode", ",", "offset", ")", ";", "emit_move_insn", "(", "got_rtx", ",", "offset", ")", ";", "offset", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "XEXP", "(", "offset", ",", "0", ")", ")", ",", "UNSPEC_LTREL_BASE", ")", ";", "offset", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "got_rtx", ",", "offset", ")", ";", "emit_move_insn", "(", "got_rtx", ",", "offset", ")", ";", "}", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insns", ";", "}", "</s>" ]

[ "Return", "insn", "sequence", "to", "load", "the", "GOT", "register", "." ]

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

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "AnalyzeFormalArguments", "(", "CCInfo", ",", "Ins", ")", ";", "}", "else", "{", "analyzeFormalArgumentsCompute", "(", "CCInfo", ",", "Ins", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "AMDGPU", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUAS", "::", "CONSTANT_BUFFER_0", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Offset", "=", "Subtarget", "->", "getExplicitKernelArgOffset", "(", "MF", ")", "+", "VA", ".", "getLocMemOffset", "(", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "Offset", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "4", ",", "MachineMemOperand", "::", "MONonTemporal", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "MFI", "->", "setABIArgOffset", "(", "Offset", "+", "MemVT", ".", "getStoreSize", "(", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "ISD::InputArg", "16", "R600", "R600", "ISD::InputArg", "8", "AMDGPU::isShader", "0", "ISD::InputArg", "AMDGPU::isShader", "AMDGPU::R600_Reg128RegClass", "AMDGPU", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "ISD::UNINDEXED", "MVT::i32", "MVT::i32", "4" ]

[]

[ "<s>", "Value", "*", "HexagonTargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "BasicBlock", "*", "BB", "=", "Builder", ".", "GetInsertBlock", "(", ")", ";", "Module", "*", "M", "=", "BB", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "PT", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", ";", "Type", "*", "Ty", "=", "PT", "->", "getElementType", "(", ")", ";", "unsigned", "SZ", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "assert", "(", "(", "SZ", "==", "32", "||", "SZ", "==", "64", ")", "&&", "\"Only 32/64-bit atomic loads supported\"", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "(", "SZ", "==", "32", ")", "?", "Intrinsic", "::", "hexagon_L2_loadw_locked", ":", "Intrinsic", "::", "hexagon_L4_loadd_locked", ";", "PointerType", "*", "NewPtrTy", "=", "Builder", ".", "getIntNTy", "(", "SZ", ")", "->", "getPointerTo", "(", "PT", "->", "getAddressSpace", "(", ")", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "NewPtrTy", ")", ";", "Value", "*", "Fn", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "IntID", ")", ";", "Value", "*", "Call", "=", "Builder", ".", "CreateCall", "(", "Fn", ",", "Addr", ",", "\"larx\"", ")", ";", "return", "Builder", ".", "CreateBitCast", "(", "Call", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "Hexagon", "Hexagon", "32", "64", "\"Only 32/64-bit atomic loads supported\"", "Intrinsic::ID", "32", "Intrinsic::hexagon_L2_loadw_locked", "Intrinsic::hexagon_L4_loadd_locked", "Intrinsic::getDeclaration", "\"larx\"" ]

[]

[ "<s>", "unsigned", "PPCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF", ")", "||", "MO", ".", "getReg", "(", ")", "<", "PPC", "::", "CR0", "||", "MO", ".", "getReg", "(", ")", ">", "PPC", "::", "CR7", ")", ";", "return", "CTX", ".", "getRegisterInfo", "(", ")", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Relocation required in an instruction that we cannot encode!\"", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MTCRF", "PPC::MFOCRF", "PPC::CR0", "PPC::CR7", "\"Relocation required in an instruction that we cannot encode!\"" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "DominatorTree", "&", "DT", "=", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "AssumptionCache", "&", "AC", "=", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "return", "promoteMemoryToRegister", "(", "F", ",", "DT", ",", "AC", ")", ";", "}", "</s>" ]

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

[ "TPC" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"TPC Hardware Loops\"", ";", "}", "</s>" ]

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

[ "TPC", "\"TPC Hardware Loops\"" ]

[]

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

[ "Optimize", "this", "function", "for", "minimum", "size", "(", "-Oz", ")", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "bool", "IsTailCallReturn", "=", "false", ";", "if", "(", "MBB", ".", "end", "(", ")", "!=", "MBBI", ")", "{", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "IsTailCallReturn", "=", "RetOpcode", "==", "AArch64", "::", "TCRETURNdi", "||", "RetOpcode", "==", "AArch64", "::", "TCRETURNri", ";", "}", "int", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "uint64_t", "ArgumentPopSize", "=", "0", ";", "if", "(", "IsTailCallReturn", ")", "{", "MachineOperand", "&", "StackAdjust", "=", "MBBI", "->", "getOperand", "(", "1", ")", ";", "ArgumentPopSize", "=", "StackAdjust", ".", "getImm", "(", ")", ";", "}", "else", "{", "ArgumentPopSize", "=", "AFI", "->", "getArgumentStackToRestore", "(", ")", ";", "}", "MachineBasicBlock", "::", "iterator", "LastPopI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "Begin", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "LastPopI", "!=", "Begin", ")", "{", "--", "LastPopI", ";", "if", "(", "!", "LastPopI", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "{", "++", "LastPopI", ";", "break", ";", "}", "}", "NumBytes", "-=", "AFI", "->", "getCalleeSavedStackSize", "(", ")", ";", "assert", "(", "NumBytes", ">=", "0", "&&", "\"Negative stack allocation size!?\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "bool", "RedZone", "=", "canUseRedZone", "(", "MF", ")", ";", "if", "(", "RedZone", "&&", "ArgumentPopSize", "==", "0", ")", "return", ";", "bool", "NoCalleeSaveRestore", "=", "AFI", "->", "getCalleeSavedStackSize", "(", ")", "==", "0", ";", "int", "StackRestoreBytes", "=", "RedZone", "?", "0", ":", "NumBytes", ";", "if", "(", "NoCalleeSaveRestore", ")", "StackRestoreBytes", "+=", "ArgumentPopSize", ";", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "StackRestoreBytes", ",", "TII", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "NoCalleeSaveRestore", "||", "ArgumentPopSize", "==", "0", ")", "return", ";", "NumBytes", "=", "0", ";", "}", "if", "(", "NumBytes", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "FP", ",", "-", "AFI", "->", "getCalleeSavedStackSize", "(", ")", "+", "16", ",", "TII", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "ArgumentPopSize", ")", "emitFrameOffset", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "ArgumentPopSize", ",", "TII", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::TCRETURNdi", "AArch64::TCRETURNri", "AArch64", "AArch64", "0", "1", "0", "\"Negative stack allocation size!?\"", "0", "0", "0", "AArch64::SP", "AArch64::SP", "0", "0", "AArch64::SP", "AArch64::FP", "16", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vrev", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "j", ",", "diff", ",", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", ")", "return", "false", ";", "diff", "=", "d", "->", "perm", "[", "0", "]", ";", "switch", "(", "diff", ")", "{", "case", "7", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "gen", "=", "gen_neon_vrev64v16qi", ";", "break", ";", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev64v8qi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "3", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "gen", "=", "gen_neon_vrev32v16qi", ";", "break", ";", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev32v8qi", ";", "break", ";", "case", "E_V8HImode", ":", "gen", "=", "gen_neon_vrev64v8hi", ";", "break", ";", "case", "E_V4HImode", ":", "gen", "=", "gen_neon_vrev64v4hi", ";", "break", ";", "case", "E_V8HFmode", ":", "gen", "=", "gen_neon_vrev64v8hf", ";", "break", ";", "case", "E_V4HFmode", ":", "gen", "=", "gen_neon_vrev64v4hf", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "1", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "gen", "=", "gen_neon_vrev16v16qi", ";", "break", ";", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev16v8qi", ";", "break", ";", "case", "E_V8HImode", ":", "gen", "=", "gen_neon_vrev32v8hi", ";", "break", ";", "case", "E_V4HImode", ":", "gen", "=", "gen_neon_vrev32v4hi", ";", "break", ";", "case", "E_V4SImode", ":", "gen", "=", "gen_neon_vrev64v4si", ";", "break", ";", "case", "E_V2SImode", ":", "gen", "=", "gen_neon_vrev64v2si", ";", "break", ";", "case", "E_V4SFmode", ":", "gen", "=", "gen_neon_vrev64v4sf", ";", "break", ";", "case", "E_V2SFmode", ":", "gen", "=", "gen_neon_vrev64v2sf", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "diff", "+", "1", ")", "for", "(", "j", "=", "0", ";", "j", "<=", "diff", ";", "j", "+=", "1", ")", "{", "gcc_assert", "(", "i", "+", "j", "<", "nelt", ")", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "j", "]", "!=", "i", "+", "diff", "-", "j", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "gen", "(", "d", "->", "target", ",", "d", "->", "op0", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VREV", "insns", "." ]

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

[]

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

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "static", "short", "find_insn_regmode_weight", "(", "rtx", "insn", ",", "machine_mode", "mode", ")", "{", "short", "reg_weight", "=", "0", ";", "rtx", "x", ";", "x", "=", "PATTERN", "(", "insn", ")", ";", "reg_weight", "+=", "find_set_regmode_weight", "(", "x", ",", "mode", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PARALLEL", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "0", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "{", "x", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "j", ")", ";", "reg_weight", "+=", "find_set_regmode_weight", "(", "x", ",", "mode", ")", ";", "}", "}", "for", "(", "x", "=", "REG_NOTES", "(", "insn", ")", ";", "x", ";", "x", "=", "XEXP", "(", "x", ",", "1", ")", ")", "{", "if", "(", "REG_NOTE_KIND", "(", "x", ")", "==", "REG_DEAD", "||", "REG_NOTE_KIND", "(", "x", ")", "==", "REG_UNUSED", ")", "{", "rtx", "note", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "REG_P", "(", "note", ")", "&&", "GET_MODE", "(", "note", ")", "==", "mode", ")", "reg_weight", "--", ";", "}", "}", "return", "reg_weight", ";", "}", "</s>" ]

[ "Get", "regmode", "weight", "for", "insn", "." ]

[ "sh", "0", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "collect", "(", ")", "{", "ValueVect", "BO", ";", "getBlockTraversalOrder", "(", "Fn", "->", "begin", "(", ")", ",", "BO", ")", ";", "ValueToNodeMap", "NM", ";", "for", "(", "ValueVect", "::", "iterator", "I", "=", "BO", ".", "begin", "(", ")", ",", "E", "=", "BO", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "*", "I", ")", ";", "for", "(", "BasicBlock", "::", "iterator", "J", "=", "B", "->", "begin", "(", ")", ",", "F", "=", "B", "->", "end", "(", ")", ";", "J", "!=", "F", ";", "++", "J", ")", "{", "if", "(", "!", "isa", "<", "GetElementPtrInst", ">", "(", "J", ")", ")", "continue", ";", "GetElementPtrInst", "*", "GepI", "=", "cast", "<", "GetElementPtrInst", ">", "(", "J", ")", ";", "if", "(", "isHandledGepForm", "(", "GepI", ")", ")", "processGepInst", "(", "GepI", ",", "NM", ")", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Gep nodes after initial collection:\\n\"", "<<", "Nodes", ")", ";", "}", "</s>" ]

[ "Analyze", "the", "given", "instruction", "MI", "and", "fill", "in", "the", "Uses", ",", "Defs", "and", "DeadDefs", "list", "based", "on", "the", "MachineOperand", "flags", "." ]

[ "Hexagon", "Hexagon", "\"Gep nodes after initial collection:\\n\"" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "unsigned", "AAPMachineFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "GlobalBaseReg", ")", "return", "GlobalBaseReg", ";", "return", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "AAP", "::", "GR64RegClass", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "AAP", "AAP", "AAP::GR64RegClass" ]

[]

[ "<s>", "rtx", "rs6000_longcall_ref", "(", "rtx", "call_ref", ")", "{", "const", "char", "*", "call_name", ";", "tree", "node", ";", "if", "(", "GET_CODE", "(", "call_ref", ")", "!=", "SYMBOL_REF", ")", "return", "call_ref", ";", "call_name", "=", "XSTR", "(", "call_ref", ",", "0", ")", ";", "if", "(", "*", "call_name", "==", "'.'", ")", "{", "while", "(", "*", "call_name", "==", "'.'", ")", "call_name", "++", ";", "node", "=", "get_identifier", "(", "call_name", ")", ";", "call_ref", "=", "gen_rtx_SYMBOL_REF", "(", "VOIDmode", ",", "IDENTIFIER_POINTER", "(", "node", ")", ")", ";", "}", "return", "force_reg", "(", "Pmode", ",", "call_ref", ")", ";", "}", "</s>" ]

[ "Return", "a", "reference", "suitable", "for", "calling", "a", "function", "with", "the", "longcall", "attribute", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "enableMachineScheduler", "(", ")", "const", "{", "if", "(", "isMClass", "(", ")", "&&", "hasMinSize", "(", ")", ")", "return", "false", ";", "return", "useMachineScheduler", "(", ")", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "ARM", "ARM" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "VEMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "if", "(", "const", "VEMCExpr", "*", "SExpr", "=", "dyn_cast", "<", "VEMCExpr", ">", "(", "Expr", ")", ")", "{", "MCFixupKind", "Kind", "=", "(", "MCFixupKind", ")", "SExpr", "->", "getFixupKind", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "Kind", ")", ")", ";", "return", "0", ";", "}", "int64_t", "Res", ";", "if", "(", "Expr", "->", "evaluateAsAbsolute", "(", "Res", ")", ")", "return", "Res", ";", "llvm_unreachable", "(", "\"Unhandled expression!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE", "VE", "0", "0", "\"Unhandled expression!\"", "0" ]

[]

[ "<s>", "bool", "AMDGPUPrintfRuntimeBinding", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "auto", "GetDT", "=", "[", "this", "]", "(", "Function", "&", "F", ")", "->", "DominatorTree", "&", "{", "return", "this", "->", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", "F", ")", ".", "getDomTree", "(", ")", ";", "}", ";", "auto", "GetTLI", "=", "[", "this", "]", "(", "Function", "&", "F", ")", "->", "TargetLibraryInfo", "&", "{", "return", "this", "->", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "F", ")", ";", "}", ";", "return", "AMDGPUPrintfRuntimeBindingImpl", "(", "GetDT", ",", "GetTLI", ")", ".", "run", "(", "M", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "IA64RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BaseRegister", "=", "FP", "?", "IA64", "::", "r5", ":", "IA64", "::", "r12", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BaseRegister", ",", "false", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "if", "(", "Offset", "<=", "8191", "&&", "Offset", ">=", "-", "8192", ")", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "IA64", "::", "r22", ",", "false", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "IA64", "::", "ADDIMM22", ")", ",", "IA64", "::", "r22", ")", ".", "addReg", "(", "BaseRegister", ")", ".", "addImm", "(", "Offset", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "IA64", "::", "r22", ",", "false", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "IA64", "::", "MOVLIMM64", ")", ",", "IA64", "::", "r22", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "IA64", "::", "ADD", ")", ",", "IA64", "::", "r22", ")", ".", "addReg", "(", "BaseRegister", ")", ".", "addReg", "(", "IA64", "::", "r22", ")", ";", "}", "}", "</s>" ]

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

[ "IA64", "IA64", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "IA64::r5", "IA64::r12", "8191", "8192", "IA64::r22", "IA64::ADDIMM22", "IA64::r22", "IA64::r22", "IA64::MOVLIMM64", "IA64::r22", "IA64::ADD", "IA64::r22", "IA64::r22" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SMShadowTracker", ".", "startFunction", "(", "MF", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Intrn", "=", "MF", ".", "getFunction", "(", ")", "->", "hasInternalLinkage", "(", ")", ";", "OutStreamer", ".", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", ".", "EmitCOFFSymbolStorageClass", "(", "Intrn", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", ".", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", ".", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionHeader", "(", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "EVT", "VT", "=", "getValueType", "(", "DL", ",", "Ty", ",", "true", ")", ";", "if", "(", "!", "isLegalAddressImmediate", "(", "AM", ".", "BaseOffs", ",", "VT", ",", "Subtarget", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "LLVM_FALLTHROUGH", ";", "default", ":", "if", "(", "AM", ".", "BaseOffs", ")", "return", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "return", "isLegalT2ScaledAddressingMode", "(", "AM", ",", "VT", ")", ";", "int", "Scale", "=", "AM", ".", "Scale", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i32", ":", "if", "(", "Scale", "<", "0", ")", "Scale", "=", "-", "Scale", ";", "if", "(", "Scale", "==", "1", ")", "return", "true", ";", "return", "isPowerOf2_32", "(", "Scale", "&", "~", "1", ")", ";", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i64", ":", "if", "(", "(", "(", "unsigned", ")", "AM", ".", "HasBaseReg", "+", "Scale", ")", "<=", "2", ")", "return", "true", ";", "return", "false", ";", "case", "MVT", "::", "isVoid", ":", "if", "(", "Scale", "&", "1", ")", "return", "false", ";", "return", "isPowerOf2_32", "(", "Scale", ")", ";", "}", "}", "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", "." ]

[ "ARM", "ARM", "0", "1", "MVT::i1", "MVT::i8", "MVT::i32", "0", "1", "1", "MVT::i16", "MVT::i64", "2", "MVT::isVoid", "1" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineOperand", "&", "FrameOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "FrameOp", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "XCoreFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "LLVM_DEBUG", "(", "MI", ".", "print", "(", "errs", "(", ")", ")", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "StackSize", ";", "Register", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "0", ")", ";", "assert", "(", "Offset", "%", "4", "==", "0", "&&", "\"Misaligned stack offset\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "Offset", "/=", "4", ";", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "XCore", "::", "GRRegsRegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "isImmUs", "(", "Offset", ")", ")", "InsertFPImmInst", "(", "II", ",", "TII", ",", "Reg", ",", "FrameReg", ",", "Offset", ")", ";", "else", "InsertFPConstInst", "(", "II", ",", "TII", ",", "Reg", ",", "FrameReg", ",", "Offset", ",", "RS", ")", ";", "}", "else", "{", "if", "(", "isImmU16", "(", "Offset", ")", ")", "InsertSPImmInst", "(", "II", ",", "TII", ",", "Reg", ",", "Offset", ")", ";", "else", "InsertSPConstInst", "(", "II", ",", "TII", ",", "Reg", ",", "Offset", ",", "RS", ")", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "0", "\"Unexpected\"", "XCore", "XCore", "XCore", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "1", "1", "1", "0", "4", "0", "\"Misaligned stack offset\"", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "4", "0", "XCore::GRRegsRegClass", "\"Unexpected register operand\"" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_arg_regno", "(", "const", "struct", "mips_arg_info", "*", "info", ",", "bool", "hard_float_p", ")", "{", "if", "(", "!", "info", "->", "fpr_p", "||", "!", "hard_float_p", ")", "return", "GP_ARG_FIRST", "+", "info", "->", "reg_offset", ";", "else", "if", "(", "mips_abi", "==", "ABI_32", "&&", "TARGET_DOUBLE_FLOAT", "&&", "info", "->", "reg_offset", ">", "0", ")", "return", "FP_ARG_FIRST", "+", "2", ";", "else", "return", "FP_ARG_FIRST", "+", "info", "->", "reg_offset", ";", "}", "</s>" ]

[ "INFO", "describes", "a", "register", "argument", "that", "has", "the", "normal", "format", "for", "the", "argument", "'s", "mode", ".", "Return", "the", "register", "it", "uses", ",", "assuming", "that", "FPRs", "are", "available", "if", "HARD_FLOAT_P", "." ]

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

[]

[ "<s>", "void", "sh_fix_range", "(", "const", "char", "*", "const_str", ")", "{", "char", "*", "str", "=", "strcpy", "(", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "const_str", ")", "+", "1", ")", ",", "const_str", ")", ";", "while", "(", "1", ")", "{", "char", "*", "dash", "=", "strchr", "(", "str", ",", "'-'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "0", ",", "\"value of -mfixed-range must have form REG1-REG2\"", ")", ";", "return", ";", "}", "*", "dash", "=", "'\\0'", ";", "char", "*", "comma", "=", "strchr", "(", "dash", "+", "1", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "int", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "str", ")", ";", "return", ";", "}", "int", "last", "=", "decode_reg_name", "(", "dash", "+", "1", ")", ";", "if", "(", "last", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "*", "dash", "=", "'-'", ";", "if", "(", "first", ">", "last", ")", "{", "warning", "(", "0", ",", "\"%s-%s is an empty range\"", ",", "str", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "for", "(", "int", "i", "=", "first", ";", "i", "<=", "last", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "!", "comma", ")", "break", ";", "*", "comma", "=", "','", ";", "str", "=", "comma", "+", "1", ";", "}", "}", "</s>" ]

[ "Parse", "the", "-mfixed-range=", "option", "string", "." ]

[ "sh", "1", "1", "0", "\"value of -mfixed-range must have form REG1-REG2\"", "1", "0", "0", "\"unknown register name: %s\"", "1", "0", "0", "\"unknown register name: %s\"", "1", "0", "\"%s-%s is an empty range\"", "1", "1", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "2", ":", "if", "(", "IsWin64", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "2", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

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

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

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

[]

[ "<s>", "SparcSubtarget", "&", "SparcSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "UseSoftMulDiv", "=", "false", ";", "IsV9", "=", "false", ";", "IsLeon", "=", "false", ";", "V8DeprecatedInsts", "=", "false", ";", "IsVIS", "=", "false", ";", "HasHardQuad", "=", "false", ";", "UsePopc", "=", "false", ";", "UseSoftFloat", "=", "false", ";", "HasNoFSMULD", "=", "false", ";", "HasNoFMULS", "=", "false", ";", "HasLeonCasa", "=", "false", ";", "HasUmacSmac", "=", "false", ";", "PerformSDIVReplace", "=", "false", ";", "InsertNOPLoad", "=", "false", ";", "FixAllFDIVSQRT", "=", "false", ";", "DetectRoundChange", "=", "false", ";", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "(", "Is64Bit", ")", "?", "\"v9\"", ":", "\"v8\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "!", "IsV9", ")", "UsePopc", "=", "false", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "Sparc", "Sparc", "Sparc", "\"v9\"", "\"v8\"" ]

[]

[ "<s>", "bool", "PTXPassConfig", "::", "addPreEmitPass", "(", ")", "{", "PM", "->", "add", "(", "createPTXMFInfoExtract", "(", "getPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "PM", "->", "add", "(", "createPTXFPRoundingModePass", "(", "getPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX", "PTX", "PTX", "PTX" ]

[]

[ "<s>", "PPCTargetLowering", "::", "ConstraintType", "PPCTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'b'", ":", "case", "'r'", ":", "case", "'f'", ":", "case", "'v'", ":", "case", "'y'", ":", "return", "C_RegisterClass", ";", "case", "'Z'", ":", "return", "C_Memory", ";", "}", "}", "else", "if", "(", "Constraint", "==", "\"wc\"", ")", "{", "return", "C_RegisterClass", ";", "}", "else", "if", "(", "Constraint", "==", "\"wa\"", "||", "Constraint", "==", "\"wd\"", "||", "Constraint", "==", "\"wf\"", "||", "Constraint", "==", "\"ws\"", ")", "{", "return", "C_RegisterClass", ";", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "1", "0", "\"wc\"", "\"wa\"", "\"wd\"", "\"wf\"", "\"ws\"" ]

[]

[ "<s>", "static", "bool", "ix86_tieable_integer_mode_p", "(", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "case", "SImode", ":", "return", "true", ";", "case", "QImode", ":", "return", "TARGET_64BIT", "||", "!", "TARGET_PARTIAL_REG_STALL", ";", "case", "DImode", ":", "return", "TARGET_64BIT", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_modes_tieable_p", ".", "Return", "true", "if", "MODE", "is", "a", "tieable", "integer", "mode", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "aarch64_simd_vector_alignment_reachable", "(", "const_tree", "type", ",", "bool", "is_packed", ")", "{", "if", "(", "is_packed", ")", "return", "false", ";", "poly_uint64", "preferred_alignment", "=", "aarch64_vectorize_preferred_vector_alignment", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "maybe_ne", "(", "wi", "::", "to_widest", "(", "TYPE_SIZE", "(", "type", ")", ")", ",", "preferred_alignment", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "riscv_print_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ",", "int", "letter", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "switch", "(", "letter", ")", "{", "case", "'h'", ":", "if", "(", "code", "==", "HIGH", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "riscv_print_operand_reloc", "(", "file", ",", "op", ",", "true", ")", ";", "break", ";", "case", "'R'", ":", "riscv_print_operand_reloc", "(", "file", ",", "op", ",", "false", ")", ";", "break", ";", "case", "'C'", ":", "fputs", "(", "GET_RTX_NAME", "(", "code", ")", ",", "file", ")", ";", "break", ";", "case", "'A'", ":", "if", "(", "riscv_memmodel_needs_amo_acquire", "(", "(", "enum", "memmodel", ")", "INTVAL", "(", "op", ")", ")", ")", "fputs", "(", "\".aq\"", ",", "file", ")", ";", "break", ";", "case", "'F'", ":", "if", "(", "riscv_memmodel_needs_release_fence", "(", "(", "enum", "memmodel", ")", "INTVAL", "(", "op", ")", ")", ")", "fputs", "(", "\"fence iorw,ow; \"", ",", "file", ")", ";", "break", ";", "case", "'i'", ":", "if", "(", "code", "!=", "REG", ")", "fputs", "(", "\"i\"", ",", "file", ")", ";", "break", ";", "case", "'S'", ":", "{", "rtx", "newop", "=", "GEN_INT", "(", "ctz_hwi", "(", "INTVAL", "(", "op", ")", ")", ")", ";", "output_addr_const", "(", "file", ",", "newop", ")", ";", "break", ";", "}", "case", "'T'", ":", "{", "rtx", "newop", "=", "GEN_INT", "(", "ctz_hwi", "(", "~", "INTVAL", "(", "op", ")", ")", ")", ";", "output_addr_const", "(", "file", ",", "newop", ")", ";", "break", ";", "}", "default", ":", "switch", "(", "code", ")", "{", "case", "REG", ":", "if", "(", "letter", "&&", "letter", "!=", "'z'", ")", "output_operand_lossage", "(", "\"invalid use of '%%%c'\"", ",", "letter", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "op", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "if", "(", "letter", "&&", "letter", "!=", "'z'", ")", "output_operand_lossage", "(", "\"invalid use of '%%%c'\"", ",", "letter", ")", ";", "else", "output_address", "(", "mode", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "break", ";", "default", ":", "if", "(", "letter", "==", "'z'", "&&", "op", "==", "CONST0_RTX", "(", "GET_MODE", "(", "op", ")", ")", ")", "fputs", "(", "reg_names", "[", "GP_REG_FIRST", "]", ",", "file", ")", ";", "else", "if", "(", "letter", "&&", "letter", "!=", "'z'", ")", "output_operand_lossage", "(", "\"invalid use of '%%%c'\"", ",", "letter", ")", ";", "else", "output_addr_const", "(", "file", ",", "riscv_strip_unspec_address", "(", "op", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND", ".", "The", "RISCV-specific", "operand", "codes", "are", ":", "'", "h'", "Print", "the", "high-part", "relocation", "associated", "with", "OP", ",", "after", "stripping", "any", "outermost", "HIGH", ".", "'", "R'", "Print", "the", "low-part", "relocation", "associated", "with", "OP", ".", "'", "C'", "Print", "the", "integer", "branch", "condition", "for", "comparison", "OP", ".", "'", "A'", "Print", "the", "atomic", "operation", "suffix", "for", "memory", "model", "OP", ".", "'", "F'", "Print", "a", "FENCE", "if", "the", "memory", "model", "requires", "a", "release", ".", "'", "z'", "Print", "x0", "if", "OP", "is", "zero", ",", "otherwise", "print", "OP", "normally", "." ]

[ "riscv", "0", "\".aq\"", "\"fence iorw,ow; \"", "\"i\"", "\"invalid use of '%%%c'\"", "\"%s\"", "\"invalid use of '%%%c'\"", "0", "\"invalid use of '%%%c'\"" ]

[]

[ "<s>", "bool", "FPS", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "FPIsUsed", "=", "false", ";", "static_assert", "(", "X86", "::", "FP6", "==", "X86", "::", "FP0", "+", "6", ",", "\"Register enums aren't sorted right!\"", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<=", "6", ";", "++", "i", ")", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "X86", "::", "FP0", "+", "i", ")", ")", "{", "FPIsUsed", "=", "true", ";", "break", ";", "}", "if", "(", "!", "FPIsUsed", ")", "return", "false", ";", "Bundles", "=", "&", "getAnalysis", "<", "EdgeBundles", ">", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bundleCFG", "(", "MF", ")", ";", "StackTop", "=", "0", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "Processed", ";", "MachineBasicBlock", "*", "Entry", "=", "MF", ".", "begin", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "*", "BB", ":", "depth_first_ext", "(", "Entry", ",", "Processed", ")", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "BB", ")", ";", "if", "(", "MF", ".", "size", "(", ")", "!=", "Processed", ".", "size", "(", ")", ")", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "if", "(", "Processed", ".", "insert", "(", "BB", ")", ".", "second", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "BB", ")", ";", "LiveBundles", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86::FP6", "X86::FP0", "6", "\"Register enums aren't sorted right!\"", "0", "6", "X86::FP0", "0", "8" ]

[]

[ "<s>", "SDValue", "getUNDEF", "(", "EVT", "VT", ")", "const", "{", "return", "DAG", ".", "getUNDEF", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "an", "UNDEF", "node", ".", "UNDEF", "does", "not", "have", "a", "useful", "SDLoc", "." ]

[ "VE" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "riscv_expand_conditional_move", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "cons", ",", "rtx", "alt", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "TARGET_XTHEADCONDMOV", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "reg_or_0_operand", "(", "cons", ",", "mode", ")", "&&", "reg_or_0_operand", "(", "alt", ",", "mode", ")", "&&", "GET_MODE", "(", "op", ")", "==", "mode", "&&", "GET_MODE", "(", "op0", ")", "==", "mode", "&&", "GET_MODE", "(", "op1", ")", "==", "mode", "&&", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", ")", "{", "riscv_expand_conditional_move_onesided", "(", "dest", ",", "cons", ",", "alt", ",", "code", ",", "op0", ",", "op1", ")", ";", "return", "true", ";", "}", "else", "if", "(", "TARGET_SFB_ALU", "&&", "mode", "==", "word_mode", ")", "{", "riscv_emit_int_compare", "(", "&", "code", ",", "&", "op0", ",", "&", "op1", ")", ";", "rtx", "cond", "=", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "op0", ")", ",", "op0", ",", "op1", ")", ";", "cons", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "cons", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dest", ")", ",", "cond", ",", "cons", ",", "alt", ")", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Emit", "a", "cond", "move", ":", "If", "OP", "holds", ",", "move", "CONS", "to", "DEST", ";", "else", "move", "ALT", "to", "DEST", ".", "Return", "0", "if", "expansion", "failed", "." ]

[ "riscv", "0", "1" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "bool", "IsAcquire", "=", "isAtLeastAcquire", "(", "Ord", ")", ";", "if", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "arm_ldaexd", ":", "Intrinsic", "::", "arm_ldrexd", ";", "Function", "*", "Ldrex", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldrex", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "32", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "arm_ldaex", ":", "Intrinsic", "::", "arm_ldrex", ";", "Function", "*", "Ldrex", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateTruncOrBitCast", "(", "Builder", ".", "CreateCall", "(", "Ldrex", ",", "Addr", ")", ",", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_ldaexd", "Intrinsic::arm_ldrexd", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "32", "\"val64\"", "Intrinsic::ID", "Intrinsic::arm_ldaex", "Intrinsic::arm_ldrex", "Intrinsic::getDeclaration" ]

[]

[ "<s>", "bool", "legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "if", "(", "pic_address_needs_scratch", "(", "x", ")", ")", "return", "false", ";", "if", "(", "SPARC_SYMBOL_REF_TLS_P", "(", "x", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "SPARC_SYMBOL_REF_TLS_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

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

[]

[ "<s>", "int", "bfin_register_move_cost", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "enum", "reg_class", "class1", ",", "enum", "reg_class", "class2", ")", "{", "if", "(", "optimize_size", ")", "return", "2", ";", "if", "(", "class1", "==", "DREGS", "&&", "class2", "!=", "DREGS", ")", "return", "2", "*", "2", ";", "return", "2", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "data", "from", "a", "register", "in", "class", "CLASS1", "to", "one", "in", "class", "CLASS2", ".", "A", "cost", "of", "2", "is", "the", "default", "." ]

[ "bfin", "2", "2", "2", "2" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "RISCV", "::", "GPRRegClass", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "int64_t", "RVVStackSize", "=", "assignRVVStackObjectOffsets", "(", "MFI", ")", ";", "RVFI", "->", "setRVVStackSize", "(", "RVVStackSize", ")", ";", "if", "(", "!", "isInt", "<", "11", ">", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ")", "||", "RVVStackSize", "!=", "0", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlign", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "if", "(", "RVVStackSize", "!=", "0", ")", "{", "int", "RVVRegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlign", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RVVRegScavFI", ")", ";", "}", "}", "if", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "||", "RVFI", "->", "useSaveRestoreLibCalls", "(", "MF", ")", ")", "{", "RVFI", "->", "setCalleeSavedStackSize", "(", "0", ")", ";", "return", ";", "}", "unsigned", "Size", "=", "0", ";", "for", "(", "const", "auto", "&", "Info", ":", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", "{", "int", "FrameIdx", "=", "Info", ".", "getFrameIdx", "(", ")", ";", "if", "(", "MFI", ".", "getStackID", "(", "FrameIdx", ")", "!=", "TargetStackID", "::", "Default", ")", "continue", ";", "Size", "+=", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ";", "}", "RVFI", "->", "setCalleeSavedStackSize", "(", "Size", ")", ";", "if", "(", "RVVStackSize", "&&", "!", "hasFP", "(", "MF", ")", "&&", "Size", "%", "8", "!=", "0", ")", "{", "RVFI", "->", "setRVVPadding", "(", "getStackAlign", "(", ")", ".", "value", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV", "11", "0", "0", "0", "0", "8", "0" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "PerformVSelectCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "PerformSignExtendCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "AArch64ISD", "::", "NEON_VDUPLANE", ":", "return", "CombineVLDDUP", "(", "N", ",", "DCI", ")", ";", "case", "AArch64ISD", "::", "NEON_LD2DUP", ":", "case", "AArch64ISD", "::", "NEON_LD3DUP", ":", "case", "AArch64ISD", "::", "NEON_LD4DUP", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic", "::", "arm_neon_vld4", ":", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "case", "Intrinsic", "::", "arm_neon_vld2lane", ":", "case", "Intrinsic", "::", "arm_neon_vld3lane", ":", "case", "Intrinsic", "::", "arm_neon_vld4lane", ":", "case", "Intrinsic", "::", "aarch64_neon_vld1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_vld1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_vld1x4", ":", "case", "Intrinsic", "::", "aarch64_neon_vst1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_vst1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_vst1x4", ":", "case", "Intrinsic", "::", "arm_neon_vst2lane", ":", "case", "Intrinsic", "::", "arm_neon_vst3lane", ":", "case", "Intrinsic", "::", "arm_neon_vst4lane", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "AArch64", "AArch64", "ISD::AND", "ISD::OR", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::VSELECT", "ISD::SIGN_EXTEND", "ISD::INTRINSIC_WO_CHAIN", "AArch64ISD::NEON_VDUPLANE", "AArch64ISD::NEON_LD2DUP", "AArch64ISD::NEON_LD3DUP", "AArch64ISD::NEON_LD4DUP", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::arm_neon_vld1", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "Intrinsic::arm_neon_vst1", "Intrinsic::arm_neon_vst2", "Intrinsic::arm_neon_vst3", "Intrinsic::arm_neon_vst4", "Intrinsic::arm_neon_vld2lane", "Intrinsic::arm_neon_vld3lane", "Intrinsic::arm_neon_vld4lane", "Intrinsic::aarch64_neon_vld1x2", "Intrinsic::aarch64_neon_vld1x3", "Intrinsic::aarch64_neon_vld1x4", "Intrinsic::aarch64_neon_vst1x2", "Intrinsic::aarch64_neon_vst1x3", "Intrinsic::aarch64_neon_vst1x4", "Intrinsic::arm_neon_vst2lane", "Intrinsic::arm_neon_vst3lane", "Intrinsic::arm_neon_vst4lane" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "LocInfo", "::", "AExt", ")", "{", "Size", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "ValVReg", "=", "MIRBuilder", ".", "buildAnyExt", "(", "LLT", "::", "scalar", "(", "Size", "*", "8", ")", ",", "ValVReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "unsigned", "Align", "=", "inferAlignmentFromPtrInfo", "(", "MF", ",", "MPO", ")", ";", "auto", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "MIRBuilder", ".", "buildStore", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

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

[ "AArch64", "8", "8", "0" ]

[]

[ "<s>", "static", "void", "mcore_print_operand_address", "(", "FILE", "*", "stream", ",", "machine_mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "stream", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "index", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "!=", "REG", ")", "{", "rtx", "temp", "=", "base", ";", "base", "=", "index", ";", "index", "=", "temp", ";", "}", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "stream", ",", "\"(%s,\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "reg_names", "[", "REGNO", "(", "base", ")", "]", ",", "INTVAL", "(", "index", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "default", ":", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "in", "x", "to", "the", "stream", "." ]

[ "mcore", "\"(%s)\"", "0", "1", "\"(%s,\"", "\")\"" ]

[]

[ "<s>", "bool", "aarch64_split_128bit_move_p", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "if", "(", "FP_REGNUM_P", "(", "REGNO", "(", "dst", ")", ")", ")", "return", "REG_P", "(", "src", ")", "&&", "!", "FP_REGNUM_P", "(", "REGNO", "(", "src", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "should", "split", "a", "move", "from", "128-bit", "value", "SRC", "to", "128-bit", "register", "DEST", "." ]

[ "aarch64" ]

[]

[ "<s>", "Register", "MipsTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "Subtarget", ".", "isGP64bit", "(", ")", ")", "{", "Register", "Reg", "=", "StringSwitch", "<", "Register", ">", "(", "RegName", ")", ".", "Case", "(", "\"$28\"", ",", "Mips", "::", "GP_64", ")", ".", "Default", "(", "Register", "(", ")", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "}", "else", "{", "Register", "Reg", "=", "StringSwitch", "<", "Register", ">", "(", "RegName", ")", ".", "Case", "(", "\"$28\"", ",", "Mips", "::", "GP", ")", ".", "Default", "(", "Register", "(", ")", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "}", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Mips", "Mips", "\"$28\"", "Mips::GP_64", "\"$28\"", "Mips::GP", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "LittleEndian", ")", ",", "DL", "(", "Subtarget", ".", "isTargetMachO", "(", ")", "?", "\"e-m:o-i64:64-i128:128-n32:64-S128\"", ":", "(", "LittleEndian", "?", "\"e-m:e-i64:64-i128:128-n32:64-S128\"", ":", "\"E-m:e-i64:64-i128:128-n32:64-S128\"", ")", ")", ",", "InstrInfo", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "Subtarget", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "AArch64", "architecture", "model", "." ]

[ "AArch64", "AArch64", "AArch64", "\"e-m:o-i64:64-i128:128-n32:64-S128\"", "\"e-m:e-i64:64-i128:128-n32:64-S128\"", "\"E-m:e-i64:64-i128:128-n32:64-S128\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "unsigned", "Bits", "=", "getBranchDisplacementBits", "(", "BranchOp", ")", ";", "assert", "(", "Bits", ">=", "3", "&&", "\"max branch displacement must be enough to jump\"", "\"over conditional branch expansion\"", ")", ";", "return", "isIntN", "(", "Bits", ",", "BrOffset", "/", "4", ")", ";", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "AArch64", "AArch64", "3", "\"max branch displacement must be enough to jump\"", "\"over conditional branch expansion\"", "4" ]

[]

[ "<s>", "static", "bool", "r10k_safe_mem_expr_p", "(", "tree", "expr", ",", "unsigned", "HOST_WIDE_INT", "offset", ")", "{", "HOST_WIDE_INT", "bitoffset", ",", "bitsize", ";", "tree", "inner", ",", "var_offset", ";", "machine_mode", "mode", ";", "int", "unsigned_p", ",", "reverse_p", ",", "volatile_p", ";", "inner", "=", "get_inner_reference", "(", "expr", ",", "&", "bitsize", ",", "&", "bitoffset", ",", "&", "var_offset", ",", "&", "mode", ",", "&", "unsigned_p", ",", "&", "reverse_p", ",", "&", "volatile_p", ",", "false", ")", ";", "if", "(", "!", "DECL_P", "(", "inner", ")", "||", "!", "DECL_SIZE_UNIT", "(", "inner", ")", "||", "var_offset", ")", "return", "false", ";", "offset", "+=", "bitoffset", "/", "BITS_PER_UNIT", ";", "return", "offset", "<", "tree_to_uhwi", "(", "DECL_SIZE_UNIT", "(", "inner", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "MEM", "with", "MEM_EXPR", "EXPR", "and", "MEM_OFFSET", "OFFSET", "is", "an", "in-range", "access", "to", "an", "automatic", "variable", ",", "or", "to", "an", "object", "with", "a", "link-time-constant", "address", "." ]

[ "mips" ]

[]

[ "<s>", "enum", "reg_class", "xstormy16_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "class", "==", "GENERAL_REGS", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "return", "EIGHT_REGS", ";", "return", "class", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_PREFERRED_RELOAD_CLASS", "and", "TARGET_PREFERRED_OUTPUT_RELOAD_CLASS", "." ]

[ "stormy16" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "getOriginalFunctionArgs", "(", "DAG", ",", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ",", "Ins", ",", "LocalIns", ")", ";", "AnalyzeFormalArguments", "(", "CCInfo", ",", "LocalIns", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "EVT", "VT", "=", "Ins", "[", "i", "]", ".", "VT", ";", "EVT", "MemVT", "=", "LocalIns", "[", "i", "]", ".", "VT", ";", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUAS", "::", "CONSTANT_BUFFER_0", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getExtLoad", "(", "ISD", "::", "SEXTLOAD", ",", "DL", ",", "VT", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "36", "+", "VA", ".", "getLocMemOffset", "(", ")", ",", "MVT", "::", "i32", ")", ",", "MachinePointerInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ")", ",", "MemVT", ",", "false", ",", "false", ",", "4", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "R600", "ISD::InputArg", "16", "ISD::InputArg", "8", "0", "AMDGPUAS::CONSTANT_BUFFER_0", "ISD::SEXTLOAD", "36", "MVT::i32", "4" ]

[]

[ "<s>", "LLT", "getStackValueStoreType", "(", "const", "DataLayout", "&", "DL", ",", "const", "CCValAssign", "&", "VA", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "const", "override", "{", "if", "(", "Flags", ".", "isPointer", "(", ")", ")", "return", "CallLowering", "::", "ValueHandler", "::", "getStackValueStoreType", "(", "DL", ",", "VA", ",", "Flags", ")", ";", "return", "getStackValueStoreTypeHack", "(", "VA", ")", ";", "}", "</s>" ]

[ "Return", "the", "in-memory", "size", "to", "write", "for", "the", "argument", "at", "VA", "." ]

[ "AArch64", "ISD::ArgFlagsTy" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "computeDefaultCPU", "(", "TT", ",", "CPU", ")", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveAArch64CodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "if", "(", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "}", "if", "(", "this", "->", "Options", ".", "TLSSize", "==", "0", ")", "this", "->", "Options", ".", "TLSSize", "=", "24", ";", "if", "(", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "||", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Kernel", ")", "&&", "this", "->", "Options", ".", "TLSSize", ">", "32", ")", "this", "->", "Options", ".", "TLSSize", "=", "32", ";", "else", "if", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Tiny", "&&", "this", "->", "Options", ".", "TLSSize", ">", "24", ")", "this", "->", "Options", ".", "TLSSize", "=", "24", ";", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", "&&", "TT", ".", "getArch", "(", ")", "!=", "Triple", "::", "aarch64_32", "&&", "!", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", ")", "{", "setGlobalISel", "(", "true", ")", ";", "setGlobalISelAbort", "(", "GlobalISelAbortMode", "::", "Disable", ")", ";", "}", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDefaultOutlining", "(", "true", ")", ";", "setSupportsDebugEntryValues", "(", "true", ")", ";", "}", "</s>" ]

[ "Create", "an", "AArch64", "architecture", "model", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "0", "24", "32", "32", "24", "24" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MI", "->", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "return", "true", ";", "return", "AMDGPUInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU" ]

[]

[ "<s>", "unsigned", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "FrameIndexValue", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FPW", ":", "MSP430", "::", "SPW", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADD16ri", ")", "{", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", "0", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", "0", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "MSP430::FPW", "MSP430::SPW", "2", "2", "1", "MSP430::ADD16ri", "MSP430::MOV16rr", "0", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "0", "1", "0" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "SICacheControl", ">", "SICacheControl", "::", "create", "(", "const", "GCNSubtarget", "&", "ST", ")", "{", "GCNSubtarget", "::", "Generation", "Generation", "=", "ST", ".", "getGeneration", "(", ")", ";", "if", "(", "Generation", "<=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "return", "make_unique", "<", "SIGfx6CacheControl", ">", "(", "ST", ")", ";", "if", "(", "Generation", "<", "AMDGPUSubtarget", "::", "GFX10", ")", "return", "make_unique", "<", "SIGfx7CacheControl", ">", "(", "ST", ")", ";", "return", "make_unique", "<", "SIGfx10CacheControl", ">", "(", "ST", ",", "ST", ".", "isCuModeEnabled", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU", "SI", "AMDGPU", "SI", "SI" ]

[]

[ "<s>", "void", "ix86_expand_floorceil", "(", "rtx", "operand0", ",", "rtx", "operand1", ",", "bool", "do_floor", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "xa", ",", "xi", ",", "TWO52", ",", "tmp", ",", "one", ",", "res", ",", "mask", ";", "rtx_code_label", "*", "label", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "res", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "res", ",", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "mask", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "xi", "=", "gen_reg_rtx", "(", "mode", "==", "DFmode", "?", "DImode", ":", "SImode", ")", ";", "expand_fix", "(", "xi", ",", "res", ",", "0", ")", ";", "expand_float", "(", "xa", ",", "xi", ",", "0", ")", ";", "one", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "dconst1", ",", "mode", ")", ")", ";", "tmp", "=", "ix86_expand_sse_compare_mask", "(", "UNGT", ",", "xa", ",", "res", ",", "!", "do_floor", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_AND", "(", "mode", ",", "one", ",", "tmp", ")", ")", ")", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "do_floor", "?", "MINUS", ":", "PLUS", ",", "xa", ",", "tmp", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "emit_move_insn", "(", "res", ",", "tmp", ")", ";", "if", "(", "HONOR_SIGNED_ZEROS", "(", "mode", ")", ")", "ix86_sse_copysign_to_positive", "(", "res", ",", "res", ",", "force_reg", "(", "mode", ",", "operand1", ")", ",", "mask", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "SSE2", "sequence", "for", "computing", "floor", "or", "ceil", "from", "OPERAND1", "storing", "into", "OPERAND0", "." ]

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

[]

[ "<s>", "unsigned", "HexagonMCCodeEmitter", "::", "getMachineOpValue", "(", "MCInst", "const", "&", "MI", ",", "MCOperand", "const", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "const", "{", "size_t", "OperandNumber", "=", "~", "0U", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "if", "(", "&", "MI", ".", "getOperand", "(", "i", ")", "==", "&", "MO", ")", "{", "OperandNumber", "=", "i", ";", "break", ";", "}", "assert", "(", "(", "OperandNumber", "!=", "~", "0U", ")", "&&", "\"Operand not found\"", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isNewValue", "(", "MCII", ",", "MI", ")", "&&", "&", "MO", "==", "&", "HexagonMCInstrInfo", "::", "getNewValueOperand", "(", "MCII", ",", "MI", ")", ")", "{", "unsigned", "SOffset", "=", "0", ";", "unsigned", "VOffset", "=", "0", ";", "unsigned", "UseReg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "DefReg1", "=", "Hexagon", "::", "NoRegister", ";", "unsigned", "DefReg2", "=", "Hexagon", "::", "NoRegister", ";", "auto", "Instrs", "=", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "*", "State", ".", "Bundle", ")", ";", "const", "MCOperand", "*", "I", "=", "Instrs", ".", "begin", "(", ")", "+", "State", ".", "Index", "-", "1", ";", "for", "(", ";", ";", "--", "I", ")", "{", "assert", "(", "I", "!=", "Instrs", ".", "begin", "(", ")", "-", "1", "&&", "\"Couldn't find producer\"", ")", ";", "MCInst", "const", "&", "Inst", "=", "*", "I", "->", "getInst", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isImmext", "(", "Inst", ")", ")", "continue", ";", "DefReg1", "=", "Hexagon", "::", "NoRegister", ";", "DefReg2", "=", "Hexagon", "::", "NoRegister", ";", "++", "SOffset", ";", "if", "(", "HexagonMCInstrInfo", "::", "isVector", "(", "MCII", ",", "Inst", ")", ")", "{", "++", "VOffset", ";", "}", "if", "(", "HexagonMCInstrInfo", "::", "hasNewValue", "(", "MCII", ",", "Inst", ")", ")", "DefReg1", "=", "HexagonMCInstrInfo", "::", "getNewValueOperand", "(", "MCII", ",", "Inst", ")", ".", "getReg", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "hasNewValue2", "(", "MCII", ",", "Inst", ")", ")", "DefReg2", "=", "HexagonMCInstrInfo", "::", "getNewValueOperand2", "(", "MCII", ",", "Inst", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "RegisterMatches", "(", "UseReg", ",", "DefReg1", ",", "DefReg2", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "HexagonMCInstrInfo", "::", "isPredicated", "(", "MCII", ",", "Inst", ")", ")", "{", "break", ";", "}", "assert", "(", "HexagonMCInstrInfo", "::", "isPredicated", "(", "MCII", ",", "MI", ")", "&&", "\"Unpredicated consumer depending on predicated producer\"", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isPredicatedTrue", "(", "MCII", ",", "Inst", ")", "==", "HexagonMCInstrInfo", "::", "isPredicatedTrue", "(", "MCII", ",", "MI", ")", ")", "break", ";", "}", "unsigned", "Offset", "=", "HexagonMCInstrInfo", "::", "isVector", "(", "MCII", ",", "MI", ")", "?", "VOffset", ":", "SOffset", ";", "Offset", "<<=", "1", ";", "Offset", "|=", "HexagonMCInstrInfo", "::", "SubregisterBit", "(", "UseReg", ",", "DefReg1", ",", "DefReg2", ")", ";", "return", "Offset", ";", "}", "assert", "(", "!", "MO", ".", "isImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isSubInstruction", "(", "MI", ")", "||", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "MI", ")", "==", "HexagonII", "::", "TypeCJ", ")", "return", "HexagonMCInstrInfo", "::", "getDuplexRegisterNumbering", "(", "Reg", ")", ";", "return", "MCT", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "}", "return", "getExprOpValue", "(", "MI", ",", "MO", ",", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0U", "0", "0U", "\"Operand not found\"", "Hexagon", "Hexagon", "0", "0", "Hexagon::NoRegister", "Hexagon::NoRegister", "Hexagon", "1", "1", "\"Couldn't find producer\"", "Hexagon", "Hexagon::NoRegister", "Hexagon::NoRegister", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Unpredicated consumer depending on predicated producer\"", "Hexagon", "Hexagon", "Hexagon", "1", "Hexagon", "Hexagon", "Hexagon", "HexagonII::TypeCJ", "Hexagon" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "inlineStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "PrologMBB", ")", "const", "{", "const", "StringRef", "ChkStkStubSymbol", "=", "\"__chkstk_stub\"", ";", "MachineInstr", "*", "ChkStkStub", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "MI", ":", "PrologMBB", ")", "{", "if", "(", "MI", ".", "isCall", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isSymbol", "(", ")", "&&", "ChkStkStubSymbol", "==", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ")", "{", "ChkStkStub", "=", "&", "MI", ";", "break", ";", "}", "}", "if", "(", "ChkStkStub", "!=", "nullptr", ")", "{", "assert", "(", "!", "ChkStkStub", "->", "isBundled", "(", ")", "&&", "\"Not expecting bundled instructions here\"", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "next", "(", "ChkStkStub", "->", "getIterator", "(", ")", ")", ";", "assert", "(", "std", "::", "prev", "(", "MBBI", ")", ".", "operator", "==", "(", "ChkStkStub", ")", "&&", "\"MBBI expected after __chkstk_stub.\"", ")", ";", "DebugLoc", "DL", "=", "PrologMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "emitStackProbeInline", "(", "MF", ",", "PrologMBB", ",", "MBBI", ",", "DL", ",", "true", ")", ";", "ChkStkStub", "->", "eraseFromParent", "(", ")", ";", "}", "}", "</s>" ]

[ "Replace", "a", "StackProbe", "inline-stub", "with", "the", "actual", "probe", "code", "inline", "." ]

[ "X86", "X86", "\"__chkstk_stub\"", "0", "0", "\"Not expecting bundled instructions here\"", "\"MBBI expected after __chkstk_stub.\"" ]

[]

[ "<s>", "static", "unsigned", "long", "rs6000_arg_size", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "long", "size", ";", "if", "(", "mode", "!=", "BLKmode", ")", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "else", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "TARGET_32BIT", ")", "return", "(", "size", "+", "3", ")", ">>", "2", ";", "else", "return", "(", "size", "+", "7", ")", ">>", "3", ";", "}", "</s>" ]

[ "Compute", "the", "size", "(", "in", "words", ")", "of", "a", "function", "argument", "." ]

[ "powerpcspe", "3", "2", "7", "3" ]

[]

[ "<s>", "uint32_t", "AArch64MCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpIdx", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"Unexpected ADR target type!\"", ")", ";", "MCFixupKind", "Kind", "=", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "BL", "?", "MCFixupKind", "(", "AArch64", "::", "fixup_aarch64_pcrel_call26", ")", ":", "MCFixupKind", "(", "AArch64", "::", "fixup_aarch64_pcrel_branch26", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "Kind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "AArch64", "AArch64", "\"Unexpected ADR target type!\"", "AArch64::BL", "AArch64::fixup_aarch64_pcrel_call26", "AArch64::fixup_aarch64_pcrel_branch26", "0", "0" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this\"", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i128", "&&", "\"unexpected illegal conversion\"", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Don't know how to custom expand this\"", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "0", "MVT::i128", "\"unexpected illegal conversion\"" ]

[]

[ "<s>", "bool", "Inserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "int", "FI", "=", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "getGPFI", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "F", ".", "begin", "(", ")", ",", "MFE", "=", "F", ".", "end", "(", ")", ";", "MFI", "!=", "MFE", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MFI", "->", "begin", "(", ")", ";", "if", "(", "MBB", ".", "isLandingPad", "(", ")", ")", "{", "for", "(", ";", "I", "->", "getOpcode", "(", ")", "!=", "TargetOpcode", "::", "EH_LABEL", ";", "++", "I", ")", ";", "++", "I", ";", "DebugLoc", "dl", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "LW", ")", ",", "Mips", "::", "GP", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "Changed", "=", "true", ";", "}", "while", "(", "I", "!=", "MFI", "->", "end", "(", ")", ")", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Mips", "::", "JALR", ")", "{", "++", "I", ";", "continue", ";", "}", "DebugLoc", "dl", "=", "I", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "I", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "LW", ")", ",", "Mips", "::", "GP", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::LW", "Mips::GP", "0", "Mips::JALR", "Mips::LW", "Mips::GP", "0" ]

[]

[ "<s>", "bool", "ARMPreAllocLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TD", "=", "&", "Fn", ".", "getDataLayout", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "MF", "=", "&", "Fn", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MFI", ":", "Fn", ")", "Modified", "|=", "RescheduleLoadStoreInstrs", "(", "&", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Opcode", ")", "&&", "!", "TII", "->", "get", "(", "Opcode", ")", ".", "mayStore", "(", ")", ")", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Opcode", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::INSERT_SUBREG", "AMDGPU::REG_SEQUENCE" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ".", "TargetSize", "/", "8", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "AArch64", "8", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAVX", "(", "false", ")", ",", "HasFMA3", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "DarwinVers", "(", "0", ")", ",", "IsLinux", "(", "false", ")", ",", "stackAlignment", "(", "8", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "Is64Bit", "(", "is64Bit", ")", ",", "TargetType", "(", "isELF", ")", "{", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "std", "::", "string", "CPU", "=", "GetCurrentX86CPU", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "}", "else", "{", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "Is64Bit", "&&", "X86SSELevel", "<", "SSE2", ")", "X86SSELevel", "=", "SSE2", ";", "}", "if", "(", "Is64Bit", ")", "HasX86_64", "=", "true", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "Is64Bit", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "TT", ".", "length", "(", ")", ">", "5", ")", "{", "size_t", "Pos", ";", "if", "(", "(", "Pos", "=", "TT", ".", "find", "(", "\"-darwin\"", ")", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isDarwin", ";", "if", "(", "isdigit", "(", "TT", "[", "Pos", "+", "7", "]", ")", ")", "DarwinVers", "=", "atoi", "(", "&", "TT", "[", "Pos", "+", "7", "]", ")", ";", "else", "DarwinVers", "=", "8", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isELF", ";", "IsLinux", "=", "true", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"cygwin\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isCygwin", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"mingw\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isMingw", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"win32\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isWindows", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"windows\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isWindows", ";", "}", "else", "if", "(", "TT", ".", "find", "(", "\"-cl\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "TargetType", "=", "isDarwin", ";", "DarwinVers", "=", "9", ";", "}", "}", "if", "(", "TargetType", "==", "isDarwin", "||", "Is64Bit", ")", "stackAlignment", "=", "16", ";", "if", "(", "StackAlignment", ")", "stackAlignment", "=", "StackAlignment", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "8", "128", "X86", "X86", "X86", "X86", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "5", "\"-darwin\"", "7", "7", "8", "\"linux\"", "\"cygwin\"", "\"mingw\"", "\"win32\"", "\"windows\"", "\"-cl\"", "9", "16" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "getInsertSubregLikeInputs", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "DefIdx", ",", "RegSubRegPair", "&", "BaseReg", ",", "RegSubRegPairAndIdx", "&", "InsertedReg", ")", "const", "{", "assert", "(", "DefIdx", "<", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "&&", "\"Invalid definition index\"", ")", ";", "assert", "(", "MI", ".", "isInsertSubregLike", "(", ")", "&&", "\"Invalid kind of instruction\"", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VSETLNi32", ":", "const", "MachineOperand", "&", "MOBaseReg", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "const", "MachineOperand", "&", "MOInsertedReg", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "MOInsertedReg", ".", "isUndef", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MOIndex", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "BaseReg", ".", "Reg", "=", "MOBaseReg", ".", "getReg", "(", ")", ";", "BaseReg", ".", "SubReg", "=", "MOBaseReg", ".", "getSubReg", "(", ")", ";", "InsertedReg", ".", "Reg", "=", "MOInsertedReg", ".", "getReg", "(", ")", ";", "InsertedReg", ".", "SubReg", "=", "MOInsertedReg", ".", "getSubReg", "(", ")", ";", "InsertedReg", ".", "SubIdx", "=", "MOIndex", ".", "getImm", "(", ")", "==", "0", "?", "ARM", "::", "ssub_0", ":", "ARM", "::", "ssub_1", ";", "return", "true", ";", "}", "llvm_unreachable", "(", "\"Target dependent opcode missing\"", ")", ";", "}", "</s>" ]

[ "Target-dependent", "implementation", "of", "getInsertSubregInputs", "." ]

[ "ARM", "ARM", "\"Invalid definition index\"", "\"Invalid kind of instruction\"", "ARM::VSETLNi32", "1", "2", "3", "0", "ARM::ssub_0", "ARM::ssub_1", "\"Target dependent opcode missing\"" ]

[]

[ "<s>", "MachineInstrBuilder", "emitInst", "(", "unsigned", "Opc", ",", "unsigned", "DstReg", ")", "{", "return", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DstReg", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "AVRAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "AVRMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "I", ";", "MCInstLowering", ".", "lowerInstruction", "(", "*", "MI", ",", "I", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "I", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "AVR", "AVR", "AVR" ]

[]

[ "<s>", "static", "rtx", "spu_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "op0", ",", "op1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "op0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "ALIGNED_SYMBOL_REF_P", "(", "op0", ")", ")", "{", "op0", "=", "force_reg", "(", "Pmode", ",", "op0", ")", ";", "mark_reg_pointer", "(", "op0", ",", "128", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", ")", "op0", "=", "force_reg", "(", "Pmode", ",", "op0", ")", ";", "if", "(", "ALIGNED_SYMBOL_REF_P", "(", "op1", ")", ")", "{", "op1", "=", "force_reg", "(", "Pmode", ",", "op1", ")", ";", "mark_reg_pointer", "(", "op1", ",", "128", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "REG", ")", "op1", "=", "force_reg", "(", "Pmode", ",", "op1", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "op0", ",", "op1", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "When", "the", "address", "is", "reg", "+", "const_int", ",", "force", "the", "const_int", "into", "a", "register", "." ]

[ "spu", "0", "1", "128", "128" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", ",", "int", ")", "{", "PROMOTE_MODE", "(", "mode", ",", "*", "punsignedp", ",", "type", ")", ";", "return", "mode", ";", "}", "</s>" ]

[ "On", "rs6000", ",", "function", "arguments", "are", "promoted", ",", "as", "are", "function", "return", "values", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "rs6000_split_logical_inner", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ",", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "bool", "complement_final_p", ",", "bool", "complement_op1_p", ",", "bool", "complement_op2_p", ")", "{", "rtx", "bool_rtx", ";", "if", "(", "op2", "&&", "CONST_INT_P", "(", "op2", ")", "&&", "(", "mode", "==", "SImode", "||", "(", "mode", "==", "DImode", "&&", "TARGET_POWERPC64", ")", ")", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", ")", "{", "HOST_WIDE_INT", "mask", "=", "GET_MODE_MASK", "(", "mode", ")", ";", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "op2", ")", "&", "mask", ";", "if", "(", "code", "==", "AND", ")", "{", "if", "(", "value", "==", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "else", "if", "(", "value", "==", "mask", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "op1", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "op1", ")", ")", ";", "return", ";", "}", "}", "else", "if", "(", "code", "==", "IOR", "||", "code", "==", "XOR", ")", "{", "if", "(", "value", "==", "0", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "op1", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "op1", ")", ")", ";", "return", ";", "}", "}", "}", "if", "(", "code", "==", "AND", "&&", "mode", "==", "SImode", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", ")", "{", "emit_insn", "(", "gen_andsi3", "(", "dest", ",", "op1", ",", "op2", ")", ")", ";", "return", ";", "}", "if", "(", "complement_op1_p", ")", "op1", "=", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ";", "if", "(", "complement_op2_p", ")", "op2", "=", "gen_rtx_NOT", "(", "mode", ",", "op2", ")", ";", "if", "(", "!", "complement_op1_p", "&&", "complement_op2_p", ")", "std", "::", "swap", "(", "op1", ",", "op2", ")", ";", "bool_rtx", "=", "(", "(", "code", "==", "NOT", ")", "?", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ":", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op1", ",", "op2", ")", ")", ";", "if", "(", "complement_final_p", ")", "bool_rtx", "=", "gen_rtx_NOT", "(", "mode", ",", "bool_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "bool_rtx", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rs6000_split_logical", "to", "emit", "a", "logical", "instruction", "after", "spliting", "the", "operation", "to", "single", "GPR", "registers", ".", "DEST", "is", "the", "destination", "register", ".", "OP1", "and", "OP2", "are", "the", "input", "source", "registers", ".", "CODE", "is", "the", "base", "operation", "(", "AND", ",", "IOR", ",", "XOR", ",", "NOT", ")", ".", "MODE", "is", "the", "machine", "mode", ".", "If", "COMPLEMENT_FINAL_P", "is", "true", ",", "wrap", "the", "whole", "operation", "with", "NOT", ".", "If", "COMPLEMENT_OP1_P", "is", "true", ",", "wrap", "operand1", "with", "NOT", ".", "If", "COMPLEMENT_OP2_P", "is", "true", ",", "wrap", "operand2", "with", "NOT", "." ]

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

[]

[ "<s>", "static", "bool", "tilepro_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "regno", "<", "TILEPRO_NUM_RETURN_REGS", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_VALUE_REGNO_P", "." ]

[ "tilepro" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "requiresUniformRegister", "(", "MachineFunction", "&", "MF", ",", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "V", ")", ")", "{", "if", "(", "CI", "->", "isInlineAsm", "(", ")", ")", "{", "const", "SIRegisterInfo", "*", "SIRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "TargetLowering", "::", "AsmOperandInfoVector", "TargetConstraints", "=", "ParseConstraints", "(", "MF", ".", "getDataLayout", "(", ")", ",", "Subtarget", "->", "getRegisterInfo", "(", ")", ",", "*", "CI", ")", ";", "for", "(", "auto", "&", "TC", ":", "TargetConstraints", ")", "{", "if", "(", "TC", ".", "Type", "==", "InlineAsm", "::", "isOutput", ")", "{", "ComputeConstraintToUse", "(", "TC", ",", "SDValue", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegForInlineAsmConstraint", "(", "SIRI", ",", "TC", ".", "ConstraintCode", ",", "TC", ".", "ConstraintVT", ")", ".", "second", ";", "if", "(", "RC", "&&", "SIRI", "->", "isSGPRClass", "(", "RC", ")", ")", "return", "true", ";", "}", "}", "}", "}", "SmallPtrSet", "<", "const", "Value", "*", ",", "16", ">", "Visited", ";", "return", "hasCFUser", "(", "V", ",", "Visited", ",", "Subtarget", "->", "getWavefrontSize", "(", ")", ")", ";", "}", "</s>" ]

[ "Allows", "target", "to", "decide", "about", "the", "register", "class", "of", "the", "specific", "value", "that", "is", "live", "outside", "the", "defining", "block", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "16" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_abi_word_mode", "(", "void", ")", "{", "return", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "}", "</s>" ]

[ "The", "mode", "the", "ABI", "uses", "for", "a", "word", ".", "This", "is", "not", "the", "same", "as", "word_mode", "for", "-m32", "-mpowerpc64", ".", "This", "is", "used", "to", "implement", "various", "target", "hooks", "." ]

[ "rs6000" ]

[]