Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "floating_exact_log2", "(", "rtx", "x", ")", "{", "const", "REAL_VALUE_TYPE", "*", "r", ";", "REAL_VALUE_TYPE", "r1", ";", "int", "exp", ";", "r", "=", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "real_less", "(", "r", ",", "&", "dconst1", ")", ")", "return", "0", ";", "exp", "=", "real_exponent", "(", "r", ")", ";", "real_2expN", "(", "&", "r1", ",", "exp", ",", "DFmode", ")", ";", "if", "(", "real_equal", "(", "&", "r1", ",", "r", ")", ")", "return", "exp", ";", "return", "0", ";", "}", "</s>" ]

[ "If", "X", "is", "a", "floating-point", "constant", ",", "return", "the", "logarithm", "of", "X", "base", "2", ",", "or", "0", "if", "X", "is", "not", "a", "power", "of", "2", "." ]

[ "m68k", "0", "0" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV16_rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV32_rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "(", "MI", "->", "getOperand", "(", "4", ")", ".", "isCPI", "(", ")", "||", "(", "MI", "->", "getOperand", "(", "4", ")", ".", "isGlobal", "(", ")", "&&", "isGVStub", "(", "MI", "->", "getOperand", "(", "4", ")", ".", "getGlobal", "(", ")", ",", "TM", ")", ")", ")", ")", "{", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", ")", "return", "true", ";", "if", "(", "!", "ReMatPICStubLoad", "&&", "MI", "->", "getOperand", "(", "4", ")", ".", "isGlobal", "(", ")", ")", "return", "false", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "isPICBase", "=", "false", ";", "for", "(", "MachineRegisterInfo", "::", "def_iterator", "I", "=", "MRI", ".", "def_begin", "(", "BaseReg", ")", ",", "E", "=", "MRI", ".", "def_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "DefMI", "=", "I", ".", "getOperand", "(", ")", ".", "getParent", "(", ")", ";", "if", "(", "DefMI", "->", "getOpcode", "(", ")", "!=", "X86", "::", "MOVPC32r", ")", "return", "false", ";", "assert", "(", "!", "isPICBase", "&&", "\"More than one PIC base?\"", ")", ";", "isPICBase", "=", "true", ";", "}", "return", "isPICBase", ";", "}", "return", "false", ";", "}", "case", "X86", "::", "LEA32r", ":", "case", "X86", "::", "LEA64r", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "!", "MI", "->", "getOperand", "(", "4", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "regIsPICBase", "(", "BaseReg", ",", "MRI", ")", ";", "}", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "X86", "X86", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV16_rm", "X86::MOV32rm", "X86::MOV32_rm", "X86::MOV64rm", "X86::LD_Fp64m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MOVAPSrm", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "1", "2", "3", "3", "0", "4", "4", "4", "1", "0", "4", "X86::MOVPC32r", "\"More than one PIC base?\"", "X86::LEA32r", "X86::LEA64r", "2", "3", "3", "0", "4", "1", "1", "0" ]

[]

[ "<s>", "enum", "reg_class", "mep_secondary_input_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "int", "rv", "=", "NO_REGS", ";", "fprintf", "(", "stderr", ",", "\"secondary input reload copy to %s %s from \"", ",", "reg_class_names", "[", "rclass", "]", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "CR_REGS", ")", ")", "rv", "=", "mep_secondary_copro_reload_class", "(", "rclass", ",", "x", ")", ";", "else", "if", "(", "MEP_NONGENERAL_CLASS", "(", "rclass", ")", "&&", "(", "mep_nonregister", "(", "x", ")", "||", "mep_nongeneral_reg", "(", "x", ")", ")", ")", "rv", "=", "GENERAL_REGS", ";", "fprintf", "(", "stderr", ",", "\" - requires %s\\n\"", ",", "reg_class_names", "[", "rv", "]", ")", ";", "return", "(", "enum", "reg_class", ")", "rv", ";", "}", "</s>" ]

[ "Copying", "X", "to", "register", "in", "RCLASS", "." ]

[ "mep", "\"secondary input reload copy to %s %s from \"", "\" - requires %s\\n\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "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", ";", "report_fatal_error", "(", "\"ISRs cannot have arguments\"", ")", ";", "}", "}", "</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>", "void", "X86RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "0", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Is64Bit", "?", "X86", "::", "SUB64ri32", ":", "X86", "::", "SUB32ri", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "{", "unsigned", "Opc", "=", "(", "Amount", "<", "128", ")", "?", "(", "Is64Bit", "?", "X86", "::", "ADD64ri8", ":", "X86", "::", "ADD32ri8", ")", ":", "(", "Is64Bit", "?", "X86", "::", "ADD64ri32", ":", "X86", "::", "ADD32ri", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "unsigned", "Opc", "=", "(", "CalleeAmt", "<", "128", ")", "?", "(", "Is64Bit", "?", "X86", "::", "SUB64ri8", ":", "X86", "::", "SUB32ri8", ")", ":", "(", "Is64Bit", "?", "X86", "::", "SUB64ri32", ":", "X86", "::", "SUB32ri", ")", ";", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "X86", "X86", "0", "0", "1", "0", "X86::SUB64ri32", "X86::SUB32ri", "1", "128", "X86::ADD64ri8", "X86::ADD32ri8", "X86::ADD64ri32", "X86::ADD32ri", "3", "1", "128", "X86::SUB64ri8", "X86::SUB32ri8", "X86::SUB64ri32", "X86::SUB32ri", "3" ]

[]

[ "<s>", "virtual", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "LCtx", "=", "&", "M", ".", "getContext", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TGSI" ]

[]

[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_MBlaze", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "StackOffset", "HexagonFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "hasStackRealignment", "(", "MF", ")", ";", "bool", "NoOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Register", "SP", "=", "HRI", ".", "getStackRegister", "(", ")", ";", "Register", "FP", "=", "HRI", ".", "getFrameRegister", "(", ")", ";", "Register", "AP", "=", "HMFI", ".", "getStackAlignBasePhysReg", "(", ")", ";", "if", "(", "AP", "==", "0", ")", "AP", "=", "FP", ";", "bool", "UseFP", "=", "false", ",", "UseAP", "=", "false", ";", "if", "(", "NoOpt", "&&", "!", "HasExtraAlign", ")", "UseFP", "=", "true", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "||", "MFI", ".", "isObjectPreAllocated", "(", "FI", ")", ")", "{", "UseFP", "|=", "(", "HasAlloca", "||", "HasExtraAlign", ")", ";", "}", "else", "{", "if", "(", "HasAlloca", ")", "{", "if", "(", "HasExtraAlign", ")", "UseAP", "=", "true", ";", "else", "UseFP", "=", "true", ";", "}", "}", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "assert", "(", "(", "HasFP", "||", "!", "UseFP", ")", "&&", "\"This function must have frame pointer\"", ")", ";", "if", "(", "Offset", ">", "0", "&&", "!", "HasFP", ")", "Offset", "-=", "8", ";", "if", "(", "UseFP", ")", "FrameReg", "=", "FP", ";", "else", "if", "(", "UseAP", ")", "FrameReg", "=", "AP", ";", "else", "FrameReg", "=", "SP", ";", "int", "RealOffset", "=", "Offset", ";", "if", "(", "!", "UseFP", "&&", "!", "UseAP", ")", "RealOffset", "=", "FrameSize", "+", "Offset", ";", "return", "StackOffset", "::", "getFixed", "(", "RealOffset", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "\"This function must have frame pointer\"", "0", "8" ]

[]

[ "<s>", "static", "void", "adjust_concat", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "concat", "=", "XEXP", "(", "set", ",", "1", ")", ";", "rtx", "src0", "=", "XEXP", "(", "concat", ",", "0", ")", ";", "XEXP", "(", "concat", ",", "0", ")", "=", "XEXP", "(", "concat", ",", "1", ")", ";", "XEXP", "(", "concat", ",", "1", ")", "=", "src0", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Reversing inputs for concat %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Given", "OP", "that", "contains", "a", "VEC_CONCAT", "operation", "of", "two", "doublewords", ",", "reverse", "the", "order", "of", "those", "inputs", "." ]

[ "powerpcspe", "1", "0", "0", "1", "1", "1", "\"Reversing inputs for concat %d\\n\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "HexagonRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegsV3", "[", "]", "=", "{", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "switch", "(", "MF", "->", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getHexagonArchVersion", "(", ")", ")", "{", "case", "HexagonSubtarget", "::", "V4", ":", "case", "HexagonSubtarget", "::", "V5", ":", "return", "CalleeSavedRegsV3", ";", "}", "llvm_unreachable", "(", "\"Callee saved registers requested for unknown architecture \"", "\"version\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Callee saved registers requested for unknown architecture \"", "\"version\"" ]

[]

[ "<s>", "const", "char", "*", "MipsAsmPrinter", "::", "getCurrentABIString", "(", ")", "const", "{", "switch", "(", "Subtarget", "->", "getTargetABI", "(", ")", ")", "{", "case", "MipsSubtarget", "::", "O32", ":", "return", "\"abi32\"", ";", "case", "MipsSubtarget", "::", "N32", ":", "return", "\"abiN32\"", ";", "case", "MipsSubtarget", "::", "N64", ":", "return", "\"abi64\"", ";", "case", "MipsSubtarget", "::", "EABI", ":", "return", "\"eabi32\"", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown Mips ABI\"", ")", ";", "}", "}", "</s>" ]

[ "Emit", "Set", "directives", "." ]

[ "Mips", "Mips", "Mips", "\"abi32\"", "Mips", "\"abiN32\"", "Mips", "\"abi64\"", "Mips", "\"eabi32\"", "\"Unknown Mips ABI\"" ]

[]

[ "<s>", "bool", "RV16KPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createRV16KISelDag", "(", "getRV16KTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "RV16K", "RV16K" ]

[]

[ "<s>", "static", "bool", "sh_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", ")", "{", "if", "(", "TARGET_SH5", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ")", "return", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ")", ">", "8", ";", "else", "return", "GET_MODE_SIZE", "(", "TYPE_MODE", "(", "type", ")", ")", ">", "8", ";", "}", "else", "{", "return", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "||", "(", "(", "TARGET_HITACHI", "||", "sh_attr_renesas_p", "(", "fndecl", ")", ")", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", ")", ";", "}", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "." ]

[ "sh", "8", "8" ]

[]

[ "<s>", "rtx", "avr_return_addr_rtx", "(", "int", "count", ",", "rtx", "tem", ")", "{", "rtx", "r", ";", "if", "(", "count", ")", "return", "NULL", ";", "if", "(", "AVR_3_BYTE_PC", ")", "{", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+2\"", ")", ";", "warning", "(", "0", ",", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", ")", ";", "}", "else", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+1\"", ")", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tem", ",", "r", ")", ";", "r", "=", "gen_frame_mem", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "r", ")", ")", ";", "r", "=", "gen_rtx_ROTATE", "(", "HImode", ",", "r", ",", "GEN_INT", "(", "8", ")", ")", ";", "return", "r", ";", "}", "</s>" ]

[ "Return", "contents", "of", "MEM", "at", "frame", "pointer", "+", "stack", "size", "+", "1", "(", "+2", "if", "3-byte", "PC", ")", ".", "This", "is", "return", "address", "of", "function", "." ]

[ "avr", "\".L__stack_usage+2\"", "0", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", "\".L__stack_usage+1\"", "8" ]

[]

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

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

[ "JVM", "JVM" ]

[]

[ "<s>", "static", "int", "round_frame_size", "(", "int", "size", ")", "{", "return", "(", "(", "size", "+", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", "&", "-", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "}", "</s>" ]

[ "Round", "up", "frame", "size", "SIZE", "." ]

[ "h8300", "1" ]

[]

[ "<s>", "AliasResult", "AMDGPUAAResult", "::", "alias", "(", "const", "MemoryLocation", "&", "LocA", ",", "const", "MemoryLocation", "&", "LocB", ",", "AAQueryInfo", "&", "AAQI", ")", "{", "unsigned", "asA", "=", "LocA", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "unsigned", "asB", "=", "LocB", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "AliasResult", "Result", "=", "getAliasResult", "(", "asA", ",", "asB", ")", ";", "if", "(", "Result", "==", "NoAlias", ")", "return", "Result", ";", "return", "AAResultBase", "::", "alias", "(", "LocA", ",", "LocB", ",", "AAQI", ")", ";", "}", "</s>" ]

[ "alias", "-", "If", "one", "of", "the", "pointers", "is", "to", "a", "global", "that", "we", "are", "tracking", ",", "and", "the", "other", "is", "some", "random", "pointer", ",", "we", "know", "there", "can", "not", "be", "an", "alias", ",", "because", "the", "address", "of", "the", "global", "is", "n't", "taken", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "ix86_in_large_data_p", "(", "tree", "exp", ")", "{", "if", "(", "ix86_cmodel", "!=", "CM_MEDIUM", "&&", "ix86_cmodel", "!=", "CM_MEDIUM_PIC", ")", "return", "false", ";", "if", "(", "exp", "==", "NULL_TREE", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "VAR_P", "(", "exp", ")", "&&", "!", "is_global_var", "(", "exp", ")", ")", "return", "false", ";", "if", "(", "VAR_P", "(", "exp", ")", "&&", "DECL_SECTION_NAME", "(", "exp", ")", ")", "{", "const", "char", "*", "section", "=", "DECL_SECTION_NAME", "(", "exp", ")", ";", "if", "(", "strcmp", "(", "section", ",", "\".ldata\"", ")", "==", "0", "||", "strcmp", "(", "section", ",", "\".lbss\"", ")", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "size", "<=", "0", "||", "size", ">", "ix86_section_threshold", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "goes", "in", "small", "data/bss", "." ]

[ "i386", "\".ldata\"", "0", "\".lbss\"", "0", "0" ]

[]

[ "<s>", "tree", "ix86_valid_target_attribute_tree", "(", "tree", "fndecl", ",", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ",", "bool", "target_clone_attr", ")", "{", "const", "char", "*", "orig_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "const", "char", "*", "orig_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "enum", "fpmath_unit", "orig_fpmath_set", "=", "opts_set", "->", "x_ix86_fpmath", ";", "enum", "prefer_vector_width", "orig_pvw_set", "=", "opts_set", "->", "x_prefer_vector_width_type", ";", "int", "orig_tune_defaulted", "=", "ix86_tune_defaulted", ";", "int", "orig_arch_specified", "=", "ix86_arch_specified", ";", "char", "*", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_MAX", "]", "=", "{", "NULL", ",", "NULL", "}", ";", "tree", "t", "=", "NULL_TREE", ";", "struct", "cl_target_option", "*", "def", "=", "TREE_TARGET_OPTION", "(", "target_option_default_node", ")", ";", "struct", "gcc_options", "enum_opts_set", ";", "memset", "(", "&", "enum_opts_set", ",", "0", ",", "sizeof", "(", "enum_opts_set", ")", ")", ";", "if", "(", "!", "ix86_valid_target_attribute_inner_p", "(", "fndecl", ",", "args", ",", "option_strings", ",", "opts", ",", "opts_set", ",", "&", "enum_opts_set", ",", "target_clone_attr", ")", ")", "return", "error_mark_node", ";", "if", "(", "opts", "->", "x_ix86_isa_flags", "!=", "def", "->", "x_ix86_isa_flags", "||", "opts", "->", "x_ix86_isa_flags2", "!=", "def", "->", "x_ix86_isa_flags2", "||", "opts", "->", "x_target_flags", "!=", "def", "->", "x_target_flags", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", "||", "enum_opts_set", ".", "x_ix86_fpmath", "||", "enum_opts_set", ".", "x_prefer_vector_width_type", ")", "{", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", "opts", "->", "x_ix86_arch_string", "=", "ggc_strdup", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", ";", "else", "if", "(", "!", "orig_arch_specified", ")", "opts", "->", "x_ix86_arch_string", "=", "NULL", ";", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", "opts", "->", "x_ix86_tune_string", "=", "ggc_strdup", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", ";", "else", "if", "(", "orig_tune_defaulted", ")", "opts", "->", "x_ix86_tune_string", "=", "NULL", ";", "if", "(", "enum_opts_set", ".", "x_ix86_fpmath", ")", "opts_set", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "1", ";", "if", "(", "enum_opts_set", ".", "x_prefer_vector_width_type", ")", "opts_set", "->", "x_prefer_vector_width_type", "=", "(", "enum", "prefer_vector_width", ")", "1", ";", "bool", "r", "=", "ix86_option_override_internal", "(", "false", ",", "opts", ",", "opts_set", ")", ";", "if", "(", "!", "r", ")", "{", "release_options_strings", "(", "option_strings", ")", ";", "return", "error_mark_node", ";", "}", "ix86_add_new_builtins", "(", "opts", "->", "x_ix86_isa_flags", ",", "opts", "->", "x_ix86_isa_flags2", ")", ";", "enum", "excess_precision", "orig_ix86_excess_precision", "=", "opts", "->", "x_ix86_excess_precision", ";", "bool", "orig_ix86_unsafe_math_optimizations", "=", "opts", "->", "x_ix86_unsafe_math_optimizations", ";", "opts", "->", "x_ix86_excess_precision", "=", "opts", "->", "x_flag_excess_precision", ";", "opts", "->", "x_ix86_unsafe_math_optimizations", "=", "opts", "->", "x_flag_unsafe_math_optimizations", ";", "t", "=", "build_target_option_node", "(", "opts", ",", "opts_set", ")", ";", "opts", "->", "x_ix86_arch_string", "=", "orig_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "orig_tune_string", ";", "opts_set", "->", "x_ix86_fpmath", "=", "orig_fpmath_set", ";", "opts_set", "->", "x_prefer_vector_width_type", "=", "orig_pvw_set", ";", "opts", "->", "x_ix86_excess_precision", "=", "orig_ix86_excess_precision", ";", "opts", "->", "x_ix86_unsafe_math_optimizations", "=", "orig_ix86_unsafe_math_optimizations", ";", "release_options_strings", "(", "option_strings", ")", ";", "}", "return", "t", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "inline", "bool", "isKMasked", "(", "uint64_t", "TSFlags", ")", "{", "return", "(", "TSFlags", "&", "X86II", "::", "EVEX_K", ")", "!=", "0", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "group", "of", "FMA", "opcodes", "holds", "any", "of", "k-masked", "opcodes", "." ]

[ "X86", "X86II::EVEX_K", "0" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isDesirableToCommuteWithShift", "(", "const", "SDNode", "*", "N", ",", "CombineLevel", "Level", ")", "const", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "EVT", "Ty", "=", "N0", ".", "getValueType", "(", ")", ";", "if", "(", "Ty", ".", "isScalarInteger", "(", ")", "&&", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "||", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", ")", "{", "auto", "*", "C1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N0", "->", "getOperand", "(", "1", ")", ")", ";", "auto", "*", "C2", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", ";", "if", "(", "C1", "&&", "C2", ")", "{", "const", "APInt", "&", "C1Int", "=", "C1", "->", "getAPIntValue", "(", ")", ";", "APInt", "ShiftedC1Int", "=", "C1Int", "<<", "C2", "->", "getAPIntValue", "(", ")", ";", "if", "(", "ShiftedC1Int", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "isLegalAddImmediate", "(", "ShiftedC1Int", ".", "getSExtValue", "(", ")", ")", ")", "return", "true", ";", "if", "(", "C1Int", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "isLegalAddImmediate", "(", "C1Int", ".", "getSExtValue", "(", ")", ")", ")", "return", "false", ";", "int", "C1Cost", "=", "RISCVMatInt", "::", "getIntMatCost", "(", "C1Int", ",", "Ty", ".", "getSizeInBits", "(", ")", ",", "Subtarget", ".", "is64Bit", "(", ")", ")", ";", "int", "ShiftedC1Cost", "=", "RISCVMatInt", "::", "getIntMatCost", "(", "ShiftedC1Int", ",", "Ty", ".", "getSizeInBits", "(", ")", ",", "Subtarget", ".", "is64Bit", "(", ")", ")", ";", "if", "(", "C1Cost", "<", "ShiftedC1Cost", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "0", "ISD::ADD", "ISD::OR", "1", "1", "64", "64", "RISCVMatInt::getIntMatCost", "RISCVMatInt::getIntMatCost" ]

[]

[ "<s>", "bool", "Z80FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "TII", ".", "get", "(", "Z80", "::", "POP16r", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "0", "Z80::POP16r" ]

[]

[ "<s>", "void", "WebAssemblyExceptionInfo", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

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

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "Align", "Alignment", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "Align", "(", "8", ")", ":", "Align", "(", "4", ")", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "||", "Subtarget", ".", "hasQPX", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Alignment", ",", "Subtarget", ".", "hasQPX", "(", ")", "?", "Align", "(", "32", ")", ":", "Align", "(", "16", ")", ")", ";", "return", "Alignment", ".", "value", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

[ "PowerPC", "PPC", "PPC", "8", "4", "32", "16" ]

[]

[ "<s>", "SDNode", "*", "X86DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "int", "rs6000_dbx_register_number", "(", "unsigned", "int", "regno", ",", "unsigned", "int", "format", ")", "{", "if", "(", "(", "format", "==", "0", "&&", "write_symbols", "!=", "DWARF2_DEBUG", ")", "||", "format", "==", "2", ")", "return", "regno", ";", "if", "(", "regno", "<=", "63", ")", "return", "regno", ";", "if", "(", "regno", "==", "LR_REGNO", ")", "return", "108", ";", "if", "(", "regno", "==", "CTR_REGNO", ")", "return", "109", ";", "if", "(", "format", "==", "1", "&&", "regno", "==", "CR2_REGNO", ")", "return", "64", ";", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "CR0_REGNO", "+", "86", ";", "if", "(", "regno", "==", "CA_REGNO", ")", "return", "101", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_ALTIVEC_REGNO", "+", "1124", ";", "if", "(", "regno", "==", "VRSAVE_REGNO", ")", "return", "356", ";", "if", "(", "regno", "==", "VSCR_REGNO", ")", "return", "67", ";", "return", "regno", ";", "}", "</s>" ]

[ "Map", "internal", "gcc", "register", "numbers", "to", "DWARF2", "register", "numbers", "." ]

[ "rs6000", "0", "2", "63", "108", "109", "1", "64", "86", "101", "1124", "356", "67" ]

[]

[ "<s>", "bool", "compact_sda_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "short_p", ")", "{", "rtx", "addr", ";", "int", "size", ";", "tree", "decl", "=", "NULL_TREE", ";", "int", "align", "=", "0", ";", "int", "mask", "=", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "LEGITIMATE_SMALL_DATA_ADDRESS_P", "(", "addr", ")", ")", "return", "false", ";", "if", "(", "!", "short_p", "||", "size", "==", "1", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "SYMBOL_REF", ")", "decl", "=", "SYMBOL_REF_DECL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "decl", "=", "SYMBOL_REF_DECL", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ",", "0", ")", ")", ";", "if", "(", "decl", ")", "align", "=", "DECL_ALIGN", "(", "decl", ")", ";", "align", "=", "align", "/", "BITS_PER_UNIT", ";", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "mask", "=", "1", ";", "break", ";", "default", ":", "mask", "=", "3", ";", "break", ";", "}", "if", "(", "align", "&&", "(", "(", "align", "&", "mask", ")", "==", "0", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "volatile", "cache", "option", "still", "to", "be", "handled", "." ]

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

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "DataTy", ",", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "unsigned", "Alignment", ",", "const", "Instruction", "*", "I", ")", "{", "return", "BaseT", "::", "getGatherScatterOpCost", "(", "Opcode", ",", "DataTy", ",", "Ptr", ",", "VariableMask", ",", "Alignment", ",", "I", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "Hexagon", "Hexagon" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_autovectorize_vector_modes", "(", "vector_modes", "*", "modes", ",", "bool", ")", "{", "static", "const", "machine_mode", "sve_modes", "[", "]", "=", "{", "VNx16QImode", ",", "VNx8QImode", ",", "VNx4QImode", ",", "VNx2QImode", "}", ";", "static", "const", "machine_mode", "advsimd_modes", "[", "]", "=", "{", "V16QImode", ",", "V8QImode", ",", "V4HImode", ",", "V2SImode", "}", ";", "bool", "only_asimd_p", "=", "aarch64_autovec_preference", "==", "1", ";", "bool", "only_sve_p", "=", "aarch64_autovec_preference", "==", "2", ";", "unsigned", "int", "sve_i", "=", "(", "TARGET_SVE", "&&", "!", "only_asimd_p", ")", "?", "0", ":", "ARRAY_SIZE", "(", "sve_modes", ")", ";", "unsigned", "int", "advsimd_i", "=", "0", ";", "while", "(", "!", "only_sve_p", "&&", "advsimd_i", "<", "ARRAY_SIZE", "(", "advsimd_modes", ")", ")", "{", "if", "(", "sve_i", "<", "ARRAY_SIZE", "(", "sve_modes", ")", "&&", "aarch64_cmp_autovec_modes", "(", "sve_modes", "[", "sve_i", "]", ",", "advsimd_modes", "[", "advsimd_i", "]", ")", ")", "modes", "->", "safe_push", "(", "sve_modes", "[", "sve_i", "++", "]", ")", ";", "else", "modes", "->", "safe_push", "(", "advsimd_modes", "[", "advsimd_i", "++", "]", ")", ";", "}", "while", "(", "sve_i", "<", "ARRAY_SIZE", "(", "sve_modes", ")", ")", "modes", "->", "safe_push", "(", "sve_modes", "[", "sve_i", "++", "]", ")", ";", "unsigned", "int", "flags", "=", "0", ";", "if", "(", "TARGET_SVE", "&&", "aarch64_sve_compare_costs", ")", "flags", "|=", "VECT_COMPARE_COSTS", ";", "return", "flags", ";", "}", "</s>" ]

[ "Return", "a", "list", "of", "possible", "vector", "sizes", "for", "the", "vectorizer", "to", "iterate", "over", "." ]

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

[]

[ "<s>", "static", "bool", "m32r_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "m32r_rtx_ok_for_base_p", "(", "x", ",", "strict", ")", "||", "m32r_legitimate_offset_addres_p", "(", "mode", ",", "x", ",", "strict", ")", "||", "m32r_legitimate_lo_sum_addres_p", "(", "mode", ",", "x", ",", "strict", ")", "||", "m32r_load_postinc_p", "(", "mode", ",", "x", ",", "strict", ")", "||", "m32r_store_preinc_predec_p", "(", "mode", ",", "x", ",", "strict", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_ADDRESS_P", "." ]

[ "m32r" ]

[]

[ "<s>", "static", "rtx", "arc_emit_call_tls_get_addr", "(", "rtx", "sym", ",", "int", "reloc", ",", "rtx", "eqv", ")", "{", "rtx", "r0", "=", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ";", "rtx", "call_fusage", "=", "NULL_RTX", ";", "start_sequence", "(", ")", ";", "rtx", "x", "=", "arc_unspec_offset", "(", "sym", ",", "reloc", ")", ";", "emit_move_insn", "(", "r0", ",", "x", ")", ";", "use_reg", "(", "&", "call_fusage", ",", "r0", ")", ";", "gcc_assert", "(", "reloc", "==", "UNSPEC_TLS_GD", ")", ";", "rtx", "call_insn", "=", "emit_call_insn", "(", "gen_tls_gd_get_addr", "(", "sym", ")", ")", ";", "RTL_PURE_CALL_P", "(", "call_insn", ")", "=", "1", ";", "add_function_usage_to", "(", "call_insn", ",", "call_fusage", ")", ";", "rtx_insn", "*", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "rtx", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "r0", ",", "eqv", ")", ";", "return", "dest", ";", "}", "</s>" ]

[ "Helper", "to", "be", "used", "by", "TLS", "Global", "dynamic", "model", "." ]

[ "arc", "1" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "nios2_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "0", "||", "nios2_simple_const_p", "(", "x", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "0", ")", ";", "return", "true", ";", "}", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "case", "CONST_DOUBLE", ":", "if", "(", "gprel_constant_p", "(", "x", ")", "||", "r0rel_constant_p", "(", "x", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "case", "HIGH", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "0", ")", ";", "return", "true", ";", "}", "case", "LO_SUM", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "0", ")", ";", "return", "true", ";", "}", "case", "AND", ":", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "NOT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "NOT", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "case", "MULT", ":", "{", "if", "(", "!", "TARGET_HAS_MUL", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "5", ")", ";", "else", "if", "(", "speed", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "false", ";", "}", "case", "DIV", ":", "{", "if", "(", "!", "TARGET_HAS_DIV", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "5", ")", ";", "else", "if", "(", "speed", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "false", ";", "}", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "case", "ROTATE", ":", "{", "if", "(", "!", "speed", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "return", "false", ";", "}", "case", "ZERO_EXTRACT", ":", "if", "(", "TARGET_HAS_BMX", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "SIGN_EXTEND", ":", "{", "if", "(", "MEM_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "false", ";", "}", "case", "MEM", ":", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "*", "total", "=", "nios2_address_cost", "(", "addr", ",", "mode", ",", "ADDR_SPACE_GENERIC", ",", "speed", ")", ";", "if", "(", "outer_code", "==", "SET", "&&", "opno", "==", "0", ")", ";", "else", "if", "(", "outer_code", "==", "SET", "||", "outer_code", "==", "SIGN_EXTEND", "||", "outer_code", "==", "ZERO_EXTEND", ")", "{", "if", "(", "speed", ")", "*", "total", "+=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "else", "*", "total", "+=", "COSTS_N_INSNS", "(", "speed", "?", "2", ":", "1", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

[ "nios2", "0", "0", "1", "1", "1", "0", "0", "0", "1", "1", "5", "2", "1", "5", "2", "1", "1", "2", "1", "0", "1", "3", "0", "0", "1", "2", "1" ]

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ")", "{", "if", "(", "IsThumb", ")", "EmitThumbMappingSymbol", "(", ")", ";", "else", "EmitARMMappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "support_relaxed_compatible_p", "(", "const", "vector_insn_info", "&", "info1", ",", "const", "vector_insn_info", "&", "info2", ")", "{", "if", "(", "fault_first_load_p", "(", "info1", ".", "get_insn", "(", ")", "->", "rtl", "(", ")", ")", "&&", "info2", ".", "demand_p", "(", "DEMAND_AVL", ")", "&&", "info2", ".", "has_avl_reg", "(", ")", "&&", "info2", ".", "get_avl_source", "(", ")", "&&", "info2", ".", "get_avl_source", "(", ")", "->", "insn", "(", ")", "->", "is_phi", "(", ")", ")", "{", "hash_set", "<", "set_info", "*", ">", "sets", "=", "get_all_sets", "(", "info2", ".", "get_avl_source", "(", ")", ",", "true", ",", "false", ",", "false", ")", ";", "for", "(", "set_info", "*", "set", ":", "sets", ")", "{", "if", "(", "read_vl_insn_p", "(", "set", "->", "insn", "(", ")", "->", "rtl", "(", ")", ")", ")", "{", "const", "insn_info", "*", "insn", "=", "get_backward_fault_first_load_insn", "(", "set", "->", "insn", "(", ")", ")", ";", "if", "(", "insn", "==", "info1", ".", "get_insn", "(", ")", ")", "return", "info2", ".", "compatible_vtype_p", "(", "info1", ")", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "support", "relaxed", "compatible", "check", "." ]

[ "riscv" ]

[]

[ "<s>", "Cpu0Subtarget", "&", "Cpu0Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "initSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

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

[]

[ "<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", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "EnableHexagonHVX", ".", "getPosition", "(", ")", ")", "UseHVXOps", "=", "EnableHexagonHVX", ";", "if", "(", "EnableHexagonHVXDouble", ".", "getPosition", "(", ")", ")", "UseHVXDblOps", "=", "EnableHexagonHVXDouble", ";", "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>", "void", "F2003fInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register x\"", ";", "OS", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "BPF", "\"<register x\"", "\">\"", "\"'\"", "\"'\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "VA", ")", "override", "{", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "Register", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ExtReg", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "rtx", "rs6000_debug_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "rtx", "ret", ";", "rtx_insn", "*", "insns", ";", "start_sequence", "(", ")", ";", "ret", "=", "rs6000_legitimize_address", "(", "x", ",", "oldx", ",", "mode", ")", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "ret", "!=", "x", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nrs6000_legitimize_address: mode %s, old code %s, \"", "\"new code %s, modified\\n\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "x", ")", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "ret", ")", ")", ")", ";", "fprintf", "(", "stderr", ",", "\"Original address:\\n\"", ")", ";", "debug_rtx", "(", "x", ")", ";", "fprintf", "(", "stderr", ",", "\"oldx:\\n\"", ")", ";", "debug_rtx", "(", "oldx", ")", ";", "fprintf", "(", "stderr", ",", "\"New address:\\n\"", ")", ";", "debug_rtx", "(", "ret", ")", ";", "if", "(", "insns", ")", "{", "fprintf", "(", "stderr", ",", "\"Insns added:\\n\"", ")", ";", "debug_rtx_list", "(", "insns", ",", "20", ")", ";", "}", "}", "else", "{", "fprintf", "(", "stderr", ",", "\"\\nrs6000_legitimize_address: mode %s, code %s, no change:\\n\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "x", ")", ")", ")", ";", "debug_rtx", "(", "x", ")", ";", "}", "if", "(", "insns", ")", "emit_insn", "(", "insns", ")", ";", "return", "ret", ";", "}", "</s>" ]

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

[ "rs6000", "\"\\nrs6000_legitimize_address: mode %s, old code %s, \"", "\"new code %s, modified\\n\"", "\"Original address:\\n\"", "\"oldx:\\n\"", "\"New address:\\n\"", "\"Insns added:\\n\"", "20", "\"\\nrs6000_legitimize_address: mode %s, code %s, no change:\\n\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "V_MOV_B32_e32", ":", "case", "AMDGPU", "::", "V_MOV_B32_e64", ":", "case", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "return", "MI", ".", "getNumOperands", "(", ")", "==", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MOV_B32_e32", "AMDGPU::V_MOV_B32_e64", "AMDGPU::V_MOV_B64_PSEUDO" ]

[]

[ "<s>", "static", "void", "print_slot", "(", "rtx", "insn", ")", "{", "final_scan_insn", "(", "XVECEXP", "(", "insn", ",", "0", ",", "1", ")", ",", "asm_out_file", ",", "optimize", ",", "1", ",", "NULL", ")", ";", "INSN_DELETED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "1", ")", ")", "=", "1", ";", "}", "</s>" ]

[ "Print", "an", "instruction", "which", "would", "have", "gone", "into", "a", "delay", "slot", "after", "another", "instruction", ",", "but", "could", "n't", "because", "the", "other", "instruction", "expanded", "into", "a", "sequence", "where", "putting", "the", "slot", "insn", "at", "the", "end", "would", "n't", "work", "." ]

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

[]

[ "<s>", "const", "char", "*", "output_parallel_movb", "(", "rtx", "*", "operands", ",", "int", "length", ")", "{", "if", "(", "length", "==", "4", ")", "return", "\"mov%I1b,tr %1,%0,%2\"", ";", "if", "(", "dbr_sequence_length", "(", ")", "==", "0", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "return", "\"b %2\\n\\tldi %1,%0\"", ";", "else", "return", "\"b %2\\n\\tcopy %1,%0\"", ";", "}", "else", "{", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "return", "\"ldi %1,%0\\n\\tb %2\"", ";", "else", "return", "\"copy %1,%0\\n\\tb %2\"", ";", "}", "}", "</s>" ]

[ "Output", "an", "unconditional", "move", "and", "branch", "insn", "." ]

[ "pa", "4", "\"mov%I1b,tr %1,%0,%2\"", "0", "1", "\"b %2\\n\\tldi %1,%0\"", "\"b %2\\n\\tcopy %1,%0\"", "1", "\"ldi %1,%0\\n\\tb %2\"", "\"copy %1,%0\\n\\tb %2\"" ]

[]

[ "<s>", "int64_t", "SIRegisterInfo", "::", "getFrameIndexInstrOffset", "(", "const", "MachineInstr", "*", "MI", ",", "int", "Idx", ")", "const", "{", "if", "(", "!", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", ")", "return", "0", ";", "assert", "(", "Idx", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", "&&", "\"Should never see frame index on non-address operand\"", ")", ";", "int", "OffIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "return", "MI", "->", "getOperand", "(", "OffIdx", ")", ".", "getImm", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "offset", "from", "the", "referenced", "frame", "index", "in", "the", "instruction", ",", "if", "there", "is", "one", "." ]

[ "AMDGPU", "SI", "SI", "0", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "\"Should never see frame index on non-address operand\"", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName" ]

[]

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

[ "Enable", "tracking", "of", "subregister", "liveness", "in", "register", "allocator", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "MCInstrInfo", "*", "createMCInstrInfo", "(", ")", "{", "auto", "*", "X", "=", "new", "MCInstrInfo", "(", ")", ";", "InitWebAssemblyMCInstrInfo", "(", "X", ")", ";", "return", "X", ";", "}", "</s>" ]

[ "createMCInstrInfo", "-", "Create", "a", "MCInstrInfo", "implementation", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "MFI", "->", "isFixedObjectIndex", "(", "FI", ")", "&&", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "STI", ".", "isTargetWin64", "(", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "IgnoreSPUpdates", "&&", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "assert", "(", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getTCReturnAddrDelta", "(", ")", ">=", "0", "&&", "\"we don't handle this case!\"", ")", ";", "FrameReg", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "</s>" ]

[ "Same", "as", "getFrameIndexReference", ",", "except", "that", "the", "stack", "pointer", "(", "as", "opposed", "to", "the", "frame", "pointer", ")", "will", "be", "the", "preferred", "value", "for", "FrameReg", "." ]

[ "X86", "X86", "X86", "0", "\"we don't handle this case!\"" ]

[]

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

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

[ "Z80", "\"relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "static", "int", "rename_chain", "(", "tag_insn_info", "*", "insn_info", ",", "tag_map_t", "&", "tag_map", ",", "du_head_p", "head", ")", "{", "unsigned", "dest_regno", "=", "head", "->", "regno", ";", "if", "(", "head", "->", "cannot_rename", "||", "head", "->", "renamed", ")", "return", "-", "1", ";", "HARD_REG_SET", "unavailable", ";", "enum", "reg_class", "super_class", "=", "init_unavailable", "(", "insn_info", ",", "tag_map", ",", "head", ",", "&", "unavailable", ")", ";", "unsigned", "new_regno", "=", "find_rename_reg", "(", "head", ",", "super_class", ",", "&", "unavailable", ",", "dest_regno", ",", "false", ")", ";", "if", "(", "new_regno", "!=", "dest_regno", "&&", "regrename_do_replace", "(", "head", ",", "new_regno", ")", ")", "{", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "fprintf", "(", "dump_file", ",", "\"\\tInsn %d: Renamed %d to %d\\n\"", ",", "INSN_UID", "(", "insn_info", "->", "insn", ")", ",", "dest_regno", ",", "new_regno", ")", ";", "return", "new_regno", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Find", "a", "suitable", "and", "available", "register", "and", "rename", "the", "chain", "of", "occurrences", "of", "the", "register", "defined", "in", "the", "def/use", "chain", "headed", "by", "HEAD", "in", "which", "INSN", "exists", ".", "CUR_TAG", ",", "TAGS", "and", "TAG_MAP", "are", "used", "to", "determine", "which", "registers", "are", "unavailable", "due", "to", "a", "potential", "collision", "due", "to", "the", "rename", ".", "The", "routine", "returns", "the", "register", "number", "in", "case", "of", "a", "successful", "rename", "or", "-1", "to", "indicate", "failure", "." ]

[ "aarch64", "1", "\"\\tInsn %d: Renamed %d to %d\\n\"", "1" ]

[]

[ "<s>", "SDNode", "*", "mprocDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "}", "</s>" ]

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

[ "mproc", "mproc" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "storeOfVectorConstantIsCheap", "(", "EVT", "MemVT", ",", "unsigned", "NumElem", ",", "unsigned", "AS", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "expected", "to", "be", "cheaper", "to", "do", "a", "store", "of", "vector", "constant", "with", "the", "given", "size", "and", "type", "for", "the", "address", "space", "than", "to", "store", "the", "individual", "scalar", "element", "constants", "." ]

[ "R600" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "TII", "->", "isMIMG", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", ";", "unsigned", "VReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Writemask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "1", "<<", "i", ")", "?", "1", ":", "0", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "1", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_32RegClass", ";", "break", ";", "case", "2", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "3", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SparcAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SmallVector", "<", "MCInst", ",", "8", ">", "Instructions", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "SparcOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction mnemonic\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "8", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "Sparc", "\"invalid operand for instruction\"", "\"invalid instruction mnemonic\"" ]

[]

[ "<s>", "bool", "MandarinTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "Mandarin" ]

[]

[ "<s>", "MCSymbol", "*", "MipsELFStreamer", "::", "emitCFILabel", "(", ")", "{", "MCSymbol", "*", "Label", "=", "getContext", "(", ")", ".", "createTempSymbol", "(", "\"cfi\"", ",", "true", ")", ";", "MCELFStreamer", "::", "emitLabel", "(", "Label", ")", ";", "return", "Label", ";", "}", "</s>" ]

[ "When", "emitting", "an", "object", "file", ",", "create", "and", "emit", "a", "real", "label", "." ]

[ "Mips", "Mips", "\"cfi\"" ]

[]

[ "<s>", "static", "bool", "riscv_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "nregs", "=", "riscv_hard_regno_nregs", "(", "regno", ",", "mode", ")", ";", "if", "(", "GP_REG_P", "(", "regno", ")", ")", "{", "if", "(", "!", "GP_REG_P", "(", "regno", "+", "nregs", "-", "1", ")", ")", "return", "false", ";", "}", "else", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "{", "if", "(", "!", "FP_REG_P", "(", "regno", "+", "nregs", "-", "1", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_COMPLEX_FLOAT", ")", "return", "false", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ">", "UNITS_PER_FP_REG", "||", "(", "!", "call_used_regs", "[", "regno", "]", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ">", "UNITS_PER_FP_ARG", ")", ")", "return", "false", ";", "}", "else", "return", "false", ";", "for", "(", "unsigned", "i", "=", "1", ";", "i", "<", "nregs", ";", "i", "++", ")", "if", "(", "call_used_regs", "[", "regno", "]", "!=", "call_used_regs", "[", "regno", "+", "i", "]", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

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

[]

[ "<s>", "const", "uint16_t", "*", "Cpu0RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_O32_SaveList", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "canMergeStoresTo", "(", "EVT", "MemVT", ")", "const", "override", "{", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", ";", "}", "</s>" ]

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

[ "ARM", "32" ]

[]

[ "<s>", "void", "push_back", "(", "Value", "*", "V", ")", "{", "if", "(", "!", "S", ".", "count", "(", "V", ")", ")", "{", "Q", ".", "push_back", "(", "V", ")", ";", "S", ".", "insert", "(", "V", ")", ";", "}", "}", "</s>" ]

[ "Insert", "a", "node", "at", "the", "back", ";", "never", "copies", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "llvm_unreachable", "(", "\"TODO: implement eliminateCallFramePseudoInstr\"", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "WebAssembly", "WebAssembly", "\"TODO: implement eliminateCallFramePseudoInstr\"" ]

[]

[ "<s>", "static", "bool", "can_use_cdx_ldstw", "(", "int", "regno", ",", "int", "basereg", ",", "int", "offset", ")", "{", "if", "(", "CDX_REG_P", "(", "regno", ")", "&&", "CDX_REG_P", "(", "basereg", ")", "&&", "(", "offset", "&", "0x3", ")", "==", "0", "&&", "offset", ">=", "0", "&&", "offset", "<", "0x40", ")", "return", "true", ";", "else", "if", "(", "basereg", "==", "SP_REGNO", "&&", "offset", ">=", "0", "&&", "offset", "<", "0x80", "&&", "(", "offset", "&", "0x3", ")", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", ":", "return", "true", "if", "a", "load/store", "using", "REGNO", "with", "address", "BASEREG", "and", "offset", "OFFSET", "meets", "the", "constraints", "for", "a", "2-byte", "CDX", "ldw.n", ",", "stw.n", ",", "ldwsp.n", ",", "or", "stwsp.n", "instruction", "." ]

[ "nios2", "0x3", "0", "0", "0x40", "0", "0x80", "0x3", "0" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "unsigned", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "0", ",", "DL", ".", "getPointerSizeInBits", "(", "0", ")", ")", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "AddrReg", ",", "FI", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

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

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getLoadStoreImmIdx", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "return", "2", ";", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "STPXi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "LDNPXi", ":", "case", "AArch64", "::", "LDNPDi", ":", "case", "AArch64", "::", "STNPXi", ":", "case", "AArch64", "::", "STNPDi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "STPQi", ":", "case", "AArch64", "::", "LDNPQi", ":", "case", "AArch64", "::", "STNPQi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "STPWi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "LDNPWi", ":", "case", "AArch64", "::", "LDNPSi", ":", "case", "AArch64", "::", "STNPWi", ":", "case", "AArch64", "::", "STNPSi", ":", "case", "AArch64", "::", "LDG", ":", "case", "AArch64", "::", "STGPi", ":", "case", "AArch64", "::", "LD1B_IMM", ":", "case", "AArch64", "::", "LD1B_H_IMM", ":", "case", "AArch64", "::", "LD1B_S_IMM", ":", "case", "AArch64", "::", "LD1B_D_IMM", ":", "case", "AArch64", "::", "LD1SB_H_IMM", ":", "case", "AArch64", "::", "LD1SB_S_IMM", ":", "case", "AArch64", "::", "LD1SB_D_IMM", ":", "case", "AArch64", "::", "LD1H_IMM", ":", "case", "AArch64", "::", "LD1H_S_IMM", ":", "case", "AArch64", "::", "LD1H_D_IMM", ":", "case", "AArch64", "::", "LD1SH_S_IMM", ":", "case", "AArch64", "::", "LD1SH_D_IMM", ":", "case", "AArch64", "::", "LD1W_IMM", ":", "case", "AArch64", "::", "LD1W_D_IMM", ":", "case", "AArch64", "::", "LD1SW_D_IMM", ":", "case", "AArch64", "::", "LD1D_IMM", ":", "case", "AArch64", "::", "ST1B_IMM", ":", "case", "AArch64", "::", "ST1B_H_IMM", ":", "case", "AArch64", "::", "ST1B_S_IMM", ":", "case", "AArch64", "::", "ST1B_D_IMM", ":", "case", "AArch64", "::", "ST1H_IMM", ":", "case", "AArch64", "::", "ST1H_S_IMM", ":", "case", "AArch64", "::", "ST1H_D_IMM", ":", "case", "AArch64", "::", "ST1W_IMM", ":", "case", "AArch64", "::", "ST1W_D_IMM", ":", "case", "AArch64", "::", "ST1D_IMM", ":", "case", "AArch64", "::", "LD1RB_IMM", ":", "case", "AArch64", "::", "LD1RB_H_IMM", ":", "case", "AArch64", "::", "LD1RB_S_IMM", ":", "case", "AArch64", "::", "LD1RB_D_IMM", ":", "case", "AArch64", "::", "LD1RSB_H_IMM", ":", "case", "AArch64", "::", "LD1RSB_S_IMM", ":", "case", "AArch64", "::", "LD1RSB_D_IMM", ":", "case", "AArch64", "::", "LD1RH_IMM", ":", "case", "AArch64", "::", "LD1RH_S_IMM", ":", "case", "AArch64", "::", "LD1RH_D_IMM", ":", "case", "AArch64", "::", "LD1RSH_S_IMM", ":", "case", "AArch64", "::", "LD1RSH_D_IMM", ":", "case", "AArch64", "::", "LD1RW_IMM", ":", "case", "AArch64", "::", "LD1RW_D_IMM", ":", "case", "AArch64", "::", "LD1RSW_IMM", ":", "case", "AArch64", "::", "LD1RD_IMM", ":", "case", "AArch64", "::", "LDNT1B_ZRI", ":", "case", "AArch64", "::", "LDNT1H_ZRI", ":", "case", "AArch64", "::", "LDNT1W_ZRI", ":", "case", "AArch64", "::", "LDNT1D_ZRI", ":", "case", "AArch64", "::", "STNT1B_ZRI", ":", "case", "AArch64", "::", "STNT1H_ZRI", ":", "case", "AArch64", "::", "STNT1W_ZRI", ":", "case", "AArch64", "::", "STNT1D_ZRI", ":", "case", "AArch64", "::", "LDNF1B_IMM", ":", "case", "AArch64", "::", "LDNF1B_H_IMM", ":", "case", "AArch64", "::", "LDNF1B_S_IMM", ":", "case", "AArch64", "::", "LDNF1B_D_IMM", ":", "case", "AArch64", "::", "LDNF1SB_H_IMM", ":", "case", "AArch64", "::", "LDNF1SB_S_IMM", ":", "case", "AArch64", "::", "LDNF1SB_D_IMM", ":", "case", "AArch64", "::", "LDNF1H_IMM", ":", "case", "AArch64", "::", "LDNF1H_S_IMM", ":", "case", "AArch64", "::", "LDNF1H_D_IMM", ":", "case", "AArch64", "::", "LDNF1SH_S_IMM", ":", "case", "AArch64", "::", "LDNF1SH_D_IMM", ":", "case", "AArch64", "::", "LDNF1W_IMM", ":", "case", "AArch64", "::", "LDNF1W_D_IMM", ":", "case", "AArch64", "::", "LDNF1SW_D_IMM", ":", "case", "AArch64", "::", "LDNF1D_IMM", ":", "return", "3", ";", "case", "AArch64", "::", "ADDG", ":", "case", "AArch64", "::", "STGOffset", ":", "case", "AArch64", "::", "LDR_PXI", ":", "case", "AArch64", "::", "STR_PXI", ":", "return", "2", ";", "}", "}", "</s>" ]

[ "Returns", "the", "index", "for", "the", "immediate", "for", "a", "given", "instruction", "." ]

[ "AArch64", "AArch64", "2", "AArch64::LDPXi", "AArch64::LDPDi", "AArch64::STPXi", "AArch64::STPDi", "AArch64::LDNPXi", "AArch64::LDNPDi", "AArch64::STNPXi", "AArch64::STNPDi", "AArch64::LDPQi", "AArch64::STPQi", "AArch64::LDNPQi", "AArch64::STNPQi", "AArch64::LDPWi", "AArch64::LDPSi", "AArch64::STPWi", "AArch64::STPSi", "AArch64::LDNPWi", "AArch64::LDNPSi", "AArch64::STNPWi", "AArch64::STNPSi", "AArch64::LDG", "AArch64::STGPi", "AArch64::LD1B_IMM", "AArch64::LD1B_H_IMM", "AArch64::LD1B_S_IMM", "AArch64::LD1B_D_IMM", "AArch64::LD1SB_H_IMM", "AArch64::LD1SB_S_IMM", "AArch64::LD1SB_D_IMM", "AArch64::LD1H_IMM", "AArch64::LD1H_S_IMM", "AArch64::LD1H_D_IMM", "AArch64::LD1SH_S_IMM", "AArch64::LD1SH_D_IMM", "AArch64::LD1W_IMM", "AArch64::LD1W_D_IMM", "AArch64::LD1SW_D_IMM", "AArch64::LD1D_IMM", "AArch64::ST1B_IMM", "AArch64::ST1B_H_IMM", "AArch64::ST1B_S_IMM", "AArch64::ST1B_D_IMM", "AArch64::ST1H_IMM", "AArch64::ST1H_S_IMM", "AArch64::ST1H_D_IMM", "AArch64::ST1W_IMM", "AArch64::ST1W_D_IMM", "AArch64::ST1D_IMM", "AArch64::LD1RB_IMM", "AArch64::LD1RB_H_IMM", "AArch64::LD1RB_S_IMM", "AArch64::LD1RB_D_IMM", "AArch64::LD1RSB_H_IMM", "AArch64::LD1RSB_S_IMM", "AArch64::LD1RSB_D_IMM", "AArch64::LD1RH_IMM", "AArch64::LD1RH_S_IMM", "AArch64::LD1RH_D_IMM", "AArch64::LD1RSH_S_IMM", "AArch64::LD1RSH_D_IMM", "AArch64::LD1RW_IMM", "AArch64::LD1RW_D_IMM", "AArch64::LD1RSW_IMM", "AArch64::LD1RD_IMM", "AArch64::LDNT1B_ZRI", "AArch64::LDNT1H_ZRI", "AArch64::LDNT1W_ZRI", "AArch64::LDNT1D_ZRI", "AArch64::STNT1B_ZRI", "AArch64::STNT1H_ZRI", "AArch64::STNT1W_ZRI", "AArch64::STNT1D_ZRI", "AArch64::LDNF1B_IMM", "AArch64::LDNF1B_H_IMM", "AArch64::LDNF1B_S_IMM", "AArch64::LDNF1B_D_IMM", "AArch64::LDNF1SB_H_IMM", "AArch64::LDNF1SB_S_IMM", "AArch64::LDNF1SB_D_IMM", "AArch64::LDNF1H_IMM", "AArch64::LDNF1H_S_IMM", "AArch64::LDNF1H_D_IMM", "AArch64::LDNF1SH_S_IMM", "AArch64::LDNF1SH_D_IMM", "AArch64::LDNF1W_IMM", "AArch64::LDNF1W_D_IMM", "AArch64::LDNF1SW_D_IMM", "AArch64::LDNF1D_IMM", "3", "AArch64::ADDG", "AArch64::STGOffset", "AArch64::LDR_PXI", "AArch64::STR_PXI", "2" ]

[]

[ "<s>", "MVT", "SITargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "AMDGPU", "SI", "MVT::i32" ]

[]

[ "<s>", "Instruction", "*", "visitInstruction", "(", "Instruction", "&", "I", ")", "{", "return", "&", "I", ";", "}", "</s>" ]

[ "Specify", "what", "to", "return", "for", "unhandled", "instructions", "." ]

[ "SPIRV" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "if", "(", "EnableAtomicOptimizations", ")", "{", "addPass", "(", "createAMDGPUAtomicOptimizerPass", "(", ")", ")", ";", "}", "addPass", "(", "&", "AMDGPUUnifyDivergentExitNodesID", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "if", "(", "EnableStructurizerWorkarounds", ")", "{", "addPass", "(", "createUnifyLoopExitsPass", "(", ")", ")", ";", "}", "addPass", "(", "createStructurizeCFGPass", "(", "false", ")", ")", ";", "}", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "addPass", "(", "createLCSSAPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "unsigned", "getMaxCallFrameSize", "(", ")", "const", "{", "return", "MaxCallFrameSize", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "size", "of", "a", "call", "frame", "that", "must", "be", "allocated", "for", "an", "outgoing", "function", "call", "." ]

[ "P2" ]

[]

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

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

[ "AMDGPU", "\"R600 Packetizer\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "while", "(", "++", "I", "!=", "E", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "int", "PIdx", "=", "I", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "PIdx", "!=", "-", "1", "&&", "I", "->", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", "!=", "ARMCC", "::", "AL", ")", "return", "true", ";", "}", "return", "false", ";", "}", "int", "PIdx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "return", "PIdx", "!=", "-", "1", "&&", "MI", "->", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", "!=", "ARMCC", "::", "AL", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "ARM", "ARM", "1", "ARMCC::AL", "1", "ARMCC::AL" ]

[]

[ "<s>", "static", "void", "pa_output_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "ASM_OUTPUT_LABEL", "(", "file", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ",", "0", ")", ")", ";", "fputs", "(", "\"\\t.PROC\\n\"", ",", "file", ")", ";", "fprintf", "(", "file", ",", "\"\\t.CALLINFO FRAME=\"", "HOST_WIDE_INT_PRINT_DEC", ",", "actual_fsize", ")", ";", "if", "(", "crtl", "->", "is_leaf", ")", "fputs", "(", "\",NO_CALLS\"", ",", "file", ")", ";", "else", "fputs", "(", "\",CALLS\"", ",", "file", ")", ";", "if", "(", "rp_saved", ")", "fputs", "(", "\",SAVE_RP\"", ",", "file", ")", ";", "if", "(", "frame_pointer_needed", ")", "fputs", "(", "\",SAVE_SP\"", ",", "file", ")", ";", "if", "(", "gr_saved", ")", "fprintf", "(", "file", ",", "\",ENTRY_GR=%d\"", ",", "gr_saved", "+", "2", ")", ";", "if", "(", "fr_saved", ")", "fprintf", "(", "file", ",", "\",ENTRY_FR=%d\"", ",", "fr_saved", "+", "11", ")", ";", "fputs", "(", "\"\\n\\t.ENTRY\\n\"", ",", "file", ")", ";", "remove_useless_addtr_insns", "(", "0", ")", ";", "}", "</s>" ]

[ "On", "HP-PA", ",", "move-double", "insns", "between", "fpu", "and", "cpu", "need", "an", "8-byte", "block", "of", "memory", ".", "If", "any", "fpu", "reg", "is", "used", "in", "the", "function", ",", "we", "allocate", "such", "a", "block", "here", ",", "at", "the", "bottom", "of", "the", "frame", ",", "just", "in", "case", "it", "'s", "needed", ".", "If", "this", "function", "is", "a", "leaf", "procedure", ",", "then", "we", "may", "choose", "not", "to", "do", "a", "``", "save", "''", "insn", ".", "The", "decision", "about", "whether", "or", "not", "to", "do", "this", "is", "made", "in", "regclass.c", "." ]

[ "pa", "0", "0", "\"\\t.PROC\\n\"", "\"\\t.CALLINFO FRAME=\"", "\",NO_CALLS\"", "\",CALLS\"", "\",SAVE_RP\"", "\",SAVE_SP\"", "\",ENTRY_GR=%d\"", "2", "\",ENTRY_FR=%d\"", "11", "\"\\n\\t.ENTRY\\n\"", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", "lookup", "(", "const", "Value", "*", "V", ")", "const", "{", "return", "IDs", ".", "lookup", "(", "V", ")", ";", "}", "</s>" ]

[ "This", "method", "finds", "the", "value", "with", "the", "given", "Name", "in", "the", "the", "symbol", "table", "." ]

[ "DirectX" ]

[]

[ "<s>", "bool", "X86AvoidSFBPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "DisableX86AvoidStoreForwardBlocks", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", "||", "!", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86AvoidStoreForwardBlocks\\n\"", ";", ")", ";", "findPotentiallylBlockedCopies", "(", "MF", ")", ";", "for", "(", "auto", "LoadStoreInstPair", ":", "BlockedLoadsStoresPairs", ")", "{", "MachineInstr", "*", "LoadInst", "=", "LoadStoreInstPair", ".", "first", ";", "int64_t", "LdDispImm", "=", "getDispOperand", "(", "LoadInst", ")", ".", "getImm", "(", ")", ";", "DisplacementSizeMap", "BlockingStoresDispSizeMap", ";", "SmallVector", "<", "MachineInstr", "*", ",", "2", ">", "PotentialBlockers", "=", "findPotentialBlockers", "(", "LoadInst", ")", ";", "for", "(", "auto", "*", "PBInst", ":", "PotentialBlockers", ")", "{", "if", "(", "!", "isPotentialBlockingStoreInst", "(", "PBInst", "->", "getOpcode", "(", ")", ",", "LoadInst", "->", "getOpcode", "(", ")", ")", "||", "!", "isRelevantAddressingMode", "(", "PBInst", ")", "||", "!", "PBInst", "->", "hasOneMemOperand", "(", ")", ")", "continue", ";", "int64_t", "PBstDispImm", "=", "getDispOperand", "(", "PBInst", ")", ".", "getImm", "(", ")", ";", "unsigned", "PBstSize", "=", "(", "*", "PBInst", "->", "memoperands_begin", "(", ")", ")", "->", "getSize", "(", ")", ";", "if", "(", "hasSameBaseOpValue", "(", "LoadInst", ",", "PBInst", ")", "&&", "isBlockingStore", "(", "LdDispImm", ",", "getRegSizeInBytes", "(", "LoadInst", ")", ",", "PBstDispImm", ",", "PBstSize", ")", ")", "updateBlockingStoresDispSizeMap", "(", "BlockingStoresDispSizeMap", ",", "PBstDispImm", ",", "PBstSize", ")", ";", "}", "if", "(", "BlockingStoresDispSizeMap", ".", "empty", "(", ")", ")", "continue", ";", "MachineInstr", "*", "StoreInst", "=", "LoadStoreInstPair", ".", "second", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Blocked load and store instructions: \\n\"", ")", ";", "LLVM_DEBUG", "(", "LoadInst", "->", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "StoreInst", "->", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Replaced with:\\n\"", ")", ";", "removeRedundantBlockingStores", "(", "BlockingStoresDispSizeMap", ")", ";", "breakBlockedCopies", "(", "LoadInst", ",", "StoreInst", ",", "BlockingStoresDispSizeMap", ")", ";", "updateKillStatus", "(", "LoadInst", ",", "StoreInst", ")", ";", "ForRemoval", ".", "push_back", "(", "LoadInst", ")", ";", "ForRemoval", ".", "push_back", "(", "StoreInst", ")", ";", "}", "for", "(", "auto", "*", "RemovedInst", ":", "ForRemoval", ")", "{", "RemovedInst", "->", "eraseFromParent", "(", ")", ";", "}", "ForRemoval", ".", "clear", "(", ")", ";", "BlockedLoadsStoresPairs", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86AvoidStoreForwardBlocks\\n\"", ";", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"Expected MIR to be in SSA form\"", "X86", "X86", "\"Start X86AvoidStoreForwardBlocks\\n\"", "2", "\"Blocked load and store instructions: \\n\"", "\"Replaced with:\\n\"", "\"End X86AvoidStoreForwardBlocks\\n\"" ]

[]

[ "<s>", "void", "s390_sched_dependencies_evaluation", "(", "rtx_insn", "*", "head", ",", "rtx_insn", "*", "tail", ")", "{", "if", "(", "!", "frame_pointer_needed", "||", "!", "epilogue_completed", ")", "return", ";", "while", "(", "head", "!=", "tail", "&&", "DEBUG_INSN_P", "(", "head", ")", ")", "head", "=", "NEXT_INSN", "(", "head", ")", ";", "rtx_insn", "*", "r15_restore", "=", "NULL", ",", "*", "r11_restore", "=", "NULL", ";", "for", "(", "rtx_insn", "*", "insn", "=", "tail", ";", "insn", "!=", "head", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "!", "RTX_FRAME_RELATED_P", "(", "insn", ")", "||", "set", "==", "NULL_RTX", "||", "!", "REG_P", "(", "SET_DEST", "(", "set", ")", ")", "||", "!", "FP_REG_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "continue", ";", "if", "(", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "r11_restore", "=", "insn", ";", "if", "(", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", "==", "STACK_POINTER_REGNUM", ")", "r15_restore", "=", "insn", ";", "}", "if", "(", "r11_restore", "==", "NULL", "||", "r15_restore", "==", "NULL", ")", "return", ";", "add_dependence", "(", "r11_restore", ",", "r15_restore", ",", "REG_DEP_ANTI", ")", ";", "}", "</s>" ]

[ "Evaluate", "the", "insns", "between", "HEAD", "and", "TAIL", "and", "do", "back-end", "to", "install", "back-end", "specific", "dependencies", ".", "Establish", "an", "ANTI", "dependency", "between", "r11", "and", "r15", "restores", "from", "FPRs", "to", "prevent", "the", "instructions", "scheduler", "from", "reordering", "them", "since", "this", "would", "break", "CFI", ".", "No", "further", "handling", "in", "the", "sched_reorder", "hook", "is", "required", "since", "the", "r11", "and", "r15", "restore", "will", "never", "appear", "in", "the", "same", "ready", "list", "with", "that", "change", "." ]

[ "s390" ]

[]

[ "<s>", "static", "bool", "thumb2_index_mul_operand", "(", "rtx", "op", ")", "{", "HOST_WIDE_INT", "val", ";", "if", "(", "!", "CONST_INT_P", "(", "op", ")", ")", "return", "false", ";", "val", "=", "INTVAL", "(", "op", ")", ";", "return", "(", "val", "==", "1", "||", "val", "==", "2", "||", "val", "==", "4", "||", "val", "==", "8", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "valid", "index", "scaling", "factor", "for", "Thumb-2", "address", "index", "operand", ".", "i.e", ".", "1", ",", "2", ",", "4", "or", "8", "." ]

[ "arm", "1", "2", "4", "8" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "RM", ",", "CM", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DataLayout", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "PPCRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "TM", ".", "isELFv2ABI", "(", ")", "||", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasP9Vector", "(", ")", "&&", "EnableGPRToVecSpills", "&&", "RC", "==", "&", "PPC", "::", "G8RCRegClass", ")", "{", "InflateGP8RC", "++", ";", "return", "&", "PPC", "::", "SPILLTOVSRRCRegClass", ";", "}", "if", "(", "RC", "==", "&", "PPC", "::", "GPRCRegClass", "&&", "EnableGPRToVecSpills", ")", "InflateGPRC", "++", ";", "}", "if", "(", "RC", "==", "&", "PPC", "::", "F8RCRegClass", ")", "return", "&", "PPC", "::", "VSFRCRegClass", ";", "else", "if", "(", "RC", "==", "&", "PPC", "::", "VRRCRegClass", ")", "return", "&", "PPC", "::", "VSRCRegClass", ";", "else", "if", "(", "RC", "==", "&", "PPC", "::", "F4RCRegClass", "&&", "Subtarget", ".", "hasP8Vector", "(", ")", ")", "return", "&", "PPC", "::", "VSSRCRegClass", ";", "}", "return", "TargetRegisterInfo", "::", "getLargestLegalSuperClass", "(", "RC", ",", "MF", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::SPILLTOVSRRCRegClass", "PPC::GPRCRegClass", "PPC::F8RCRegClass", "PPC::VSFRCRegClass", "PPC::VRRCRegClass", "PPC::VSRCRegClass", "PPC::F4RCRegClass", "PPC::VSSRCRegClass" ]

[]

[ "<s>", "bool", "SIModeRegister", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "BB", ":", "MF", ")", "processBlockPhase1", "(", "BB", ",", "TII", ")", ";", "for", "(", "MachineBasicBlock", "&", "BB", ":", "MF", ")", "Phase2List", ".", "push", "(", "&", "BB", ")", ";", "while", "(", "!", "Phase2List", ".", "empty", "(", ")", ")", "{", "processBlockPhase2", "(", "*", "Phase2List", ".", "front", "(", ")", ",", "TII", ")", ";", "Phase2List", ".", "pop", "(", ")", ";", "}", "for", "(", "MachineBasicBlock", "&", "BB", ":", "MF", ")", "processBlockPhase3", "(", "BB", ",", "TII", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "rs6000_define_or_undefine_macro", "(", "bool", "define_p", ",", "const", "char", "*", "name", ")", "{", "if", "(", "TARGET_DEBUG_BUILTIN", "||", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"#%s %s\\n\"", ",", "(", "define_p", ")", "?", "\"define\"", ":", "\"undef\"", ",", "name", ")", ";", "if", "(", "define_p", ")", "cpp_define", "(", "parse_in", ",", "name", ")", ";", "else", "cpp_undef", "(", "parse_in", ",", "name", ")", ";", "}", "</s>" ]

[ "Define", "or", "undefine", "a", "single", "macro", "." ]

[ "rs6000", "\"#%s %s\\n\"", "\"define\"", "\"undef\"" ]

[]

[ "<s>", "bool", "hasAndNotCompare", "(", "SDValue", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "should", "transform", ":", "(", "X", "&", "Y", ")", "==", "Y", "�", "?", "(", "~X", "&", "Y", ")", "==", "0", "(", "X", "&", "Y", ")", "!", "=", "Y", "�", "?", "(", "~X", "&", "Y", ")", "!", "=", "0", "." ]

[ "PowerPC" ]

[]

[ "<s>", "static", "void", "arm_option_check_internal", "(", "struct", "gcc_options", "*", "opts", ")", "{", "int", "flags", "=", "opts", "->", "x_target_flags", ";", "if", "(", "TARGET_IWMMXT", "&&", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_neon", ")", ")", "error", "(", "\"iWMMXt and NEON are incompatible\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_notm", ")", ")", "error", "(", "\"target CPU does not support ARM mode\"", ")", ";", "if", "(", "(", "TARGET_TPCS_FRAME", "||", "TARGET_TPCS_LEAF_FRAME", ")", "&&", "TARGET_ARM_P", "(", "flags", ")", ")", "warning", "(", "0", ",", "\"enabling backtrace support is only meaningful when compiling for the Thumb\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "TARGET_CALLEE_INTERWORKING", ")", "warning", "(", "0", ",", "\"enabling callee interworking support is only meaningful when compiling for the Thumb\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "write_symbols", "!=", "NO_DEBUG", "&&", "!", "TARGET_APCS_FRAME", "&&", "(", "TARGET_DEFAULT", "&", "MASK_APCS_FRAME", ")", ")", "warning", "(", "0", ",", "\"%<-g%> with %<-mno-apcs-frame%> may not give sensible \"", "\"debugging\"", ")", ";", "if", "(", "TARGET_THUMB_P", "(", "flags", ")", "&&", "TARGET_IWMMXT", ")", "error", "(", "\"iWMMXt unsupported under Thumb mode\"", ")", ";", "if", "(", "TARGET_HARD_TP", "&&", "TARGET_THUMB1_P", "(", "flags", ")", ")", "error", "(", "\"cannot use %<-mtp=cp15%> with 16-bit Thumb\"", ")", ";", "if", "(", "TARGET_THUMB_P", "(", "flags", ")", "&&", "TARGET_VXWORKS_RTP", "&&", "flag_pic", ")", "{", "error", "(", "\"RTP PIC is incompatible with Thumb\"", ")", ";", "flag_pic", "=", "0", ";", "}", "if", "(", "target_pure_code", "||", "target_slow_flash_data", ")", "{", "const", "char", "*", "flag", "=", "(", "target_pure_code", "?", "\"-mpure-code\"", ":", "\"-mslow-flash-data\"", ")", ";", "bool", "common_unsupported_modes", "=", "arm_arch_notm", "||", "flag_pic", "||", "TARGET_NEON", ";", "if", "(", "target_slow_flash_data", "&&", "(", "!", "TARGET_HAVE_MOVT", "||", "common_unsupported_modes", ")", ")", "error", "(", "\"%s only supports non-pic code on M-profile targets with the \"", "\"MOVT instruction\"", ",", "flag", ")", ";", "if", "(", "target_pure_code", "&&", "common_unsupported_modes", ")", "error", "(", "\"%s only supports non-pic code on M-profile targets\"", ",", "flag", ")", ";", "if", "(", "target_word_relocations", ")", "error", "(", "\"%s incompatible with %<-mword-relocations%>\"", ",", "flag", ")", ";", "}", "}", "</s>" ]

[ "Check", "any", "incompatible", "options", "that", "the", "user", "has", "specified", "." ]

[ "arm", "\"iWMMXt and NEON are incompatible\"", "\"target CPU does not support ARM mode\"", "0", "\"enabling backtrace support is only meaningful when compiling for the Thumb\"", "0", "\"enabling callee interworking support is only meaningful when compiling for the Thumb\"", "0", "\"%<-g%> with %<-mno-apcs-frame%> may not give sensible \"", "\"debugging\"", "\"iWMMXt unsupported under Thumb mode\"", "\"cannot use %<-mtp=cp15%> with 16-bit Thumb\"", "\"RTP PIC is incompatible with Thumb\"", "0", "\"-mpure-code\"", "\"-mslow-flash-data\"", "\"%s only supports non-pic code on M-profile targets with the \"", "\"MOVT instruction\"", "\"%s only supports non-pic code on M-profile targets\"", "\"%s incompatible with %<-mword-relocations%>\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ",", "bool", "OutlineFromLinkOnceODRs", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "has128ByteRedZone", "(", "MF", ")", ")", "{", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "X86FI", "||", "X86FI", "->", "getUsesRedZone", "(", ")", ")", "return", "false", ";", "}", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", ".", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

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

[]

[ "<s>", "void", "MipsTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Res", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "isTruncateFree", "(", "Type", "*", "SrcTy", ",", "Type", "*", "DstTy", ")", "const", "override", "{", "if", "(", "!", "SrcTy", "->", "isIntegerTy", "(", ")", "||", "!", "DstTy", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "return", "SrcTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", "&&", "DstTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "32", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "NVPTX", "64", "32" ]

[]

[ "<s>", "void", "PPCMachOTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileMachO", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "LSDASection", "=", "getMachOSection", "(", "\"__TEXT\"", ",", "\"__gcc_except_tab\"", ",", "0", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "PowerPC", "PPC", "\"__TEXT\"", "\"__gcc_except_tab\"", "0" ]

[]

[ "<s>", "void", "notice_update_cc", "(", "rtx", "body", ",", "rtx", "insn", ")", "{", "switch", "(", "get_attr_cc", "(", "insn", ")", ")", "{", "case", "CC_NONE", ":", "break", ";", "case", "CC_NONE_0HIT", ":", "if", "(", "cc_status", ".", "value1", "!=", "0", "&&", "reg_overlap_mentioned_p", "(", "recog_data", ".", "operand", "[", "0", "]", ",", "cc_status", ".", "value1", ")", ")", "cc_status", ".", "value1", "=", "0", ";", "break", ";", "case", "CC_SET_ZN", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "flags", "|=", "CC_NO_CARRY", "|", "CC_OVERFLOW_UNUSABLE", ";", "cc_status", ".", "value1", "=", "recog_data", ".", "operand", "[", "0", "]", ";", "break", ";", "case", "CC_SET_ZNV", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "flags", "|=", "CC_NO_CARRY", ";", "cc_status", ".", "value1", "=", "recog_data", ".", "operand", "[", "0", "]", ";", "break", ";", "case", "CC_COMPARE", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "value1", "=", "SET_SRC", "(", "body", ")", ";", "if", "(", "GET_CODE", "(", "cc_status", ".", "value1", ")", "==", "COMPARE", "&&", "GET_MODE", "(", "XEXP", "(", "cc_status", ".", "value1", ",", "0", ")", ")", "==", "SFmode", ")", "cc_status", ".", "mdep", ".", "fpCC", "=", "1", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "On", "the", "68000", ",", "all", "the", "insns", "to", "store", "in", "an", "address", "register", "fail", "to", "set", "the", "cc", "'s", ".", "However", ",", "in", "some", "cases", "these", "instructions", "can", "make", "it", "possibly", "invalid", "to", "use", "the", "saved", "cc", "'s", ".", "In", "those", "cases", "we", "clear", "out", "some", "or", "all", "of", "the", "saved", "cc", "'s", "so", "they", "wo", "n't", "be", "used", "." ]

[ "mn10300", "0", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "const", "TargetInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "AddrMode", "=", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "if", "(", "AddrMode", "==", "ARMII", "::", "AddrMode4", "||", "AddrMode", "==", "ARMII", "::", "AddrMode6", ")", "return", "Offset", "==", "0", ";", "unsigned", "NumBits", "=", "0", ";", "unsigned", "Scale", "=", "1", ";", "bool", "isSigned", "=", "true", ";", "switch", "(", "AddrMode", ")", "{", "case", "ARMII", "::", "AddrModeT2_i8", ":", "case", "ARMII", "::", "AddrModeT2_i12", ":", "Scale", "=", "1", ";", "if", "(", "Offset", "<", "0", ")", "{", "NumBits", "=", "8", ";", "Offset", "=", "-", "Offset", ";", "}", "else", "{", "NumBits", "=", "12", ";", "}", "break", ";", "case", "ARMII", "::", "AddrMode5", ":", "NumBits", "=", "8", ";", "Scale", "=", "4", ";", "break", ";", "case", "ARMII", "::", "AddrMode2", ":", "NumBits", "=", "12", ";", "break", ";", "case", "ARMII", "::", "AddrMode3", ":", "NumBits", "=", "8", ";", "break", ";", "case", "ARMII", "::", "AddrModeT1_s", ":", "NumBits", "=", "5", ";", "Scale", "=", "4", ";", "isSigned", "=", "false", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported addressing mode!\"", ")", ";", "break", ";", "}", "Offset", "+=", "getFrameIndexInstrOffset", "(", "MI", ",", "i", ")", ";", "if", "(", "(", "Offset", "&", "(", "Scale", "-", "1", ")", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "isSigned", "&&", "Offset", "<", "0", ")", "Offset", "=", "-", "Offset", ";", "unsigned", "Mask", "=", "(", "1", "<<", "NumBits", ")", "-", "1", ";", "if", "(", "(", "unsigned", ")", "Offset", "<=", "Mask", "*", "Scale", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "ARM", "ARM", "ARMII::AddrModeMask", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARMII::AddrMode4", "ARMII::AddrMode6", "0", "0", "1", "ARMII::AddrModeT2_i8", "ARMII::AddrModeT2_i12", "1", "0", "8", "12", "ARMII::AddrMode5", "8", "4", "ARMII::AddrMode2", "12", "ARMII::AddrMode3", "8", "ARMII::AddrModeT1_s", "5", "4", "\"Unsupported addressing mode!\"", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "static", "bool", "extract_base_offset_in_addr", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "{", "*", "base", "=", "addr", ";", "*", "offset", "=", "const0_rtx", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "{", "*", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "true", ";", "}", "*", "base", "=", "NULL_RTX", ";", "*", "offset", "=", "NULL_RTX", ";", "return", "false", ";", "}", "</s>" ]

[ "If", "MEM", "is", "in", "the", "form", "of", "``", "base+offset", "''", ",", "extract", "the", "two", "parts", "of", "address", "and", "set", "to", "BASE", "and", "OFFSET", ",", "otherwise", "return", "false", "after", "clearing", "BASE", "and", "OFFSET", "." ]

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

[]

[ "<s>", "bool", "DeadCodeElimination", "::", "collect", "(", ")", "{", "LiveNodes", ".", "clear", "(", ")", ";", "SetQueue", "<", "NodeId", ">", "WorkQ", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "DFG", ".", "getFunc", "(", ")", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "for", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ":", "BA", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "scanInstr", "(", "IA", ",", "WorkQ", ")", ";", "while", "(", "!", "WorkQ", ".", "empty", "(", ")", ")", "{", "NodeId", "N", "=", "WorkQ", ".", "pop_front", "(", ")", ";", "LiveNodes", ".", "insert", "(", "N", ")", ";", "auto", "RA", "=", "DFG", ".", "addr", "<", "RefNode", "*", ">", "(", "N", ")", ";", "if", "(", "DFG", ".", "IsDef", "(", "RA", ")", ")", "processDef", "(", "RA", ",", "WorkQ", ")", ";", "else", "processUse", "(", "RA", ",", "WorkQ", ")", ";", "}", "if", "(", "trace", "(", ")", ")", "{", "dbgs", "(", ")", "<<", "\"Live nodes:\\n\"", ";", "for", "(", "NodeId", "N", ":", "LiveNodes", ")", "{", "auto", "RA", "=", "DFG", ".", "addr", "<", "RefNode", "*", ">", "(", "N", ")", ";", "dbgs", "(", ")", "<<", "PrintNode", "<", "RefNode", "*", ">", "(", "RA", ",", "DFG", ")", "<<", "\"\\n\"", ";", "}", "}", "auto", "IsDead", "=", "[", "this", "]", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ")", "->", "bool", "{", "for", "(", "NodeAddr", "<", "DefNode", "*", ">", "DA", ":", "IA", ".", "Addr", "->", "members_if", "(", "DFG", ".", "IsDef", ",", "DFG", ")", ")", "if", "(", "LiveNodes", ".", "count", "(", "DA", ".", "Id", ")", ")", "return", "false", ";", "return", "true", ";", "}", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "DFG", ".", "getFunc", "(", ")", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "{", "for", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ":", "BA", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "{", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "IA", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "if", "(", "!", "LiveNodes", ".", "count", "(", "RA", ".", "Id", ")", ")", "DeadNodes", ".", "insert", "(", "RA", ".", "Id", ")", ";", "if", "(", "DFG", ".", "IsCode", "<", "NodeAttrs", "::", "Stmt", ">", "(", "IA", ")", ")", "if", "(", "isLiveInstr", "(", "NodeAddr", "<", "StmtNode", "*", ">", "(", "IA", ")", ".", "Addr", "->", "getCode", "(", ")", ")", ")", "continue", ";", "if", "(", "IsDead", "(", "IA", ")", ")", "{", "DeadInstrs", ".", "insert", "(", "IA", ".", "Id", ")", ";", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Dead instr: \"", "<<", "PrintNode", "<", "InstrNode", "*", ">", "(", "IA", ",", "DFG", ")", "<<", "\"\\n\"", ";", "}", "}", "}", "return", "!", "DeadNodes", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Live nodes:\\n\"", "\"\\n\"", "\"Dead instr: \"", "\"\\n\"" ]

[]

[ "<s>", "inline", "machine_mode", "function_checker", "::", "ret_mode", "(", ")", "const", "{", "return", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "machine_mode", "of", "the", "corresponding", "return", "type", "." ]

[ "riscv" ]

[]

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

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

[ "rs6000" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "assert", "(", "TheModule", "==", "&", "M", ")", ";", "TheModule", "=", "nullptr", ";", "EHLinkRegistrationTy", "=", "nullptr", ";", "CXXEHRegistrationTy", "=", "nullptr", ";", "SEHRegistrationTy", "=", "nullptr", ";", "SetJmp3", "=", "nullptr", ";", "CxxLongjmpUnwind", "=", "nullptr", ";", "SehLongjmpUnwind", "=", "nullptr", ";", "Cookie", "=", "nullptr", ";", "return", "false", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "X86" ]

[]

[ "<s>", "enum", "reg_class", "aarch64_regno_regclass", "(", "unsigned", "regno", ")", "{", "if", "(", "GP_REGNUM_P", "(", "regno", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "STACK_REG", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "POINTER_REGS", ";", "if", "(", "FP_REGNUM_P", "(", "regno", ")", ")", "return", "(", "FP_LO8_REGNUM_P", "(", "regno", ")", "?", "FP_LO8_REGS", ":", "FP_LO_REGNUM_P", "(", "regno", ")", "?", "FP_LO_REGS", ":", "FP_REGS", ")", ";", "if", "(", "PR_REGNUM_P", "(", "regno", ")", ")", "return", "PR_LO_REGNUM_P", "(", "regno", ")", "?", "PR_LO_REGS", ":", "PR_HI_REGS", ";", "if", "(", "regno", "==", "FFR_REGNUM", "||", "regno", "==", "FFRT_REGNUM", ")", "return", "FFR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "REGNO_REG_CLASS", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_store_pair", "(", "machine_mode", "mode", ",", "rtx", "mem1", ",", "rtx", "reg1", ",", "rtx", "mem2", ",", "rtx", "reg2", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "return", "gen_store_pairdi", "(", "mem1", ",", "reg1", ",", "mem2", ",", "reg2", ")", ";", "case", "E_DFmode", ":", "return", "gen_store_pairdf", "(", "mem1", ",", "reg1", ",", "mem2", ",", "reg2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "and", "return", "a", "store", "pair", "instruction", "of", "mode", "MODE", "to", "store", "register", "REG1", "to", "MEM1", "and", "register", "REG2", "to", "MEM2", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMSubtarget", "&", "st", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "assert", "(", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", "&&", "\"Thumb1 can only copy GPR registers\"", ")", ";", "if", "(", "st", ".", "hasV6Ops", "(", ")", "||", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "SrcReg", ")", "||", "!", "ARM", "::", "tGPRRegClass", ".", "contains", "(", "DestReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tMOVr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tPUSH", ")", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tPOP", ")", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM::GPRRegClass", "\"Thumb1 can only copy GPR registers\"", "ARM::hGPRRegClass", "ARM::tGPRRegClass", "ARM::tMOVr", "ARMCC::AL", "ARM::tPUSH", "ARMCC::AL", "ARM::tPOP", "ARMCC::AL" ]

[]

[ "<s>", "static", "void", "*", "cygwin_gt_pch_get_address", "(", "size_t", "sz", ",", "int", "fd", ")", "{", "void", "*", "base", ";", "off_t", "p", "=", "lseek", "(", "fd", ",", "0", ",", "SEEK_CUR", ")", ";", "if", "(", "p", "==", "(", "off_t", ")", "-", "1", ")", "fatal_error", "(", "input_location", ",", "\"cannot get position in PCH file: %m\"", ")", ";", "if", "(", "(", "size_t", ")", "p", "<", "sz", ")", "{", "if", "(", "ftruncate", "(", "fd", ",", "sz", ")", "==", "-", "1", ")", "fatal_error", "(", "input_location", ",", "\"cannot extend PCH file: %m\"", ")", ";", "}", "base", "=", "mmap", "(", "NULL", ",", "sz", ",", "PROT_READ", "|", "PROT_WRITE", ",", "MAP_PRIVATE", ",", "fd", ",", "0", ")", ";", "if", "(", "base", "==", "MAP_FAILED", ")", "base", "=", "NULL", ";", "else", "munmap", "(", "base", ",", "sz", ")", ";", "if", "(", "lseek", "(", "fd", ",", "p", ",", "SEEK_SET", ")", "==", "(", "off_t", ")", "-", "1", ")", "fatal_error", "(", "input_location", ",", "\"cannot set position in PCH file: %m\"", ")", ";", "return", "base", ";", "}", "</s>" ]

[ "Identify", "an", "address", "that", "'s", "likely", "to", "be", "free", "in", "a", "subsequent", "invocation", "of", "the", "compiler", ".", "The", "area", "should", "be", "able", "to", "hold", "SIZE", "bytes", ".", "FD", "is", "an", "open", "file", "descriptor", "if", "the", "host", "would", "like", "to", "probe", "with", "mmap", "." ]

[ "i386", "0", "1", "\"cannot get position in PCH file: %m\"", "1", "\"cannot extend PCH file: %m\"", "0", "1", "\"cannot set position in PCH file: %m\"" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "X86DomainReassignment", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "DisableX86DomainReassignment", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function before Domain Reassignment *****\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "hasAVX512", "(", ")", "||", "!", "STI", "->", "hasBWI", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "initConverters", "(", ")", ";", "bool", "Changed", "=", "false", ";", "EnclosedEdges", ".", "clear", "(", ")", ";", "EnclosedInstrs", ".", "clear", "(", ")", ";", "std", "::", "vector", "<", "Closure", ">", "Closures", ";", "unsigned", "ClosureID", "=", "0", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "++", "Idx", ")", "{", "Register", "Reg", "=", "Register", "::", "index2VirtReg", "(", "Idx", ")", ";", "if", "(", "!", "isGPR", "(", "MRI", "->", "getRegClass", "(", "Reg", ")", ")", ")", "continue", ";", "if", "(", "EnclosedEdges", ".", "count", "(", "Reg", ")", ")", "continue", ";", "Closure", "C", "(", "ClosureID", "++", ",", "{", "MaskDomain", "}", ")", ";", "buildClosure", "(", "C", ",", "Reg", ")", ";", "if", "(", "!", "C", ".", "empty", "(", ")", "&&", "C", ".", "isLegal", "(", "MaskDomain", ")", ")", "Closures", ".", "push_back", "(", "std", "::", "move", "(", "C", ")", ")", ";", "}", "for", "(", "Closure", "&", "C", ":", "Closures", ")", "{", "LLVM_DEBUG", "(", "C", ".", "dump", "(", "MRI", ")", ")", ";", "if", "(", "isReassignmentProfitable", "(", "C", ",", "MaskDomain", ")", ")", "{", "reassign", "(", "C", ",", "MaskDomain", ")", ";", "++", "NumClosuresConverted", ";", "Changed", "=", "true", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function after Domain Reassignment *****\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"***** Machine Function before Domain Reassignment *****\\n\"", "X86", "\"Expected MIR to be in SSA form\"", "0", "0", "\"***** Machine Function after Domain Reassignment *****\\n\"" ]

[]