Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "MipsConstantIslands", "::", "isBBInRange", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "DestBB", ",", "unsigned", "MaxDisp", ")", "{", "unsigned", "PCAdj", "=", "4", ";", "unsigned", "BrOffset", "=", "getOffsetOf", "(", "MI", ")", "+", "PCAdj", ";", "unsigned", "DestOffset", "=", "BBInfo", "[", "DestBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Branch of destination \"", "<<", "printMBBReference", "(", "*", "DestBB", ")", "<<", "\" from \"", "<<", "printMBBReference", "(", "*", "MI", "->", "getParent", "(", ")", ")", "<<", "\" max delta=\"", "<<", "MaxDisp", "<<", "\" from \"", "<<", "getOffsetOf", "(", "MI", ")", "<<", "\" to \"", "<<", "DestOffset", "<<", "\" offset \"", "<<", "int", "(", "DestOffset", "-", "BrOffset", ")", "<<", "\"\\t\"", "<<", "*", "MI", ")", ";", "if", "(", "BrOffset", "<=", "DestOffset", ")", "{", "if", "(", "DestOffset", "-", "BrOffset", "<=", "MaxDisp", ")", "return", "true", ";", "}", "else", "{", "if", "(", "BrOffset", "-", "DestOffset", "<=", "MaxDisp", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isBBInRange", "-", "Returns", "true", "if", "the", "distance", "between", "specific", "MI", "and", "specific", "BB", "can", "fit", "in", "MI", "'s", "displacement", "field", "." ]

[ "Mips", "Mips", "4", "\"Branch of destination \"", "\" from \"", "\" max delta=\"", "\" from \"", "\" to \"", "\" offset \"", "\"\\t\"" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "PPCSubTarget", "->", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "const", "Module", "*", "M", "=", "MF", "->", "getFunction", "(", ")", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "if", "(", "M", "->", "getPICLevel", "(", ")", "==", "PICLevel", "::", "SmallPIC", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MoveGOTtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "else", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "unsigned", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_and_GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC::MoveGOTtoLR", "PPC::MFLR", "PPC", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::GPRCRegClass", "PPC::UpdateGBR", "PPC", "PPC::GPRC_and_GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::G8RC_and_G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "void", "DLXDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", ";", "}", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "Constant", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "{", "ConstantSDNode", "*", "ConstNode", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "if", "(", "ConstNode", "->", "isNullValue", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "DLX", "::", "R0", ",", "MVT", "::", "i32", ")", ";", "return", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "}", "if", "(", "ConstNode", "->", "isAllOnesValue", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "DLX", "::", "R1", ",", "MVT", "::", "i32", ")", ";", "return", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "}", "}", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "selectFrameIndex", "(", "Node", ")", ";", "return", ";", "default", ":", "break", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "DLX", "DLX", "\"== \"", "\"\\n\"", "0", "ISD::Constant", "MVT::i32", "DLX::R0", "MVT::i32", "DLX::R1", "MVT::i32", "ISD::FrameIndex" ]

[]

[ "<s>", "bool", "AMDGPUCFGStructurizer", "::", "isReturnBlock", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "MachineInstr", "*", "MI", "=", "getReturnInstr", "(", "MBB", ")", ";", "bool", "IsReturn", "=", "(", "MBB", "->", "succ_size", "(", ")", "==", "0", ")", ";", "if", "(", "MI", ")", "assert", "(", "IsReturn", ")", ";", "else", "if", "(", "IsReturn", ")", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"BB\"", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "\" is return block without RETURN instr\\n\"", ";", ")", ";", "return", "IsReturn", ";", "}", "</s>" ]

[ "Convenience", "function", "that", "returns", "true", "if", "the", "block", "ends", "in", "a", "return", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "0", "\"BB\"", "\" is return block without RETURN instr\\n\"" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ")", "return", "true", ";", "return", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "pa_som_asm_init_sections", "(", "void", ")", "{", "text_section", "=", "get_unnamed_section", "(", "0", ",", "som_output_text_section_asm_op", ",", "NULL", ")", ";", "som_readonly_data_section", "=", "get_unnamed_section", "(", "0", ",", "output_section_asm_op", ",", "\"\\t.SPACE $TEXT$\\n\\t.SUBSPA $LIT$\"", ")", ";", "som_one_only_readonly_data_section", "=", "get_unnamed_section", "(", "0", ",", "som_output_comdat_data_section_asm_op", ",", "\"\\t.SPACE $TEXT$\\n\"", "\"\\t.NSUBSPA $LIT$,QUAD=0,ALIGN=8,\"", "\"ACCESS=0x2c,SORT=16,COMDAT\"", ")", ";", "som_one_only_data_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", ",", "som_output_comdat_data_section_asm_op", ",", "\"\\t.SPACE $PRIVATE$\\n\"", "\"\\t.NSUBSPA $DATA$,QUAD=1,ALIGN=8,\"", "\"ACCESS=31,SORT=24,COMDAT\"", ")", ";", "if", "(", "flag_tm", ")", "som_tm_clone_table_section", "=", "get_unnamed_section", "(", "0", ",", "output_section_asm_op", ",", "\"\\t.SPACE $PRIVATE$\\n\\t.SUBSPA $TM_CLONE_TABLE$\"", ")", ";", "readonly_data_section", "=", "som_readonly_data_section", ";", "exception_section", "=", "data_section", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_INITIALIZE_SECTIONS" ]

[ "pa", "0", "0", "\"\\t.SPACE $TEXT$\\n\\t.SUBSPA $LIT$\"", "0", "\"\\t.SPACE $TEXT$\\n\"", "\"\\t.NSUBSPA $LIT$,QUAD=0,ALIGN=8,\"", "\"ACCESS=0x2c,SORT=16,COMDAT\"", "\"\\t.SPACE $PRIVATE$\\n\"", "\"\\t.NSUBSPA $DATA$,QUAD=1,ALIGN=8,\"", "\"ACCESS=31,SORT=24,COMDAT\"", "0", "\"\\t.SPACE $PRIVATE$\\n\\t.SUBSPA $TM_CLONE_TABLE$\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon early if conversion\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon early if conversion\"" ]

[]

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

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

[ "LC3", "LC3" ]

[]

[ "<s>", "MachineBasicBlock", "*", "AArch64TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "MI", ".", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Unexpected instruction for custom inserter!\"", ")", ";", "case", "AArch64", "::", "F128CSEL", ":", "return", "EmitF128CSEL", "(", "MI", ",", "BB", ")", ";", "case", "TargetOpcode", "::", "STATEPOINT", ":", "MI", ".", "addOperand", "(", "*", "MI", ".", "getMF", "(", ")", ",", "MachineOperand", "::", "CreateReg", "(", "AArch64", "::", "LR", ",", "true", ",", "true", ",", "false", ",", "true", ")", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "return", "emitPatchPoint", "(", "MI", ",", "BB", ")", ";", "case", "AArch64", "::", "CATCHRET", ":", "return", "EmitLoweredCatchRet", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Unexpected instruction for custom inserter!\"", "AArch64::F128CSEL", "AArch64::LR", "AArch64::CATCHRET" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "bool", "isARM", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "const", "ARMBaseInstrInfo", "&", "TII", ",", "int", "NumBytes", ",", "unsigned", "MIFlags", "=", "MachineInstr", "::", "NoFlags", ",", "ARMCC", "::", "CondCodes", "Pred", "=", "ARMCC", "::", "AL", ",", "unsigned", "PredReg", "=", "0", ")", "{", "emitRegPlusImmediate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "ARM", "::", "SP", ",", "ARM", "::", "SP", ",", "NumBytes", ",", "MIFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARMCC::CondCodes", "ARMCC::AL", "0", "ARM", "ARM::SP", "ARM::SP" ]

[]

[ "<s>", "static", "inline", "bool", "fp_valid_at", "(", "HOST_WIDE_INT", "cfa_offset", ")", "{", "const", "struct", "machine_frame_state", "&", "fs", "=", "cfun", "->", "machine", "->", "fs", ";", "if", "(", "fs", ".", "sp_realigned", "&&", "cfa_offset", ">", "fs", ".", "sp_realigned_fp_last", ")", "{", "gcc_assert", "(", "cfa_offset", ">=", "fs", ".", "sp_realigned_offset", ")", ";", "return", "false", ";", "}", "return", "fs", ".", "fp_valid", ";", "}", "</s>" ]

[ "Determine", "if", "the", "frame", "pointer", "is", "valid", "for", "accessing", "the", "CFA_OFFSET", "in", "the", "frame", "save", "area", ".", "The", "register", "is", "saved", "at", "CFA", "-", "CFA_OFFSET", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "canLowerReturn", "(", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CallConv", ",", "SmallVectorImpl", "<", "BaseArgInfo", ">", "&", "Outs", ",", "bool", "IsVarArg", ")", "const", "{", "if", "(", "AMDGPU", "::", "isEntryFunctionCC", "(", "CallConv", ")", ")", "return", "true", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "const", "SITargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "SITargetLowering", ">", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "MF", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "checkReturn", "(", "CCInfo", ",", "Outs", ",", "TLI", ".", "CCAssignFnForReturn", "(", "CallConv", ",", "IsVarArg", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::isEntryFunctionCC", "16", "SI", "SI" ]

[]

[ "<s>", "bool", "ARMLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetMachine", "&", "TM", "=", "Fn", ".", "getTarget", "(", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "RS", "=", "new", "RegScavenger", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "LoadStoreMultipleOpti", "(", "MBB", ")", ";", "Modified", "|=", "MergeReturnIntoLDM", "(", "MBB", ")", ";", "}", "delete", "RS", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "ready_reorder", "(", "rtx_insn", "*", "*", "ready", ",", "int", "nready", ")", "{", "if", "(", "nready", "==", "2", ")", "swap_reorder", "(", "ready", ",", "nready", ")", ";", "else", "if", "(", "nready", ">", "2", ")", "qsort", "(", "ready", ",", "nready", ",", "sizeof", "(", "rtx_insn", "*", ")", ",", "rank_for_reorder", ")", ";", "}", "</s>" ]

[ "Sort", "the", "ready", "list", "READY", "by", "ascending", "priority", ",", "using", "the", "SCHED_REORDER", "macro", "." ]

[ "sh", "2", "2" ]

[]

[ "<s>", "unsigned", "VEAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "GOp", ",", "unsigned", "Kind", ")", "{", "VEOperand", "&", "Op", "=", "(", "VEOperand", "&", ")", "GOp", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK_F32", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "VEOperand", "::", "MorphToF32Reg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_I32", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "VEOperand", "::", "MorphToI32Reg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_F128", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "VEOperand", "::", "MorphToF128Reg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_MISC", ":", "if", "(", "Op", ".", "isImm", "(", ")", "&&", "VEOperand", "::", "MorphToMISCReg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE", "VE", "VEOperand::MorphToF32Reg", "VEOperand::MorphToI32Reg", "VEOperand::MorphToF128Reg", "VEOperand::MorphToMISCReg" ]

[]

[ "<s>", "SMLoc", "getLoc", "(", ")", "const", "{", "return", "getParser", "(", ")", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "source", "location", "of", "the", "point", "where", "the", "field", "was", "defined", "." ]

[ "RV16K" ]

[]

[ "<s>", "bool", "RISCVExpandAtomicPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "RISCVInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "expandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "standard_80387_constant_opcode", "(", "rtx", "x", ")", "{", "switch", "(", "standard_80387_constant_p", "(", "x", ")", ")", "{", "case", "1", ":", "return", "\"fldz\"", ";", "case", "2", ":", "return", "\"fld1\"", ";", "case", "3", ":", "return", "\"fldlg2\"", ";", "case", "4", ":", "return", "\"fldln2\"", ";", "case", "5", ":", "return", "\"fldl2e\"", ";", "case", "6", ":", "return", "\"fldl2t\"", ";", "case", "7", ":", "return", "\"fldpi\"", ";", "case", "8", ":", "case", "9", ":", "return", "\"#\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "opcode", "of", "the", "special", "instruction", "to", "be", "used", "to", "load", "the", "constant", "X", "." ]

[ "i386", "1", "\"fldz\"", "2", "\"fld1\"", "3", "\"fldlg2\"", "4", "\"fldln2\"", "5", "\"fldl2e\"", "6", "\"fldl2t\"", "7", "\"fldpi\"", "8", "9", "\"#\"" ]

[]

[ "<s>", "Register", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "XCore", "::", "R0", ";", "}", "</s>" ]

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

[ "XCore", "XCore::R0" ]

[]

[ "<s>", "tree", "handle_arm_sve_vector_bits_attribute", "(", "tree", "*", "node", ",", "tree", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "*", "no_add_attrs", "=", "true", ";", "tree", "type", "=", "*", "node", ";", "tree", "attr", "=", "lookup_sve_type_attribute", "(", "type", ")", ";", "if", "(", "!", "attr", ")", "{", "error", "(", "\"%qs applied to non-SVE type %qT\"", ",", "\"arm_sve_vector_bits\"", ",", "type", ")", ";", "return", "NULL_TREE", ";", "}", "if", "(", "!", "VECTOR_TYPE_P", "(", "type", ")", ")", "{", "error", "(", "\"%qs applied to non-vector type %qT\"", ",", "\"arm_sve_vector_bits\"", ",", "type", ")", ";", "return", "NULL_TREE", ";", "}", "if", "(", "!", "sizeless_type_p", "(", "type", ")", ")", "{", "error", "(", "\"%qs applied to type %qT, which already has a size\"", ",", "\"arm_sve_vector_bits\"", ",", "type", ")", ";", "return", "NULL_TREE", ";", "}", "tree", "size", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "size", ")", "!=", "INTEGER_CST", ")", "{", "error", "(", "\"%qs requires an integer constant expression\"", ",", "\"arm_sve_vector_bits\"", ")", ";", "return", "NULL_TREE", ";", "}", "unsigned", "HOST_WIDE_INT", "value", "=", "tree_to_uhwi", "(", "size", ")", ";", "if", "(", "maybe_ne", "(", "value", ",", "BITS_PER_SVE_VECTOR", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"unsupported SVE vector size\"", ")", ";", "return", "NULL_TREE", ";", "}", "tree", "new_sve_type_args", "=", "copy_list", "(", "TREE_VALUE", "(", "attr", ")", ")", ";", "tree", "mangled_name_node", "=", "chain_index", "(", "2", ",", "new_sve_type_args", ")", ";", "const", "char", "*", "old_mangled_name", "=", "IDENTIFIER_POINTER", "(", "TREE_VALUE", "(", "mangled_name_node", ")", ")", ";", "char", "*", "new_mangled_name", "=", "xasprintf", "(", "\"9__SVE_VLSI%sLj%dEE\"", ",", "old_mangled_name", ",", "(", "int", ")", "value", ")", ";", "TREE_VALUE", "(", "mangled_name_node", ")", "=", "get_identifier", "(", "new_mangled_name", ")", ";", "free", "(", "new_mangled_name", ")", ";", "tree", "new_type", ";", "tree", "base_type", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "if", "(", "lang_GNU_C", "(", ")", "&&", "VECTOR_BOOLEAN_TYPE_P", "(", "type", ")", ")", "new_type", "=", "build_variant_type_copy", "(", "base_type", ")", ";", "else", "new_type", "=", "build_distinct_type_copy", "(", "base_type", ")", ";", "tree", "acle_name_node", "=", "TREE_CHAIN", "(", "mangled_name_node", ")", ";", "const", "char", "*", "old_type_name", "=", "IDENTIFIER_POINTER", "(", "TREE_VALUE", "(", "acle_name_node", ")", ")", ";", "char", "*", "new_type_name", "=", "xasprintf", "(", "\"%s __attribute__((arm_sve_vector_bits(%d)))\"", ",", "old_type_name", ",", "(", "int", ")", "value", ")", ";", "tree", "decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "new_type_name", ")", ",", "new_type", ")", ";", "DECL_ARTIFICIAL", "(", "decl", ")", "=", "1", ";", "TYPE_NAME", "(", "new_type", ")", "=", "decl", ";", "free", "(", "new_type_name", ")", ";", "if", "(", "!", "VECTOR_BOOLEAN_TYPE_P", "(", "new_type", ")", ")", "TYPE_INDIVISIBLE_P", "(", "new_type", ")", "=", "0", ";", "TYPE_ATTRIBUTES", "(", "new_type", ")", "=", "get_arm_sve_vector_bits_attributes", "(", "TYPE_ATTRIBUTES", "(", "new_type", ")", ",", "new_sve_type_args", ")", ";", "if", "(", "TYPE_ATTRIBUTES", "(", "base_type", ")", "!=", "TYPE_ATTRIBUTES", "(", "type", ")", "||", "TYPE_QUALS", "(", "base_type", ")", "!=", "TYPE_QUALS", "(", "type", ")", ")", "{", "tree", "attrs", "=", "get_arm_sve_vector_bits_attributes", "(", "TYPE_ATTRIBUTES", "(", "type", ")", ",", "new_sve_type_args", ")", ";", "new_type", "=", "build_type_attribute_qual_variant", "(", "new_type", ",", "attrs", ",", "TYPE_QUALS", "(", "type", ")", ")", ";", "}", "if", "(", "TYPE_ALIGN", "(", "base_type", ")", "!=", "TYPE_ALIGN", "(", "type", ")", ")", "new_type", "=", "build_aligned_type", "(", "new_type", ",", "TYPE_ALIGN", "(", "type", ")", ")", ";", "*", "node", "=", "new_type", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "An", "attribute", "callback", "for", "the", "``", "arm_sve_vector_bits", "''", "attribute", "." ]

[ "aarch64", "\"%qs applied to non-SVE type %qT\"", "\"arm_sve_vector_bits\"", "\"%qs applied to non-vector type %qT\"", "\"arm_sve_vector_bits\"", "\"%qs applied to type %qT, which already has a size\"", "\"arm_sve_vector_bits\"", "\"%qs requires an integer constant expression\"", "\"arm_sve_vector_bits\"", "\"unsupported SVE vector size\"", "2", "\"9__SVE_VLSI%sLj%dEE\"", "\"%s __attribute__((arm_sve_vector_bits(%d)))\"", "1", "0" ]

[]

[ "<s>", "void", "avr_output_addr_vec_elt", "(", "FILE", "*", "stream", ",", "int", "value", ")", "{", "progmem_section", "(", ")", ";", "if", "(", "AVR_MEGA", ")", "fprintf", "(", "stream", ",", "\"\\t.word pm(.L%d)\\n\"", ",", "value", ")", ";", "else", "fprintf", "(", "stream", ",", "\"\\trjmp .L%d\\n\"", ",", "value", ")", ";", "jump_tables_size", "++", ";", "}", "</s>" ]

[ "Worker", "function", "for", "`", "ASM_OUTPUT_ADDR_VEC_ELT", "'", "." ]

[ "avr", "\"\\t.word pm(.L%d)\\n\"", "\"\\trjmp .L%d\\n\"" ]

[]

[ "<s>", "bool", "BlackfinAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "O", "<<", "'['", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "']'", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Blackfin", "0" ]

[]

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

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

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

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "CMPri", ":", "case", "ARM", "::", "t2CMPri", ":", "case", "ARM", "::", "tCMPi8", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "ARM", "::", "CMPrr", ":", "case", "ARM", "::", "t2CMPrr", ":", "case", "ARM", "::", "tCMPr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "ARM", "::", "TSTri", ":", "case", "ARM", "::", "t2TSTri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::CMPri", "ARM::t2CMPri", "ARM::tCMPi8", "0", "0", "0", "1", "ARM::CMPrr", "ARM::t2CMPrr", "ARM::tCMPr", "0", "1", "0", "0", "ARM::TSTri", "ARM::t2TSTri", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "int", "pop_data_area", "(", "v850_data_area", "data_area", ")", "{", "if", "(", "data_area_stack", "==", "NULL", ")", "warning", "(", "OPT_Wpragmas", ",", "\"%<#pragma%> GHS endXXX found without \"", "\"previous startXXX\"", ")", ";", "else", "if", "(", "data_area", "!=", "data_area_stack", "->", "data_area", ")", "warning", "(", "OPT_Wpragmas", ",", "\"%<#pragma%> GHS endXXX does not match \"", "\"previous startXXX\"", ")", ";", "else", "{", "data_area_stack_element", "*", "elem", ";", "elem", "=", "data_area_stack", ";", "data_area_stack", "=", "data_area_stack", "->", "prev", ";", "free", "(", "elem", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Remove", "a", "data", "area", "from", "the", "stack", "." ]

[ "v850", "\"%<#pragma%> GHS endXXX found without \"", "\"previous startXXX\"", "\"%<#pragma%> GHS endXXX does not match \"", "\"previous startXXX\"", "1", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "compute_vrsave_mask", "(", ")", "{", "unsigned", "int", "i", ",", "mask", "=", "0", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "if", "(", "regs_ever_live", "[", "i", "]", ")", "mask", "|=", "ALTIVEC_REG_BIT", "(", "i", ")", ";", "if", "(", "mask", "==", "0", ")", "return", "mask", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "if", "(", "call_used_regs", "[", "i", "]", ")", "mask", "|=", "ALTIVEC_REG_BIT", "(", "i", ")", ";", "for", "(", "i", "=", "cfun", "->", "args_info", ".", "vregno", ";", "i", ">=", "ALTIVEC_ARG_MIN_REG", ";", "--", "i", ")", "mask", "&=", "~", "ALTIVEC_REG_BIT", "(", "i", ")", ";", "{", "bool", "yes", "=", "false", ";", "diddle_return_value", "(", "is_altivec_return_reg", ",", "&", "yes", ")", ";", "if", "(", "yes", ")", "mask", "&=", "~", "ALTIVEC_REG_BIT", "(", "ALTIVEC_ARG_RETURN", ")", ";", "}", "return", "mask", ";", "}", "</s>" ]

[ "Return", "a", "32-bit", "mask", "of", "the", "AltiVec", "registers", "we", "need", "to", "set", "in", "VRSAVE", ".", "Bit", "n", "of", "the", "return", "value", "is", "1", "if", "Vn", "is", "live", ".", "The", "MSB", "in", "the", "32-bit", "word", "is", "0", "." ]

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

[]

[ "<s>", "void", "AnalyzeFormalArguments", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "CCAssignFn", "Fn", ")", "{", "PreAnalyzeFormalArguments", "(", "Ins", ",", "Fn", ")", ";", "CCState", "::", "AnalyzeFormalArguments", "(", "Ins", ",", "Fn", ")", ";", "}", "</s>" ]

[ "AnalyzeFormalArguments", "-", "Analyze", "an", "array", "of", "argument", "values", ",", "incorporating", "info", "about", "the", "formals", "into", "this", "state", "." ]

[ "Mips", "ISD::InputArg" ]

[]

[ "<s>", "void", "mt_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "-", "3", ")", "mt_print_operand_simple_address", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "else", "mt_print_operand_simple_address", "(", "file", ",", "addr", ")", ";", "}", "</s>" ]

[ "Implement", "PRINT_OPERAND_ADDRESS", "." ]

[ "mt", "1", "1", "3", "0" ]

[]

[ "<s>", "bool", "isIntDivCheap", "(", "EVT", "VT", ",", "AttributeList", "Attr", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

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

[ "BPF" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreSched2", "(", "PassManagerBase", "&", "PM", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "PM", ".", "add", "(", "createExecutionDependencyFixPass", "(", "&", "ARM", "::", "DPRRegClass", ")", ")", ";", "}", "PM", ".", "add", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createIfConverterPass", "(", ")", ")", ";", "}", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", ")", "PM", ".", "add", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM::DPRRegClass", "ARM" ]

[]

[ "<s>", "static", "void", "s390_regs_ever_clobbered", "(", "char", "regs_ever_clobbered", "[", "]", ")", "{", "basic_block", "cur_bb", ";", "rtx_insn", "*", "cur_insn", ";", "unsigned", "int", "i", ";", "memset", "(", "regs_ever_clobbered", ",", "0", ",", "32", ")", ";", "if", "(", "!", "crtl", "->", "is_leaf", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "regs_ever_clobbered", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", "||", "cfun", "->", "machine", "->", "has_landing_pad_p", ")", "for", "(", "i", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "i", ")", "!=", "INVALID_REGNUM", ";", "i", "++", ")", "if", "(", "crtl", "->", "calls_eh_return", "||", "(", "cfun", "->", "machine", "->", "has_landing_pad_p", "&&", "df_regs_ever_live_p", "(", "EH_RETURN_DATA_REGNO", "(", "i", ")", ")", ")", ")", "regs_ever_clobbered", "[", "EH_RETURN_DATA_REGNO", "(", "i", ")", "]", "=", "1", ";", "if", "(", "crtl", "->", "saves_all_registers", ")", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "!", "call_really_used_regs", "[", "i", "]", ")", "regs_ever_clobbered", "[", "i", "]", "=", "1", ";", "FOR_EACH_BB_FN", "(", "cur_bb", ",", "cfun", ")", "{", "FOR_BB_INSNS", "(", "cur_bb", ",", "cur_insn", ")", "{", "rtx", "pat", ";", "if", "(", "!", "INSN_P", "(", "cur_insn", ")", ")", "continue", ";", "pat", "=", "PATTERN", "(", "cur_insn", ")", ";", "if", "(", "epilogue_completed", "&&", "RTX_FRAME_RELATED_P", "(", "cur_insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "GENERAL_REG_P", "(", "SET_DEST", "(", "pat", ")", ")", ")", "{", "if", "(", "GET_MODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "DImode", "&&", "FP_REG_P", "(", "SET_SRC", "(", "pat", ")", ")", ")", "continue", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "MEM", ")", "continue", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "load_multiple_operation", "(", "pat", ",", "VOIDmode", ")", ")", "continue", ";", "}", "note_stores", "(", "pat", ",", "s390_reg_clobbered_rtx", ",", "regs_ever_clobbered", ")", ";", "}", "}", "}", "</s>" ]

[ "Walks", "through", "all", "basic", "blocks", "of", "the", "current", "function", "looking", "for", "clobbered", "hard", "regs", "using", "s390_reg_clobbered_rtx", ".", "The", "fields", "of", "the", "passed", "integer", "array", "REGS_EVER_CLOBBERED", "are", "set", "to", "one", "for", "each", "of", "those", "regs", "." ]

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

[]

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

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

[ "Mips", "Mips", "0", "1" ]

[]

[ "<s>", "static", "void", "nds32_emit_isr_reset_content", "(", "void", ")", "{", "unsigned", "int", "i", ";", "unsigned", "int", "total_n_vectors", ";", "char", "reset_handler_name", "[", "100", "]", ";", "char", "section_name", "[", "100", "]", ";", "char", "symbol_name", "[", "100", "]", ";", "total_n_vectors", "=", "nds32_isr_vectors", "[", "0", "]", ".", "total_n_vectors", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! RESET HANDLER CONTENT - BEGIN !\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t.rodata\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.align\\t2\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t ! references to jmptbl section entries\\n\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "total_n_vectors", ";", "i", "++", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.word\\t_nds32_jmptbl_%02d\\n\"", ",", "i", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t ! references to vector section entries\\n\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "total_n_vectors", ";", "i", "++", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.word\\t_nds32_vector_%02d\\n\"", ",", "i", ")", ";", "snprintf", "(", "section_name", ",", "sizeof", "(", "section_name", ")", ",", "\".nds32_jmptbl.00\"", ")", ";", "snprintf", "(", "symbol_name", ",", "sizeof", "(", "symbol_name", ")", ",", "\"_nds32_jmptbl_00\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ....................................\\n\"", ")", ";", "nds32_emit_section_head_template", "(", "section_name", ",", "symbol_name", ",", "2", ",", "true", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.word\\t%s\\n\"", ",", "nds32_isr_vectors", "[", "0", "]", ".", "func_name", ")", ";", "nds32_emit_section_tail_template", "(", "symbol_name", ")", ";", "snprintf", "(", "section_name", ",", "sizeof", "(", "section_name", ")", ",", "\".nds32_vector.00\"", ")", ";", "snprintf", "(", "symbol_name", ",", "sizeof", "(", "symbol_name", ")", ",", "\"_nds32_vector_00\"", ")", ";", "snprintf", "(", "reset_handler_name", ",", "sizeof", "(", "reset_handler_name", ")", ",", "\"_nds32_reset\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ....................................\\n\"", ")", ";", "nds32_emit_section_head_template", "(", "section_name", ",", "symbol_name", ",", "floor_log2", "(", "nds32_isr_vector_size", ")", ",", "false", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tj\\t%s ! jump to reset handler\\n\"", ",", "reset_handler_name", ")", ";", "nds32_emit_section_tail_template", "(", "symbol_name", ")", ";", "snprintf", "(", "section_name", ",", "sizeof", "(", "section_name", ")", ",", "\".nds32_nmih\"", ")", ";", "snprintf", "(", "symbol_name", ",", "sizeof", "(", "symbol_name", ")", ",", "\"_nds32_nmih\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ....................................\\n\"", ")", ";", "nds32_emit_section_head_template", "(", "section_name", ",", "symbol_name", ",", "2", ",", "true", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.word\\t%s\\n\"", ",", "(", "strlen", "(", "nds32_isr_vectors", "[", "0", "]", ".", "nmi_name", ")", "==", "0", ")", "?", "\"0\"", ":", "nds32_isr_vectors", "[", "0", "]", ".", "nmi_name", ")", ";", "nds32_emit_section_tail_template", "(", "symbol_name", ")", ";", "snprintf", "(", "section_name", ",", "sizeof", "(", "section_name", ")", ",", "\".nds32_wrh\"", ")", ";", "snprintf", "(", "symbol_name", ",", "sizeof", "(", "symbol_name", ")", ",", "\"_nds32_wrh\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! ....................................\\n\"", ")", ";", "nds32_emit_section_head_template", "(", "section_name", ",", "symbol_name", ",", "2", ",", "true", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.word\\t%s\\n\"", ",", "(", "strlen", "(", "nds32_isr_vectors", "[", "0", "]", ".", "warm_name", ")", "==", "0", ")", "?", "\"0\"", ":", "nds32_isr_vectors", "[", "0", "]", ".", "warm_name", ")", ";", "nds32_emit_section_tail_template", "(", "symbol_name", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t! RESET HANDLER CONTENT - END !\\n\"", ")", ";", "}", "</s>" ]

[ "Function", "to", "emit", "isr", "reset", "handler", "content", ".", "Including", "all", "jmptbl/vector", "references", ",", "jmptbl", "section", ",", "vector", "section", ",", "nmi", "handler", "section", ",", "and", "warm", "handler", "section", "." ]

[ "nds32", "100", "100", "100", "0", "\"\\t! RESET HANDLER CONTENT - BEGIN !\\n\"", "\"\\t.section\\t.rodata\\n\"", "\"\\t.align\\t2\\n\"", "\"\\t ! references to jmptbl section entries\\n\"", "0", "\"\\t.word\\t_nds32_jmptbl_%02d\\n\"", "\"\\t ! references to vector section entries\\n\"", "0", "\"\\t.word\\t_nds32_vector_%02d\\n\"", "\".nds32_jmptbl.00\"", "\"_nds32_jmptbl_00\"", "\"\\t! ....................................\\n\"", "2", "\"\\t.word\\t%s\\n\"", "0", "\".nds32_vector.00\"", "\"_nds32_vector_00\"", "\"_nds32_reset\"", "\"\\t! ....................................\\n\"", "\"\\tj\\t%s ! jump to reset handler\\n\"", "\".nds32_nmih\"", "\"_nds32_nmih\"", "\"\\t! ....................................\\n\"", "2", "\"\\t.word\\t%s\\n\"", "0", "0", "\"0\"", "0", "\".nds32_wrh\"", "\"_nds32_wrh\"", "\"\\t! ....................................\\n\"", "2", "\"\\t.word\\t%s\\n\"", "0", "0", "\"0\"", "0", "\"\\t! RESET HANDLER CONTENT - END !\\n\"" ]

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "RegisterVT", ";", "unsigned", "NumRegisters", ";", "std", "::", "tie", "(", "RegisterVT", ",", "NumRegisters", ")", "=", "handleMaskRegisterForCallingConv", "(", "NumElts", ",", "CC", ",", "Subtarget", ")", ";", "if", "(", "RegisterVT", "!=", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ")", "return", "RegisterVT", ";", "}", "if", "(", "VT", "==", "MVT", "::", "v3f16", "&&", "Subtarget", ".", "hasFP16", "(", ")", ")", "return", "MVT", "::", "v8f16", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "f80", ")", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "Subtarget", ".", "hasX87", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "X86", "X86", "MVT::i1", "MVT::INVALID_SIMPLE_VALUE_TYPE", "MVT::v3f16", "MVT::v8f16", "MVT::f64", "MVT::f80", "MVT::i32" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "HRI", ".", "getMinimalPhysRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "RC", "==", "&", "Hexagon", "::", "PredRegsRegClass", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "return", "true", ";", "}", "continue", ";", "}", "else", "if", "(", "MO", ".", "isRegMask", "(", ")", ")", "{", "for", "(", "unsigned", "PR", ":", "Hexagon", "::", "PredRegsRegClass", ")", "{", "if", "(", "!", "MI", ".", "modifiesRegister", "(", "PR", ",", "&", "HRI", ")", ")", "continue", ";", "Pred", ".", "push_back", "(", "MO", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::PredRegsRegClass", "Hexagon::PredRegsRegClass" ]

[]

[ "<s>", "static", "void", "tilepro_expand_high_multiply", "(", "rtx", "result", ",", "rtx", "op1", ",", "rtx", "op2", ",", "bool", "sign", ")", "{", "rtx", "tmp0", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp3", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp4", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp5", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp6", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp7", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp8", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp9", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp10", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp11", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp12", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp13", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "result_lo", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "sign", ")", "{", "emit_insn", "(", "gen_insn_mulhl_su", "(", "tmp0", ",", "op1", ",", "op2", ")", ")", ";", "emit_insn", "(", "gen_insn_mulhl_su", "(", "tmp1", ",", "op2", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_insn_mulll_uu", "(", "tmp2", ",", "op1", ",", "op2", ")", ")", ";", "emit_insn", "(", "gen_insn_mulhh_ss", "(", "tmp3", ",", "op1", ",", "op2", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_insn_mulhl_uu", "(", "tmp0", ",", "op1", ",", "op2", ")", ")", ";", "emit_insn", "(", "gen_insn_mulhl_uu", "(", "tmp1", ",", "op2", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_insn_mulll_uu", "(", "tmp2", ",", "op1", ",", "op2", ")", ")", ";", "emit_insn", "(", "gen_insn_mulhh_uu", "(", "tmp3", ",", "op1", ",", "op2", ")", ")", ";", "}", "emit_move_insn", "(", "tmp4", ",", "(", "gen_rtx_ASHIFT", "(", "SImode", ",", "tmp0", ",", "GEN_INT", "(", "16", ")", ")", ")", ")", ";", "emit_move_insn", "(", "tmp5", ",", "(", "gen_rtx_ASHIFT", "(", "SImode", ",", "tmp1", ",", "GEN_INT", "(", "16", ")", ")", ")", ")", ";", "emit_move_insn", "(", "tmp6", ",", "(", "gen_rtx_PLUS", "(", "SImode", ",", "tmp4", ",", "tmp5", ")", ")", ")", ";", "emit_move_insn", "(", "result_lo", ",", "(", "gen_rtx_PLUS", "(", "SImode", ",", "tmp2", ",", "tmp6", ")", ")", ")", ";", "emit_move_insn", "(", "tmp7", ",", "gen_rtx_LTU", "(", "SImode", ",", "tmp6", ",", "tmp4", ")", ")", ";", "emit_move_insn", "(", "tmp8", ",", "gen_rtx_LTU", "(", "SImode", ",", "result_lo", ",", "tmp2", ")", ")", ";", "if", "(", "sign", ")", "{", "emit_move_insn", "(", "tmp9", ",", "(", "gen_rtx_ASHIFTRT", "(", "SImode", ",", "tmp0", ",", "GEN_INT", "(", "16", ")", ")", ")", ")", ";", "emit_move_insn", "(", "tmp10", ",", "(", "gen_rtx_ASHIFTRT", "(", "SImode", ",", "tmp1", ",", "GEN_INT", "(", "16", ")", ")", ")", ")", ";", "}", "else", "{", "emit_move_insn", "(", "tmp9", ",", "(", "gen_rtx_LSHIFTRT", "(", "SImode", ",", "tmp0", ",", "GEN_INT", "(", "16", ")", ")", ")", ")", ";", "emit_move_insn", "(", "tmp10", ",", "(", "gen_rtx_LSHIFTRT", "(", "SImode", ",", "tmp1", ",", "GEN_INT", "(", "16", ")", ")", ")", ")", ";", "}", "emit_move_insn", "(", "tmp11", ",", "(", "gen_rtx_PLUS", "(", "SImode", ",", "tmp3", ",", "tmp7", ")", ")", ")", ";", "emit_move_insn", "(", "tmp12", ",", "(", "gen_rtx_PLUS", "(", "SImode", ",", "tmp8", ",", "tmp9", ")", ")", ")", ";", "emit_move_insn", "(", "tmp13", ",", "(", "gen_rtx_PLUS", "(", "SImode", ",", "tmp11", ",", "tmp12", ")", ")", ")", ";", "emit_move_insn", "(", "result", ",", "(", "gen_rtx_PLUS", "(", "SImode", ",", "tmp13", ",", "tmp10", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "high", "multiply", "pattern", "in", "SImode", ".", "RESULT", ",", "OP1", ",", "OP2", "are", "the", "operands", ",", "and", "SIGN", "is", "true", "if", "it", "'s", "a", "signed", "multiply", ",", "and", "false", "if", "it", "'s", "an", "unsigned", "multiply", "." ]

[ "tilepro", "16", "16", "16", "16", "16", "16" ]

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "virtual", "const", "PPCRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "const", "char", "*", "avr_out_tstsi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"tst %D0\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "if", "(", "reg_unused_after", "(", "insn", ",", "op", "[", "0", "]", ")", "&&", "compare_eq_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"or %A0,%B0\"", "CR_TAB", "\"or %A0,%C0\"", "CR_TAB", "\"or %A0,%D0\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "{", "avr_out_compare", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "test", "instruction", "for", "SImode", "." ]

[ "avr", "\"tst %D0\"", "1", "0", "\"or %A0,%B0\"", "\"or %A0,%C0\"", "\"or %A0,%D0\"", "3", "\"\"" ]

[]

[ "<s>", "bool", "update", "(", "int", "O", ",", "int", "M", ")", "{", "UpdateType", "Type", "=", "classifyUpdateByMask", "(", "M", ")", ";", "if", "(", "Type", "==", "Intermixed", ")", "return", "false", ";", "if", "(", "Start", "==", "INT_MIN", ")", "{", "Start", "=", "Stop", "=", "O", ";", "updateMask", "(", "M", ")", ";", "return", "true", ";", "}", "else", "if", "(", "Type", "==", "Descending", "&&", "O", "==", "Start", "-", "4", ")", "{", "Start", "-=", "4", ";", "updateMask", "(", "M", ")", ";", "return", "true", ";", "}", "else", "if", "(", "Type", "==", "Ascending", "&&", "O", "==", "Stop", "+", "4", ")", "{", "Stop", "+=", "4", ";", "updateMask", "(", "M", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Digest", "more", "data", "." ]

[ "M68k", "4", "4", "4", "4" ]

[]

[ "<s>", "static", "bool", "nvptx_split_reg_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "mode", "==", "TImode", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Like", "maybe_split_mode", ",", "but", "only", "return", "whether", "or", "not", "the", "mode", "needs", "to", "be", "split", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "!", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "{", "ix86_emit_save_reg_using_mov", "(", "word_mode", ",", "regno", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "POINTER", "+", "OFFSET", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "AMDGPUIntrinsicInfo", "::", "isOverloaded", "(", "unsigned", "id", ")", "const", "{", "}", "</s>" ]

[ "Returns", "true", "if", "the", "intrinsic", "can", "be", "overloaded", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

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

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

[ "Comet2", "Comet2", "Comet2" ]

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "TOYMCInstLower", "MCInstLowering", "(", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ",", "*", "this", ")", ";", "do", "{", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "I", "++", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "}", "while", "(", "(", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY" ]

[]

[ "<s>", "bool", "ix86_expand_vecmul_qihi", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "machine_mode", "himode", ",", "qimode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "hop1", ",", "hop2", ",", "hdest", ";", "rtx", "(", "*", "gen_extend", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_truncate", ")", "(", "rtx", ",", "rtx", ")", ";", "if", "(", "qimode", "==", "E_V64QImode", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512BW", ")", "return", "false", ";", "if", "(", "(", "qimode", "==", "V8QImode", "||", "qimode", "==", "V16QImode", ")", "&&", "!", "TARGET_AVX512VL", ")", "return", "false", ";", "if", "(", "qimode", "==", "V32QImode", "&&", "(", "TARGET_PREFER_AVX128", "||", "TARGET_PREFER_AVX256", ")", ")", "return", "false", ";", "switch", "(", "qimode", ")", "{", "case", "E_V8QImode", ":", "himode", "=", "V8HImode", ";", "gen_extend", "=", "gen_zero_extendv8qiv8hi2", ";", "gen_truncate", "=", "gen_truncv8hiv8qi2", ";", "break", ";", "case", "E_V16QImode", ":", "himode", "=", "V16HImode", ";", "gen_extend", "=", "gen_zero_extendv16qiv16hi2", ";", "gen_truncate", "=", "gen_truncv16hiv16qi2", ";", "break", ";", "case", "E_V32QImode", ":", "himode", "=", "V32HImode", ";", "gen_extend", "=", "gen_zero_extendv32qiv32hi2", ";", "gen_truncate", "=", "gen_truncv32hiv32qi2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "hop1", "=", "gen_reg_rtx", "(", "himode", ")", ";", "hop2", "=", "gen_reg_rtx", "(", "himode", ")", ";", "hdest", "=", "gen_reg_rtx", "(", "himode", ")", ";", "emit_insn", "(", "gen_extend", "(", "hop1", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_extend", "(", "hop2", ",", "op2", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "hdest", ",", "simplify_gen_binary", "(", "MULT", ",", "himode", ",", "hop1", ",", "hop2", ")", ")", ")", ";", "emit_insn", "(", "gen_truncate", "(", "dest", ",", "hdest", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Optimize", "vector", "MUL", "generation", "for", "V8QI", ",", "V16QI", "and", "V32QI", "under", "TARGET_AVX512BW", ".", "i.e", ".", "for", "v16qi", "a", "*", "b", ",", "it", "has", "vpmovzxbw", "ymm2", ",", "xmm0", "vpmovzxbw", "ymm3", ",", "xmm1", "vpmullw", "ymm4", ",", "ymm2", ",", "ymm3", "vpmovwb", "xmm0", ",", "ymm4", "it", "would", "take", "less", "instructions", "than", "ix86_expand_vecop_qihi", ".", "Return", "true", "if", "success", "." ]

[ "i386" ]

[]

[ "<s>", "MCSymbol", "*", "AArch64MCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "return", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "section", "*", "pa_som_tm_clone_table_section", "(", "void", ")", "{", "return", "som_tm_clone_table_section", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_TM_CLONE_TABLE_SECTION", "." ]

[ "pa" ]

[]

[ "<s>", "static", "MachineInstr", "*", "getVRegDef", "(", "unsigned", "Reg", ",", "const", "MachineInstr", "*", "Insert", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "LiveIntervals", "&", "LIS", ")", "{", "if", "(", "MachineInstr", "*", "Def", "=", "MRI", ".", "getUniqueVRegDef", "(", "Reg", ")", ")", "return", "Def", ";", "if", "(", "const", "VNInfo", "*", "ValNo", "=", "LIS", ".", "getInterval", "(", "Reg", ")", ".", "getVNInfoBefore", "(", "LIS", ".", "getInstructionIndex", "(", "*", "Insert", ")", ")", ")", "return", "LIS", ".", "getInstructionFromIndex", "(", "ValNo", "->", "def", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "getVRegDef", "-", "Return", "the", "machine", "instr", "that", "defines", "the", "specified", "virtual", "register", "or", "null", "if", "none", "is", "found", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "inline", "bool", "is_naked_func", "(", "tree", "decl", "=", "current_function_decl", ")", "{", "return", "has_attr", "(", "ATTR_NAKED", ",", "decl", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "``", "naked", "''", "attribute", "." ]

[ "msp430" ]

[]

[ "<s>", "bool", "RISCVTargetMachine", "::", "isNoopAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DstAS", ")", "const", "{", "const", "bool", "SrcIsCheri", "=", "isCheriPointer", "(", "SrcAS", ",", "nullptr", ")", ";", "const", "bool", "DestIsCheri", "=", "isCheriPointer", "(", "DstAS", ",", "nullptr", ")", ";", "if", "(", "(", "SrcIsCheri", "||", "DestIsCheri", ")", "&&", "(", "SrcIsCheri", "!=", "DestIsCheri", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "cast", "between", "SrcAS", "and", "DestAS", "is", "a", "noop", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "int", "function_arg_slotno", "(", "const", "struct", "sparc_args", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ",", "int", "incoming_p", ",", "int", "*", "pregno", ",", "int", "*", "ppadding", ")", "{", "int", "regbase", "=", "(", "incoming_p", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ")", ";", "int", "slotno", "=", "cum", "->", "words", ";", "enum", "mode_class", "mclass", ";", "int", "regno", ";", "*", "ppadding", "=", "0", ";", "if", "(", "type", "&&", "TREE_ADDRESSABLE", "(", "type", ")", ")", "return", "-", "1", ";", "if", "(", "TARGET_ARCH32", "&&", "mode", "==", "BLKmode", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", "%", "PARM_BOUNDARY", "!=", "0", ")", "return", "-", "1", ";", "if", "(", "TARGET_ARCH64", "&&", "(", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ")", ">=", "128", "&&", "(", "slotno", "&", "1", ")", "!=", "0", ")", "slotno", "++", ",", "*", "ppadding", "=", "1", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "REAL_TYPE", ")", "{", "gcc_assert", "(", "mode", "==", "BLKmode", ")", ";", "}", "else", "{", "gcc_assert", "(", "mode", "!=", "BLKmode", ")", ";", "mclass", "=", "MODE_FLOAT", ";", "}", "}", "switch", "(", "mclass", ")", "{", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "TARGET_ARCH64", "&&", "TARGET_FPU", "&&", "named", ")", "{", "if", "(", "slotno", ">=", "SPARC_FP_ARG_MAX", ")", "return", "-", "1", ";", "regno", "=", "SPARC_FP_ARG_FIRST", "+", "slotno", "*", "2", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "regno", "++", ";", "break", ";", "}", "case", "MODE_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "slotno", ">=", "SPARC_INT_ARG_MAX", ")", "return", "-", "1", ";", "regno", "=", "regbase", "+", "slotno", ";", "break", ";", "case", "MODE_RANDOM", ":", "if", "(", "mode", "==", "VOIDmode", ")", "return", "-", "1", ";", "gcc_assert", "(", "mode", "==", "BLKmode", ")", ";", "if", "(", "TARGET_ARCH32", "||", "!", "type", "||", "(", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", ")", "{", "if", "(", "slotno", ">=", "SPARC_INT_ARG_MAX", ")", "return", "-", "1", ";", "regno", "=", "regbase", "+", "slotno", ";", "}", "else", "{", "int", "intregs_p", "=", "0", ",", "fpregs_p", "=", "0", ",", "packed_p", "=", "0", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "fpregs_p", "=", "1", ";", "else", "scan_record_type", "(", "type", ",", "&", "intregs_p", ",", "&", "fpregs_p", ",", "&", "packed_p", ")", ";", "if", "(", "packed_p", "||", "!", "named", ")", "fpregs_p", "=", "0", ",", "intregs_p", "=", "1", ";", "if", "(", "fpregs_p", "&&", "slotno", ">=", "SPARC_FP_ARG_MAX", ")", "return", "-", "1", ";", "if", "(", "!", "fpregs_p", "&&", "intregs_p", "&&", "slotno", ">=", "SPARC_INT_ARG_MAX", ")", "return", "-", "1", ";", "return", "slotno", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "*", "pregno", "=", "regno", ";", "return", "slotno", ";", "}", "</s>" ]

[ "Compute", "the", "slot", "number", "to", "pass", "an", "argument", "in", ".", "Return", "the", "slot", "number", "or", "-1", "if", "passing", "on", "the", "stack", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "INCOMING_P", "is", "zero", "for", "FUNCTION_ARG", ",", "nonzero", "for", "FUNCTION_INCOMING_ARG", ".", "*", "PREGNO", "records", "the", "register", "number", "to", "use", "if", "scalar", "type", ".", "*", "PPADDING", "records", "the", "amount", "of", "padding", "needed", "in", "words", "." ]

[ "sparc", "0", "1", "0", "1", "128", "1", "0", "1", "1", "2", "4", "1", "1", "1", "0", "0", "0", "1", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "aarch64_option_restore", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "opts", "->", "x_explicit_tune_core", "=", "ptr", "->", "x_explicit_tune_core", ";", "selected_tune", "=", "aarch64_get_tune_cpu", "(", "ptr", "->", "x_explicit_tune_core", ")", ";", "opts", "->", "x_explicit_arch", "=", "ptr", "->", "x_explicit_arch", ";", "selected_arch", "=", "aarch64_get_arch", "(", "ptr", "->", "x_explicit_arch", ")", ";", "opts", "->", "x_aarch64_override_tune_string", "=", "ptr", "->", "x_aarch64_override_tune_string", ";", "aarch64_override_options_internal", "(", "opts", ")", ";", "}", "</s>" ]

[ "Implements", "TARGET_OPTION_RESTORE", ".", "Restore", "the", "backend", "codegen", "decisions", "using", "the", "information", "saved", "in", "PTR", "." ]

[ "aarch64" ]

[]

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

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

[ "LoongArch" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "uint32_t", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "static_cast", "<", "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", "." ]

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

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "{", "llvm_unreachable", "(", "\"No isMem\"", ")", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "Hexagon", "\"No isMem\"" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "CI", ",", "unsigned", "IntrID", ")", "const", "{", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "0", ")", ";", "Info", ".", "align", "=", "0", ";", "const", "ConstantInt", "*", "Vol", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "4", ")", ")", ";", "Info", ".", "vol", "=", "!", "Vol", "||", "!", "Vol", "->", "isZero", "(", ")", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "true", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "4" ]

[]

[ "<s>", "void", "AlphaInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "Alpha", "::", "F4RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDS", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "F8RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDT", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "GPRCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDQ", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "llvm_unreachable", "(", "\"Unhandled register class\"", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "Alpha", "Alpha", "Alpha::F4RCRegisterClass", "Alpha::LDS", "Alpha::F31", "Alpha::F8RCRegisterClass", "Alpha::LDT", "Alpha::F31", "Alpha::GPRCRegisterClass", "Alpha::LDQ", "Alpha::F31", "\"Unhandled register class\"" ]

[]

[ "<s>", "static", "bool", "mmix_rtx_costs", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "int", "code", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "TARGET_RTX_COSTS", "." ]

[ "mmix" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", ";", "}", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "addPass", "(", "createARMLowOverheadLoopsPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "IsPCRel", ",", "nullptr", ",", "IsLittleEndian", ",", "true", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "!", "IsLittleEndian", ")", "{", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "(", "Offset", "+", "FullSizeBytes", ")", "<=", "DataSize", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FullSizeBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "FullSizeBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Invalid fixup offset!\"", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "if", "(", "Ins", ".", "empty", "(", ")", ")", "return", "Chain", ";", "else", "{", "report_fatal_error", "(", "\"ISRs cannot have arguments\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::InputArg", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot have arguments\"" ]

[]

[ "<s>", "static", "int", "spu_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "rtx", "set", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_blockage", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_blockage", ")", "return", "0", ";", "if", "(", "(", "INSN_P", "(", "insn", ")", "&&", "get_attr_length", "(", "insn", ")", "==", "0", ")", "||", "(", "INSN_P", "(", "dep_insn", ")", "&&", "get_attr_length", "(", "dep_insn", ")", "==", "0", ")", ")", "return", "0", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "&&", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", ")", "return", "8", ";", "if", "(", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_hbr", ")", "&&", "(", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_hbr", ")", ")", "return", "2", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", ")", "return", "0", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "target", "=", "get_branch_target", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "target", ")", "!=", "REG", "||", "!", "set_of", "(", "target", ",", "insn", ")", ")", "return", "cost", "-", "2", ";", "return", "cost", ";", "}", "if", "(", "CALL_P", "(", "dep_insn", ")", ")", "return", "cost", "-", "2", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR__return", "&&", "(", "set", "=", "single_set", "(", "dep_insn", ")", ")", "&&", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "REG", "&&", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", "==", "LINK_REGISTER_REGNUM", ")", "return", "20", ";", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "dep_type", "==", "REG_DEP_ANTI", ")", "return", "insn_sched_cost", "(", "dep_insn", ")", "-", "3", ";", "return", "cost", ";", "}", "</s>" ]

[ "INSN", "is", "dependent", "on", "DEP_INSN", "." ]

[ "spu", "0", "0", "0", "0", "8", "2", "0", "2", "2", "20", "3" ]

[]

[ "<s>", "bool", "valid_sf_si_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_ALLOW_SF_SUBREG", ")", "return", "true", ";", "if", "(", "mode", "!=", "SFmode", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_INT", ")", "return", "true", ";", "if", "(", "!", "SUBREG_P", "(", "src", ")", "||", "!", "sf_subreg_operand", "(", "src", ",", "mode", ")", ")", "return", "true", ";", "if", "(", "SUBREG_P", "(", "dest", ")", ")", "{", "rtx", "dest_subreg", "=", "SUBREG_REG", "(", "dest", ")", ";", "rtx", "src_subreg", "=", "SUBREG_REG", "(", "src", ")", ";", "return", "GET_MODE", "(", "dest_subreg", ")", "==", "GET_MODE", "(", "src_subreg", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "a", "SFmode", "or", "SImode", "move", "can", "be", "done", "without", "converting", "one", "mode", "to", "another", ".", "This", "arrises", "when", "we", "have", ":", "(", "SUBREG", ":", "SF", "(", "REG", ":", "SI", "...", ")", ")", "(", "SUBREG", ":", "SI", "(", "REG", ":", "SF", "...", ")", ")", "and", "one", "of", "the", "values", "is", "in", "a", "floating", "point/vector", "register", ",", "where", "SFmode", "scalars", "are", "stored", "in", "DFmode", "format", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "aarch64_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gr_saved", "=", "cfun", "->", "va_list_gpr_size", ";", "int", "vr_saved", "=", "cfun", "->", "va_list_fpr_size", ";", "local_cum", "=", "*", "cum", ";", "aarch64_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "arg", ")", ";", "if", "(", "cfun", "->", "va_list_gpr_size", ")", "gr_saved", "=", "MIN", "(", "NUM_ARG_REGS", "-", "local_cum", ".", "aapcs_ncrn", ",", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", ")", "vr_saved", "=", "MIN", "(", "NUM_FP_ARG_REGS", "-", "local_cum", ".", "aapcs_nvrn", ",", "cfun", "->", "va_list_fpr_size", "/", "UNITS_PER_VREG", ")", ";", "if", "(", "!", "TARGET_FLOAT", ")", "{", "gcc_assert", "(", "local_cum", ".", "aapcs_nvrn", "==", "0", ")", ";", "vr_saved", "=", "0", ";", "}", "if", "(", "!", "no_rtl", ")", "{", "if", "(", "gr_saved", ">", "0", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "gr_saved", "*", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "aapcs_ncrn", "+", "R0_REGNUM", ",", "mem", ",", "gr_saved", ")", ";", "}", "if", "(", "vr_saved", ">", "0", ")", "{", "machine_mode", "mode", "=", "TImode", ";", "int", "off", ",", "i", ",", "vr_start", ";", "off", "=", "-", "ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "off", "-=", "vr_saved", "*", "UNITS_PER_VREG", ";", "vr_start", "=", "V0_REGNUM", "+", "local_cum", ".", "aapcs_nvrn", ";", "for", "(", "i", "=", "0", ";", "i", "<", "vr_saved", ";", "++", "i", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "off", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "aarch64_emit_move", "(", "mem", ",", "gen_rtx_REG", "(", "mode", ",", "vr_start", "+", "i", ")", ")", ";", "off", "+=", "UNITS_PER_VREG", ";", "}", "}", "}", "cfun", "->", "machine", "->", "frame", ".", "saved_varargs_size", "=", "(", "ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "+", "vr_saved", "*", "UNITS_PER_VREG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

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

[]

[ "<s>", "rtx", "aarch64_convert_sve_data_to_pred", "(", "rtx", "target", ",", "machine_mode", "mode", ",", "rtx", "src", ")", "{", "machine_mode", "src_mode", "=", "GET_MODE", "(", "src", ")", ";", "return", "aarch64_sve_emit_int_cmp", "(", "target", ",", "mode", ",", "NE", ",", "src_mode", ",", "src", ",", "CONST0_RTX", "(", "src_mode", ")", ")", ";", "}", "</s>" ]

[ "Use", "a", "comparison", "to", "convert", "integer", "vector", "SRC", "into", "MODE", ",", "which", "is", "the", "corresponding", "SVE", "predicate", "mode", ".", "Use", "TARGET", "for", "the", "result", "if", "it", "'s", "nonnull", "and", "convenient", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "HSAILRegisterInfo", "::", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "HSAILMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "HSAILMachineFunctionInfo", ">", "(", ")", ";", "return", "Info", "->", "hasSpilledCRs", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

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

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "CPUString", "=", "HEXAGON_MC", "::", "selectHexagonCPU", "(", "getTargetTriple", "(", ")", ",", "CPU", ")", ";", "static", "std", "::", "map", "<", "StringRef", ",", "HexagonArchEnum", ">", "CpuTable", "{", "{", "\"hexagonv4\"", ",", "V4", "}", ",", "{", "\"hexagonv5\"", ",", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "V60", "}", ",", "}", ";", "auto", "foundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "foundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "foundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVXOps", "=", "false", ";", "UseHVXDblOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "EnableHexagonHVX", ".", "getPosition", "(", ")", ")", "UseHVXOps", "=", "EnableHexagonHVX", ";", "if", "(", "EnableHexagonHVXDouble", ".", "getPosition", "(", ")", ")", "UseHVXDblOps", "=", "EnableHexagonHVXDouble", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "HEXAGON_MC::selectHexagonCPU", "Hexagon", "\"hexagonv4\"", "\"hexagonv5\"", "\"hexagonv55\"", "\"hexagonv60\"", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "function_expander", "::", "try_negating_argument", "(", "unsigned", "int", "argno", ",", "machine_mode", "mode", ")", "{", "rtx", "x", "=", "args", "[", "argno", "]", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", "mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "x", "=", "simplify_unary_operation", "(", "NEG", ",", "mode", ",", "x", ",", "mode", ")", ";", "if", "(", "!", "x", ")", "return", "false", ";", "args", "[", "argno", "]", "=", "x", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "negation", "of", "argument", "ARGNO", "can", "be", "folded", "away", ",", "replacing", "it", "with", "the", "negated", "value", "if", "so", ".", "MODE", "is", "the", "associated", "vector", "mode", ",", "but", "the", "argument", "could", "be", "a", "single", "element", ".", "The", "main", "case", "this", "handles", "is", "constant", "arguments", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_SaveList", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "default", ":", "break", ";", "}", "bool", "IsNaCl", "=", "Subtarget", ".", "isTargetNaCl", "(", ")", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "IsNaCl", ")", "{", "if", "(", "CallsEHReturn", ")", "return", "CSR_NaCl64EHRet_SaveList", ";", "return", "CSR_NaCl64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"MachineFunction required\"", "X86", "X86" ]

[]

[ "<s>", "void", "AGCFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "AGC", "AGC" ]

[]

[ "<s>", "machine_mode", "select_cc_mode", "(", "enum", "rtx_code", "op", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "UNORDERED", ":", "case", "ORDERED", ":", "case", "UNLT", ":", "case", "UNLE", ":", "case", "UNGT", ":", "case", "UNGE", ":", "case", "UNEQ", ":", "case", "LTGT", ":", "return", "CCFPmode", ";", "case", "LT", ":", "case", "LE", ":", "case", "GT", ":", "case", "GE", ":", "return", "CCFPEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "||", "GET_CODE", "(", "x", ")", "==", "MINUS", "||", "GET_CODE", "(", "x", ")", "==", "NEG", "||", "GET_CODE", "(", "x", ")", "==", "ASHIFT", ")", "&&", "y", "==", "const0_rtx", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "return", "CCXNZmode", ";", "else", "return", "CCNZmode", ";", "}", "else", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "NOT", "&&", "y", "==", "constm1_rtx", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "return", "CCXCmode", ";", "else", "return", "CCCmode", ";", "}", "if", "(", "!", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "{", "if", "(", "GET_CODE", "(", "y", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_ADDV", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_SUBV", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_NEGV", ")", ")", "return", "CCVmode", ";", "else", "return", "CCCmode", ";", "}", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "return", "CCXmode", ";", "else", "return", "CCmode", ";", "}", "}", "</s>" ]

[ "Given", "a", "comparison", "code", "(", "EQ", ",", "NE", ",", "etc", ".", ")", "and", "the", "first", "operand", "of", "a", "COMPARE", ",", "return", "the", "mode", "to", "be", "used", "for", "the", "comparison", ".", "For", "floating-point", ",", "CCFP", "[", "E", "]", "mode", "is", "used", ".", "CC_NOOVmode", "should", "be", "used", "when", "the", "first", "operand", "is", "a", "PLUS", ",", "MINUS", ",", "NEG", ",", "or", "ASHIFT", ".", "CCmode", "should", "be", "used", "when", "no", "special", "processing", "is", "needed", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyCFGStackify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "releaseMemory", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "placeMarkers", "(", "MF", ")", ";", "rewriteDepthImmediates", "(", "MF", ")", ";", "fixEndsAtEndOfFunction", "(", "MF", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "AppendEndToFunction", "(", "MF", ",", "TII", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "const", "AMDGPUAAResult", "&", "getResult", "(", ")", "const", "{", "return", "*", "Result", ";", "}", "</s>" ]

[ "Get", "the", "result", "of", "an", "analysis", "pass", "for", "a", "given", "IR", "unit", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "JVMAssemblerImpl", "*", "getInst", "(", ")", "{", "if", "(", "!", "inst", ")", "{", "inst", "=", "new", "JVMAssemblerImpl", "(", ")", ";", "}", "return", "inst", ";", "}", "</s>" ]

[ "If", "this", "is", "a", "normal", "dependency", ",", "returns", "the", "instruction", "that", "is", "depended", "on", "." ]

[ "JVM", "JVM", "JVM" ]

[]

[ "<s>", "void", "SPURegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "int", "LinkSlotOffset", "=", "SPUFrameInfo", "::", "stackSlotSize", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SPU", "::", "RET", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "assert", "(", "(", "FrameSize", "&", "0xf", ")", "==", "0", "&&", "\"SPURegisterInfo::emitEpilogue: FrameSize not aligned\"", ")", ";", "if", "(", "FrameSize", ">", "0", "||", "MFI", "->", "hasCalls", "(", ")", ")", "{", "FrameSize", "=", "FrameSize", "+", "SPUFrameInfo", "::", "minStackSize", "(", ")", ";", "if", "(", "isS10Constant", "(", "FrameSize", "+", "LinkSlotOffset", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQDr128", ")", ",", "SPU", "::", "R0", ")", ".", "addImm", "(", "FrameSize", "+", "LinkSlotOffset", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "AIr32", ")", ",", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "if", "(", "FrameSize", "<=", "(", "1", "<<", "16", ")", "-", "1", "&&", "FrameSize", ">=", "-", "(", "1", "<<", "16", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "STQDr128", ")", ",", "SPU", "::", "R2", ")", ".", "addImm", "(", "16", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "ILr32", ")", ",", "SPU", "::", "R2", ")", ".", "addImm", "(", "FrameSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "Ar32", ")", ",", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQDr128", ")", ",", "SPU", "::", "R0", ")", ".", "addImm", "(", "16", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "SFIr32", ")", ",", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ".", "addImm", "(", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQXr128", ")", ",", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "}", "else", "{", "std", "::", "string", "msg", ";", "raw_string_ostream", "Msg", "(", "msg", ")", ";", "Msg", "<<", "\"Unhandled frame size: \"", "<<", "FrameSize", ";", "llvm_report_error", "(", "Msg", ".", "str", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::RET", "\"Can only insert epilog into returning blocks\"", "0xf", "0", "\"SPURegisterInfo::emitEpilogue: FrameSize not aligned\"", "0", "SPU", "SPU::LQDr128", "SPU::R0", "SPU::R1", "SPU::AIr32", "SPU::R1", "SPU::R1", "1", "16", "1", "1", "16", "SPU::STQDr128", "SPU::R2", "16", "SPU::R1", "SPU::ILr32", "SPU::R2", "SPU::Ar32", "SPU::R1", "SPU::R1", "SPU::R2", "SPU::LQDr128", "SPU::R0", "16", "SPU::R2", "SPU::SFIr32", "SPU::R2", "SPU::R2", "16", "SPU::LQXr128", "SPU::R2", "SPU::R2", "SPU::R1", "\"Unhandled frame size: \"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isFsqrtCheap", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "DAG", ".", "getNodeIfExists", "(", "X86ISD", "::", "FRSQRT", ",", "DAG", ".", "getVTList", "(", "VT", ")", ",", "Op", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "Subtarget", ".", "hasFastVectorFSQRT", "(", ")", ";", "return", "Subtarget", ".", "hasFastScalarFSQRT", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SQRT", "(", "X", ")", "should", "n't", "be", "replaced", "with", "X", "*", "RSQRT", "(", "X", ")", "." ]

[ "X86", "X86", "X86ISD::FRSQRT" ]

[]

[ "<s>", "static", "bool", "ix86_expand_vecop_qihi2", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "machine_mode", "himode", ",", "qimode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "hop1", ",", "hop2", ",", "hdest", ";", "rtx", "(", "*", "gen_extend", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_truncate", ")", "(", "rtx", ",", "rtx", ")", ";", "bool", "uns_p", "=", "(", "code", "==", "ASHIFTRT", ")", "?", "false", ":", "true", ";", "if", "(", "qimode", "==", "E_V64QImode", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512BW", ")", "return", "false", ";", "if", "(", "(", "qimode", "==", "V8QImode", "||", "qimode", "==", "V16QImode", ")", "&&", "!", "TARGET_AVX512VL", ")", "return", "false", ";", "if", "(", "qimode", "==", "V32QImode", "&&", "(", "TARGET_PREFER_AVX128", "||", "TARGET_PREFER_AVX256", ")", ")", "return", "false", ";", "switch", "(", "qimode", ")", "{", "case", "E_V8QImode", ":", "himode", "=", "V8HImode", ";", "gen_extend", "=", "uns_p", "?", "gen_zero_extendv8qiv8hi2", ":", "gen_extendv8qiv8hi2", ";", "gen_truncate", "=", "gen_truncv8hiv8qi2", ";", "break", ";", "case", "E_V16QImode", ":", "himode", "=", "V16HImode", ";", "gen_extend", "=", "uns_p", "?", "gen_zero_extendv16qiv16hi2", ":", "gen_extendv16qiv16hi2", ";", "gen_truncate", "=", "gen_truncv16hiv16qi2", ";", "break", ";", "case", "E_V32QImode", ":", "himode", "=", "V32HImode", ";", "gen_extend", "=", "uns_p", "?", "gen_zero_extendv32qiv32hi2", ":", "gen_extendv32qiv32hi2", ";", "gen_truncate", "=", "gen_truncv32hiv32qi2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "hop1", "=", "gen_reg_rtx", "(", "himode", ")", ";", "hop2", "=", "gen_reg_rtx", "(", "himode", ")", ";", "hdest", "=", "gen_reg_rtx", "(", "himode", ")", ";", "emit_insn", "(", "gen_extend", "(", "hop1", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_extend", "(", "hop2", ",", "op2", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "hdest", ",", "simplify_gen_binary", "(", "code", ",", "himode", ",", "hop1", ",", "hop2", ")", ")", ")", ";", "emit_insn", "(", "gen_truncate", "(", "dest", ",", "hdest", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "similar", "as", "ix86_expand_vecop_qihi", ",", "but", "optimized", "under", "AVX512BW", "by", "using", "vpmovwb", ".", "For", "example", ",", "optimize", "vector", "MUL", "generation", "like", "vpmovzxbw", "ymm2", ",", "xmm0", "vpmovzxbw", "ymm3", ",", "xmm1", "vpmullw", "ymm4", ",", "ymm2", ",", "ymm3", "vpmovwb", "xmm0", ",", "ymm4", "it", "would", "take", "less", "instructions", "than", "ix86_expand_vecop_qihi", ".", "Return", "true", "if", "success", "." ]

[ "i386" ]

[]

[ "<s>", "void", "mmix_asm_output_reg_pop", "(", "FILE", "*", "stream", ",", "int", "regno", ")", "{", "fprintf", "(", "stream", ",", "\"\\tLDOU %s,%s,0\\n\\tINCL %s,8\\n\"", ",", "reg_names", "[", "MMIX_OUTPUT_REGNO", "(", "regno", ")", "]", ",", "reg_names", "[", "MMIX_STACK_POINTER_REGNUM", "]", ",", "reg_names", "[", "MMIX_STACK_POINTER_REGNUM", "]", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_REG_POP", "." ]

[ "mmix", "\"\\tLDOU %s,%s,0\\n\\tINCL %s,8\\n\"" ]

[]

[ "<s>", "static", "unsigned", "int", "avr_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "REG_CC", "&&", "mode", "==", "CCmode", ")", "return", "1", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", ".", "CCmode", "is", "four", "units", "for", "historical", "reasons", ".", "If", "this", "hook", "is", "not", "defined", ",", "TARGET_HARD_REGNO_NREGS", "reports", "that", "CCmode", "requires", "four", "registers", ".", "Define", "this", "hook", "to", "allow", "CCmode", "to", "fit", "in", "a", "single", "REG_CC", ".", "For", "other", "modes", "and", "regs", ",", "return", "the", "number", "of", "words", "in", "mode", "(", "i.e", "whatever", "the", "default", "implementation", "of", "the", "hook", "returned", ")", "." ]

[ "avr", "1" ]

[]

[ "<s>", "static", "void", "vr4130_align_insns", "(", "void", ")", "{", "struct", "mips_sim", "state", ";", "rtx_insn", "*", "insn", ",", "*", "subinsn", ",", "*", "last", ",", "*", "last2", ",", "*", "next", ";", "bool", "aligned_p", ";", "dfa_start", "(", ")", ";", "last", "=", "0", ";", "last2", "=", "0", ";", "aligned_p", "=", "true", ";", "mips_sim_init", "(", "&", "state", ",", "alloca", "(", "state_size", "(", ")", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", "!=", "0", ";", "insn", "=", "next", ")", "{", "unsigned", "int", "length", ";", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "vr4130_avoid_branch_rt_conflict", "(", "insn", ")", ";", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", ">", "0", "&&", "USEFUL_INSN_P", "(", "insn", ")", ")", "FOR_EACH_SUBINSN", "(", "subinsn", ",", "insn", ")", "{", "mips_sim_wait_insn", "(", "&", "state", ",", "subinsn", ")", ";", "if", "(", "state", ".", "insns_left", "!=", "state", ".", "issue_rate", "&&", "!", "CALL_P", "(", "subinsn", ")", ")", "{", "if", "(", "subinsn", "==", "SEQ_BEGIN", "(", "insn", ")", "&&", "aligned_p", ")", "{", "gcc_assert", "(", "last2", ")", ";", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "last2", ")", ";", "aligned_p", "=", "false", ";", "}", "else", "if", "(", "subinsn", "!=", "SEQ_BEGIN", "(", "insn", ")", "&&", "!", "aligned_p", ")", "{", "gcc_assert", "(", "last", ")", ";", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "last", ")", ";", "aligned_p", "=", "true", ";", "}", "}", "mips_sim_issue_insn", "(", "&", "state", ",", "subinsn", ")", ";", "}", "mips_sim_finish_insn", "(", "&", "state", ",", "insn", ")", ";", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", ">", "0", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "SEQ_BEGIN", "(", "insn", ")", ")", "&&", "(", "recog_memoized", "(", "insn", ")", "<", "0", "||", "length", ">=", "8", ")", ")", "{", "next", "=", "emit_insn_after", "(", "gen_align", "(", "GEN_INT", "(", "3", ")", ")", ",", "insn", ")", ";", "next", "=", "NEXT_INSN", "(", "next", ")", ";", "mips_sim_next_cycle", "(", "&", "state", ")", ";", "aligned_p", "=", "true", ";", "}", "else", "if", "(", "length", "&", "4", ")", "aligned_p", "=", "!", "aligned_p", ";", "last2", "=", "last", ";", "last", "=", "insn", ";", "}", "if", "(", "LABEL_P", "(", "insn", ")", "&&", "label_to_alignment", "(", "insn", ")", ".", "levels", "[", "0", "]", ".", "log", ">=", "3", ")", "aligned_p", "=", "true", ";", "}", "dfa_finish", "(", ")", ";", "}", "</s>" ]

[ "Implement", "-mvr4130-align", ".", "Go", "through", "each", "basic", "block", "and", "simulate", "the", "processor", "pipeline", ".", "If", "we", "find", "that", "a", "pair", "of", "instructions", "could", "execute", "in", "parallel", ",", "and", "the", "first", "of", "those", "instruction", "is", "not", "8-byte", "aligned", ",", "insert", "a", "nop", "to", "make", "it", "aligned", "." ]

[ "mips", "0", "0", "0", "0", "0", "0", "8", "3", "4", "0", "3" ]

[]

[ "<s>", "static", "bool", "must_save_rets_p", "(", "void", ")", "{", "return", "df_regs_ever_live_p", "(", "REG_RETS", ")", ";", "}", "</s>" ]

[ "Determine", "if", "we", "are", "going", "to", "save", "the", "RETS", "register", "." ]

[ "bfin" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "{", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "Videocore" ]

[]

[ "<s>", "bool", "R600TargetLowering", "::", "canMergeStoresTo", "(", "unsigned", "AS", ",", "EVT", "MemVT", ",", "const", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "(", "AS", "==", "AMDGPUASI", ".", "LOCAL_ADDRESS", "||", "AS", "==", "AMDGPUASI", ".", "PRIVATE_ADDRESS", ")", ")", "{", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "SI", "SI", "32" ]

[]

[ "<s>", "static", "void", "rs6000_emit_prologue_components", "(", "sbitmap", "components", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "rtx", "ptr_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "frame_pointer_needed", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", ")", ";", "machine_mode", "reg_mode", "=", "Pmode", ";", "int", "reg_size", "=", "TARGET_32BIT", "?", "4", ":", "8", ";", "machine_mode", "fp_reg_mode", "=", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_DOUBLE_FLOAT", ")", "?", "DFmode", ":", "SFmode", ";", "int", "fp_reg_size", "=", "8", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "0", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "0", ")", ";", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "reg", ",", "gen_rtx_REG", "(", "reg_mode", ",", "LR_REGNO", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "NULL", ")", ";", "int", "offset", "=", "info", "->", "lr_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "lr", "=", "gen_rtx_REG", "(", "reg_mode", ",", "LR_REGNO", ")", ";", "rtx", "mem", "=", "copy_rtx", "(", "SET_DEST", "(", "single_set", "(", "insn", ")", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "lr", ")", ")", ";", "}", "if", "(", "bitmap_bit_p", "(", "components", ",", "2", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "TOC_REGNUM", ")", ";", "rtx", "sp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "sp_reg", ",", "RS6000_TOC_SAVE_SLOT", ")", ")", ";", "}", "int", "offset", "=", "info", "->", "gp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "32", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "set", "=", "copy_rtx", "(", "single_set", "(", "insn", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set", ")", ";", "}", "offset", "+=", "reg_size", ";", "}", "offset", "=", "info", "->", "fp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_fp_reg_save", ";", "i", "<", "64", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "fp_reg_mode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "set", "=", "copy_rtx", "(", "single_set", "(", "insn", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set", ")", ";", "}", "offset", "+=", "fp_reg_size", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS", "." ]

[ "rs6000", "4", "8", "8", "0", "0", "1", "1", "2", "32", "1", "64", "1" ]

[]

[ "<s>", "bool", "Cpu0PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createCpu0SEISelDag", "(", "getCpu0TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "bool", "isZero", "(", "SDValue", "V", ")", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "V", ")", ";", "return", "C", "&&", "C", "->", "isNullValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "expression", "is", "a", "constant", "zero", "." ]

[ "X86" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin_compare_1", "(", "enum", "insn_code", "icode", ",", "enum", "mips_fp_condition", "cond", ",", "tree", "exp", ",", "int", "nargs", ")", "{", "struct", "expand_operand", "ops", "[", "MAX_RECOG_OPERANDS", "]", ";", "rtx", "output", ";", "int", "opno", ",", "argno", ";", "gcc_assert", "(", "nargs", "+", "2", "==", "insn_data", "[", "(", "int", ")", "icode", "]", ".", "n_generator_args", ")", ";", "output", "=", "mips_allocate_fcc", "(", "insn_data", "[", "(", "int", ")", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ")", ";", "opno", "=", "0", ";", "create_fixed_operand", "(", "&", "ops", "[", "opno", "++", "]", ",", "output", ")", ";", "for", "(", "argno", "=", "0", ";", "argno", "<", "nargs", ";", "argno", "++", ")", "mips_prepare_builtin_arg", "(", "&", "ops", "[", "opno", "++", "]", ",", "exp", ",", "argno", ")", ";", "create_integer_operand", "(", "&", "ops", "[", "opno", "++", "]", ",", "(", "int", ")", "cond", ")", ";", "return", "mips_expand_builtin_insn", "(", "icode", ",", "opno", ",", "ops", ",", "true", ")", ";", "}", "</s>" ]

[ "Expand", "a", "floating-point", "comparison", "for", "built-in", "function", "call", "EXP", ".", "The", "first", "NARGS", "arguments", "are", "the", "values", "to", "be", "compared", ".", "ICODE", "is", "the", ".md", "pattern", "that", "does", "the", "comparison", "and", "COND", "is", "the", "condition", "that", "is", "being", "tested", ".", "Return", "an", "rtx", "for", "the", "result", "." ]

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

[]

[ "<s>", "vector_type_index", "function_resolver", "::", "infer_vector_base_type", "(", "unsigned", "int", "argno", ")", "{", "type_suffix_index", "type", "=", "infer_vector_type", "(", "argno", ")", ";", "if", "(", "type", "==", "NUM_TYPE_SUFFIXES", ")", "return", "NUM_VECTOR_TYPES", ";", "if", "(", "type", "==", "TYPE_SUFFIX_u32", "||", "type", "==", "TYPE_SUFFIX_u64", ")", "return", "type_suffixes", "[", "type", "]", ".", "vector_type", ";", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects %qs or %qs\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ",", "\"svuint32_t\"", ",", "\"svuint64_t\"", ")", ";", "return", "NUM_VECTOR_TYPES", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "be", "a", "vector", "base", "in", "a", "gather-style", "address", ".", "Return", "its", "type", "on", "success", ",", "otherwise", "return", "NUM_VECTOR_TYPES", "." ]

[ "aarch64", "\"passing %qT to argument %d of %qE, which\"", "\" expects %qs or %qs\"", "1", "\"svuint32_t\"", "\"svuint64_t\"" ]

[]

[ "<s>", "void", "addFastRegAlloc", "(", ")", "override", "{", "}", "</s>" ]

[ "addFastRegAlloc", "-", "Add", "the", "minimum", "set", "of", "target-independent", "passes", "that", "are", "required", "for", "fast", "register", "allocation", "." ]

[ "SPIRV" ]

[]

[ "<s>", "static", "void", "aarch64_emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx_insn", "*", "jump", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "aarch64", "100", "1" ]

[]

[ "<s>", "bool", "isMem", "(", "MemoryKind", "MemKind", ",", "RegisterKind", "RegKind", ")", "const", "{", "return", "isMem", "(", "MemKind", ")", "&&", "Mem", ".", "RegKind", "==", "RegKind", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "SystemZ" ]

[]

[ "<s>", "void", "WebAssemblyRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "int64_t", "FrameOffset", "=", "MFI", ".", "getStackSize", "(", ")", "+", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "if", "(", "MI", ".", "mayLoadOrStore", "(", ")", "&&", "FIOperandNum", "==", "WebAssembly", "::", "MemOpAddressOperandNo", ")", "{", "assert", "(", "FrameOffset", ">=", "0", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ">=", "0", ")", ";", "int64_t", "Offset", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "+", "FrameOffset", ";", "if", "(", "static_cast", "<", "uint64_t", ">", "(", "Offset", ")", ">", "std", "::", "numeric_limits", "<", "uint32_t", ">", "::", "max", "(", ")", ")", "{", "report_fatal_error", "(", "\"Memory offset field overflow\"", ")", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", "-", "1", ")", ".", "setImm", "(", "Offset", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "WebAssembly", "::", "SP32", ",", "false", ")", ";", "}", "else", "{", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "FIRegOperand", "=", "WebAssembly", "::", "SP32", ";", "if", "(", "FrameOffset", ")", "{", "FIRegOperand", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "FIRegOperand", ")", ".", "addImm", "(", "FrameOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "WebAssembly", "::", "ADD_I32", ")", ",", "FIRegOperand", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "FIRegOperand", ")", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FIRegOperand", ",", "false", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "WebAssembly::MemOpAddressOperandNo", "0", "1", "0", "1", "\"Memory offset field overflow\"", "1", "WebAssembly::SP32", "WebAssembly", "WebAssembly::SP32", "WebAssembly::I32RegClass", "WebAssembly::CONST_I32", "WebAssembly::ADD_I32", "WebAssembly::SP32" ]

[]

[ "<s>", "bool", "Nios2AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "Nios2", "Nios2" ]

[]

[ "<s>", "const", "char", "*", "NyuziTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "NyuziISD", "::", "CALL", ":", "return", "\"NyuziISD::CALL\"", ";", "case", "NyuziISD", "::", "RET_FLAG", ":", "return", "\"NyuziISD::RET_FLAG\"", ";", "case", "NyuziISD", "::", "SPLAT", ":", "return", "\"NyuziISD::SPLAT\"", ";", "case", "NyuziISD", "::", "SEL_COND_RESULT", ":", "return", "\"NyuziISD::SEL_COND_RESULT\"", ";", "case", "NyuziISD", "::", "RECIPROCAL_EST", ":", "return", "\"NyuziISD::RECIPROCAL_EST\"", ";", "case", "NyuziISD", "::", "MASK_TO_INT", ":", "return", "\"NyuziISD::MASK_TO_INT\"", ";", "case", "NyuziISD", "::", "MASK_FROM_INT", ":", "return", "\"NyuziISD::MASK_FROM_INT\"", ";", "case", "NyuziISD", "::", "MOVEHI", ":", "return", "\"NyuziISD::MOVEHI\"", ";", "case", "NyuziISD", "::", "ORLO", ":", "return", "\"NyuziISD::ORLO\"", ";", "case", "NyuziISD", "::", "GOT_ADDR", ":", "return", "\"NyuziISD::GOT_ADDR\"", ";", "case", "NyuziISD", "::", "FGT", ":", "return", "\"NyuziISD::FGT\"", ";", "case", "NyuziISD", "::", "FGE", ":", "return", "\"NyuziISD::FGE\"", ";", "case", "NyuziISD", "::", "FLT", ":", "return", "\"NyuziISD::FLT\"", ";", "case", "NyuziISD", "::", "FLE", ":", "return", "\"NyuziISD::FLE\"", ";", "case", "NyuziISD", "::", "FEQ", ":", "return", "\"NyuziISD::FEQ\"", ";", "case", "NyuziISD", "::", "FNE", ":", "return", "\"NyuziISD::FNE\"", ";", "default", ":", "return", "nullptr", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "Nyuzi", "Nyuzi", "NyuziISD::CALL", "\"NyuziISD::CALL\"", "NyuziISD::RET_FLAG", "\"NyuziISD::RET_FLAG\"", "NyuziISD::SPLAT", "\"NyuziISD::SPLAT\"", "NyuziISD::SEL_COND_RESULT", "\"NyuziISD::SEL_COND_RESULT\"", "NyuziISD::RECIPROCAL_EST", "\"NyuziISD::RECIPROCAL_EST\"", "NyuziISD::MASK_TO_INT", "\"NyuziISD::MASK_TO_INT\"", "NyuziISD::MASK_FROM_INT", "\"NyuziISD::MASK_FROM_INT\"", "NyuziISD::MOVEHI", "\"NyuziISD::MOVEHI\"", "NyuziISD::ORLO", "\"NyuziISD::ORLO\"", "NyuziISD::GOT_ADDR", "\"NyuziISD::GOT_ADDR\"", "NyuziISD::FGT", "\"NyuziISD::FGT\"", "NyuziISD::FGE", "\"NyuziISD::FGE\"", "NyuziISD::FLT", "\"NyuziISD::FLT\"", "NyuziISD::FLE", "\"NyuziISD::FLE\"", "NyuziISD::FEQ", "\"NyuziISD::FEQ\"", "NyuziISD::FNE", "\"NyuziISD::FNE\"" ]

[]

[ "<s>", "unsigned", "int", "mn10300_get_live_callee_saved_regs", "(", "unsigned", "int", "*", "bytes_saved", ")", "{", "int", "mask", ";", "int", "i", ";", "unsigned", "int", "count", ";", "count", "=", "mask", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_EXTENDED_REGNUM", ";", "i", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "i", ")", "&&", "!", "call_really_used_regs", "[", "i", "]", ")", "{", "mask", "|=", "(", "1", "<<", "i", ")", ";", "++", "count", ";", "}", "if", "(", "(", "mask", "&", "0x3c000", ")", "!=", "0", ")", "{", "for", "(", "i", "=", "0x04000", ";", "i", "<", "0x40000", ";", "i", "<<=", "1", ")", "if", "(", "(", "mask", "&", "i", ")", "==", "0", ")", "++", "count", ";", "mask", "|=", "0x3c000", ";", "}", "if", "(", "bytes_saved", ")", "*", "bytes_saved", "=", "count", "*", "UNITS_PER_WORD", ";", "return", "mask", ";", "}", "</s>" ]

[ "Returns", "the", "set", "of", "live", ",", "callee-saved", "registers", "as", "a", "bitmask", ".", "The", "callee-saved", "extended", "registers", "can", "not", "be", "stored", "individually", ",", "so", "all", "of", "them", "will", "be", "included", "in", "the", "mask", "if", "any", "one", "of", "them", "is", "used", "." ]

[ "mn10300", "0", "0", "1", "0x3c000", "0", "0x04000", "0x40000", "1", "0", "0x3c000" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_r", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "bool", "Op0IsKill", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "1", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "one", "register", "operand", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

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

[]

[ "<s>", "void", "or1k_expand_call", "(", "rtx", "retval", ",", "rtx", "fnaddr", ",", "rtx", "callarg1", ",", "bool", "sibcall", ")", "{", "rtx", "call", ",", "use", "=", "NULL", ";", "if", "(", "flag_pic", "&&", "GET_CODE", "(", "XEXP", "(", "fnaddr", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "XEXP", "(", "fnaddr", ",", "0", ")", ")", ")", "{", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "rtx", "hard_pic", "=", "gen_rtx_REG", "(", "Pmode", ",", "REAL_PIC_OFFSET_TABLE_REGNUM", ")", ";", "emit_move_insn", "(", "hard_pic", ",", "pic_offset_table_rtx", ")", ";", "use_reg", "(", "&", "use", ",", "hard_pic", ")", ";", "}", "if", "(", "!", "call_insn_operand", "(", "XEXP", "(", "fnaddr", ",", "0", ")", ",", "Pmode", ")", ")", "{", "fnaddr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "fnaddr", ",", "0", ")", ")", ";", "fnaddr", "=", "gen_rtx_MEM", "(", "SImode", ",", "fnaddr", ")", ";", "}", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "fnaddr", ",", "callarg1", ")", ";", "if", "(", "retval", ")", "call", "=", "gen_rtx_SET", "(", "retval", ",", "call", ")", ";", "if", "(", "!", "sibcall", ")", "{", "rtx", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNUM", ")", ")", ";", "call", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "call", ",", "clob", ")", ")", ";", "}", "call", "=", "emit_call_insn", "(", "call", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "call", ")", "=", "use", ";", "}", "</s>" ]

[ "Expand", "the", "patterns", "``", "call", "''", ",", "``", "sibcall", "''", ",", "``", "call_value", "''", "and", "``", "sibcall_value", "''", ".", "Expands", "a", "function", "call", "where", "argument", "RETVAL", "is", "an", "optional", "RTX", "providing", "return", "value", "storage", ",", "the", "argument", "FNADDR", "is", "and", "RTX", "describing", "the", "function", "to", "call", ",", "the", "argument", "CALLARG1", "is", "the", "number", "or", "registers", "used", "as", "operands", "and", "the", "argument", "SIBCALL", "should", "be", "true", "if", "this", "is", "a", "nested", "function", "call", ".", "If", "FNADDR", "is", "a", "non", "local", "symbol", "and", "FLAG_PIC", "is", "enabled", "this", "will", "generate", "a", "PLT", "call", "." ]

[ "or1k", "0", "0", "1", "0", "0", "2" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]