Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "AArch64ConditionalCompares", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Compares **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SchedModel", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getSchedModel", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Loops", "=", "getAnalysisIfAvailable", "<", "MachineLoopInfo", ">", "(", ")", ";", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "MinSize", "=", "MF", ".", "getFunction", "(", ")", ".", "optForMinSize", "(", ")", ";", "bool", "Changed", "=", "false", ";", "CmpConv", ".", "runOnMachineFunction", "(", "MF", ",", "MBPI", ")", ";", "for", "(", "auto", "*", "I", ":", "depth_first", "(", "DomTree", ")", ")", "if", "(", "tryConvert", "(", "I", "->", "getBlock", "(", ")", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Compares **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "void", "print", "(", "DiagnosticPrinter", "&", "DP", ")", "const", "override", "{", "DP", "<<", "\"unsupported \"", "<<", "getDescription", "(", ")", "<<", "\" in \"", "<<", "Fn", ".", "getName", "(", ")", ";", "}", "</s>" ]

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

[ "R600", "\"unsupported \"", "\" in \"" ]

[]

[ "<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "flag_delete_null_pointer_checks", "=", "0", ";", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "maybe_set_param_value", "(", "PARAM_ALLOW_STORE_DATA_RACES", ",", "1", ",", "global_options", ".", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"-fpic is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"-fPIC is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"-fpie is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"-fPIE is not supported\"", ")", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "avr_register_passes", "(", ")", ";", "}", "</s>" ]

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

[ "avr", "0", "0", "1", "0", "1", "\"-fpic is not supported\"", "2", "\"-fPIC is not supported\"", "1", "\"-fpie is not supported\"", "2", "\"-fPIE is not supported\"", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1" ]

[]

[ "<s>", "void", "emit_symbolic_move", "(", "rtx", "*", "operands", ")", "{", "rtx", "temp", "=", "!", "can_create_pseudo_p", "(", ")", "?", "operands", "[", "0", "]", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "Pmode", ",", "operands", "[", "1", "]", ")", ";", "else", "if", "(", "TLS_SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "operands", "[", "1", "]", "=", "legitimize_tls_address", "(", "operands", "[", "1", "]", ",", "temp", ")", ";", "else", "if", "(", "flag_pic", ")", "operands", "[", "1", "]", "=", "legitimize_pic_address", "(", "operands", "[", "1", "]", ",", "temp", ")", ";", "}", "</s>" ]

[ "Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "." ]

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

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "CSI", ")", "{", "Register", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "8", "&&", "\"Invalid register size\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPRd", ")", ",", "Reg", ")", ";", "}", "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", "(", ")", "." ]

[ "AVR", "AVR", "AVR", "AVR", "8", "\"Invalid register size\"", "AVR::POPRd" ]

[]

[ "<s>", "static", "rtx", "nios2_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "nios2_legitimize_constant_address", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST", ")", "{", "rtx", "unspec", ",", "offset", ",", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "split_const", "(", "XEXP", "(", "x", ",", "1", ")", ",", "&", "unspec", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", "&&", "!", "nios2_large_offset_p", "(", "XINT", "(", "unspec", ",", "1", ")", ")", "&&", "offset", "!=", "const0_rtx", ")", "{", "unspec", "=", "copy_rtx", "(", "unspec", ")", ";", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", "=", "plus_constant", "(", "Pmode", ",", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ",", "INTVAL", "(", "offset", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "gen_rtx_CONST", "(", "Pmode", ",", "unspec", ")", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMIZE_ADDRESS", "." ]

[ "nios2", "0", "1", "0", "1", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "MVT", "RISCVTargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "!", "Subtarget", ".", "hasStdExtZfhmin", "(", ")", ")", "return", "MVT", "::", "f32", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "MVT::f16", "MVT::f32" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isEligibleForTailCallOptimization", "(", "CCState", "&", "CCInfo", ",", "CallLoweringInfo", "&", "CLI", ",", "MachineFunction", "&", "MF", ",", "const", "SmallVector", "<", "CCValAssign", ",", "16", ">", "&", "ArgLocs", ")", "const", "{", "auto", "&", "Callee", "=", "CLI", ".", "Callee", ";", "auto", "CalleeCC", "=", "CLI", ".", "CallConv", ";", "auto", "&", "Outs", "=", "CLI", ".", "Outs", ";", "auto", "&", "Caller", "=", "MF", ".", "getFunction", "(", ")", ";", "auto", "CallerCC", "=", "Caller", ".", "getCallingConv", "(", ")", ";", "if", "(", "Caller", ".", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "if", "(", "Caller", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ")", "return", "false", ";", "auto", "IsCallerStructRet", "=", "Caller", ".", "hasStructRetAttr", "(", ")", ";", "auto", "IsCalleeStructRet", "=", "Outs", ".", "empty", "(", ")", "?", "false", ":", "Outs", "[", "0", "]", ".", "Flags", ".", "isSRet", "(", ")", ";", "if", "(", "IsCallerStructRet", "||", "IsCalleeStructRet", ")", "return", "false", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "G", "->", "getGlobal", "(", ")", ";", "if", "(", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "false", ";", "}", "const", "RISCVRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "CalleeCC", "!=", "CallerCC", ")", "{", "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "for", "(", "auto", "&", "Arg", ":", "Outs", ")", "if", "(", "Arg", ".", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

[ "RISCV", "RISCV", "16", "\"disable-tail-calls\"", "\"true\"", "\"interrupt\"", "0", "0", "RISCV" ]

[]

[ "<s>", "void", "print", "(", ")", "{", "if", "(", "numSymbols", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "if", "(", "i", ")", "O", "<<", "\", \"", ";", "O", "<<", "(", "unsigned", "int", ")", "buffer", "[", "i", "]", ";", "}", "}", "else", "{", "unsigned", "int", "pos", "=", "0", ";", "unsigned", "int", "nSym", "=", "0", ";", "unsigned", "int", "nextSymbolPos", "=", "symbolPosInBuffer", "[", "nSym", "]", ";", "unsigned", "int", "nBytes", "=", "4", ";", "if", "(", "AP", ".", "nvptxSubtarget", ".", "is64Bit", "(", ")", ")", "nBytes", "=", "8", ";", "for", "(", "pos", "=", "0", ";", "pos", "<", "size", ";", "pos", "+=", "nBytes", ")", "{", "if", "(", "pos", ")", "O", "<<", "\", \"", ";", "if", "(", "pos", "==", "nextSymbolPos", ")", "{", "const", "Value", "*", "v", "=", "Symbols", "[", "nSym", "]", ";", "if", "(", "const", "GlobalValue", "*", "GVar", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "v", ")", ")", "{", "MCSymbol", "*", "Name", "=", "AP", ".", "getSymbol", "(", "GVar", ")", ";", "PointerType", "*", "PTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "GVar", "->", "getType", "(", ")", ")", ";", "bool", "IsNonGenericPointer", "=", "false", ";", "if", "(", "PTy", "&&", "PTy", "->", "getAddressSpace", "(", ")", "!=", "0", ")", "{", "IsNonGenericPointer", "=", "true", ";", "}", "if", "(", "EmitGeneric", "&&", "!", "isa", "<", "Function", ">", "(", "v", ")", "&&", "!", "IsNonGenericPointer", ")", "{", "O", "<<", "\"generic(\"", ";", "O", "<<", "*", "Name", ";", "O", "<<", "\")\"", ";", "}", "else", "{", "O", "<<", "*", "Name", ";", "}", "}", "else", "if", "(", "const", "ConstantExpr", "*", "Cexpr", "=", "dyn_cast", "<", "ConstantExpr", ">", "(", "v", ")", ")", "{", "O", "<<", "*", "AP", ".", "lowerConstant", "(", "Cexpr", ")", ";", "}", "else", "llvm_unreachable", "(", "\"symbol type unknown\"", ")", ";", "nSym", "++", ";", "if", "(", "nSym", ">=", "numSymbols", ")", "nextSymbolPos", "=", "size", "+", "1", ";", "else", "nextSymbolPos", "=", "symbolPosInBuffer", "[", "nSym", "]", ";", "}", "else", "if", "(", "nBytes", "==", "4", ")", "O", "<<", "*", "(", "unsigned", "int", "*", ")", "(", "&", "buffer", "[", "pos", "]", ")", ";", "else", "O", "<<", "*", "(", "unsigned", "long", "long", "*", ")", "(", "&", "buffer", "[", "pos", "]", ")", ";", "}", "}", "}", "</s>" ]

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

[ "NVPTX", "0", "0", "\", \"", "0", "0", "4", "8", "0", "\", \"", "0", "\"generic(\"", "\")\"", "\"symbol type unknown\"", "1", "4" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "SP", "::", "SAVEri", ";", "unsigned", "SAVErr", "=", "SP", "::", "SAVErr", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "SAVEri", "=", "SP", "::", "ADDri", ";", "SAVErr", "=", "SP", "::", "ADDrr", ";", "}", "NumBytes", "=", "-", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SAVErr", ",", "SAVEri", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "regFP", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I6", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "regFP", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "nullptr", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "unsigned", "regInRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I7", ",", "true", ")", ";", "unsigned", "regOutRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "O7", ",", "true", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRegister", "(", "nullptr", ",", "regOutRA", ",", "regInRA", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::SAVEri", "SP::SAVErr", "0", "SP::ADDri", "SP::ADDrr", "Sparc", "SP", "SP::I6", "SP::I7", "SP::O7" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MFI", "->", "hasInlineAsmWithSPAdjust", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getForceFramePointer", "(", ")", "||", "MMI", ".", "callsUnwindInit", "(", ")", "||", "MMI", ".", "callsEHReturn", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "inline", "bool", "save_reg_p", "(", "int", "r", ")", "{", "return", "!", "call_used_regs", "[", "r", "]", "&&", "df_regs_ever_live_p", "(", "r", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "the", "REG", "is", "really", "used", "." ]

[ "rs6000" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "StackAlignment", "(", "16", ")", ",", "DarwinDirective", "(", "PPC", "::", "DIR_NONE", ")", ",", "HasMFOCRF", "(", "false", ")", ",", "Has64BitSupport", "(", "false", ")", ",", "Use64BitRegs", "(", "false", ")", ",", "IsPPC64", "(", "is64Bit", ")", ",", "HasAltivec", "(", "false", ")", ",", "HasFSQRT", "(", "false", ")", ",", "HasSTFIWX", "(", "false", ")", ",", "HasISEL", "(", "false", ")", ",", "IsBookE", "(", "false", ")", ",", "HasLazyResolverStubs", "(", "false", ")", ",", "IsJITCodeModel", "(", "false", ")", ",", "TargetTriple", "(", "TT", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "(", "defined", "(", "__ppc__", ")", "||", "defined", "(", "__powerpc__", ")", ")", "if", "(", "CPUName", "==", "\"generic\"", ")", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "std", "::", "string", "FullFS", "=", "FS", ";", "if", "(", "is64Bit", ")", "{", "Has64BitSupport", "=", "true", ";", "Use64BitRegs", "=", "true", ";", "if", "(", "!", "FullFS", ".", "empty", "(", ")", ")", "FullFS", "=", "\"+64bit,\"", "+", "FullFS", ";", "else", "FullFS", "=", "\"+64bit\"", ";", "}", "ParseSubtargetFeatures", "(", "CPUName", ",", "FullFS", ")", ";", "if", "(", "use64BitRegs", "(", ")", "&&", "!", "has64BitSupport", "(", ")", ")", "Use64BitRegs", "=", "false", ";", "if", "(", "isDarwin", "(", ")", ")", "HasLazyResolverStubs", "=", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "16", "PPC::DIR_NONE", "PPC", "\"generic\"", "\"generic\"", "\"+64bit,\"", "\"+64bit\"" ]

[]

[ "<s>", "void", "AVRMCInstLower", "::", "lowerInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "MachineOperand", "const", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "MI", ".", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "continue", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "Lowers", "a", "MachineInstr", "into", "a", "MCInst", "." ]

[ "AVR", "AVR", "\"unknown operand type\"" ]

[]

[ "<s>", "bool", "MipsRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "NoFramePointerElim", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86TargetMachine", "*", "TM", "=", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "assert", "(", "!", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", "&&", "\"X86-64 PIC uses RIP relative addressing\"", ")", ";", "if", "(", "TM", "->", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "false", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "X86FI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "unsigned", "PC", ";", "if", "(", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isPICStyleGOT", "(", ")", ")", "PC", "=", "RegInfo", ".", "createVirtualRegister", "(", "X86", "::", "GR32RegisterClass", ")", ";", "else", "PC", "=", "GlobalBaseReg", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOVPC32r", ")", ",", "PC", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isPICStyleGOT", "(", ")", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "ADD32ri", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "PC", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "X86II", "::", "MO_GOT_ABSOLUTE_ADDRESS", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"X86-64 PIC uses RIP relative addressing\"", "X86", "X86", "X86", "X86", "0", "X86", "X86", "X86::GR32RegisterClass", "X86::MOVPC32r", "0", "X86", "X86::ADD32ri", "\"_GLOBAL_OFFSET_TABLE_\"", "X86II::MO_GOT_ABSOLUTE_ADDRESS" ]

[]

[ "<s>", "TargetTransformInfo", "WebAssemblyTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "TargetTransformInfo", "(", "WebAssemblyTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "ARMCodeEmitter", "::", "emitInstruction", "(", "const", "MachineInstr", "&", "MI", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JIT: \"", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "\":\\t\"", "<<", "MI", ")", ";", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "true", ")", ";", "++", "NumEmitted", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "{", "default", ":", "{", "llvm_unreachable", "(", "\"Unhandled instruction encoding format!\"", ")", ";", "break", ";", "}", "case", "ARMII", "::", "MiscFrm", ":", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "LEApcrelJT", ")", "{", "emitLEApcrelJTInstruction", "(", "MI", ")", ";", "break", ";", "}", "llvm_unreachable", "(", "\"Unhandled instruction encoding!\"", ")", ";", "break", ";", "case", "ARMII", "::", "Pseudo", ":", "emitPseudoInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "DPFrm", ":", "case", "ARMII", "::", "DPSoRegFrm", ":", "emitDataProcessingInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdFrm", ":", "case", "ARMII", "::", "StFrm", ":", "emitLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdMiscFrm", ":", "case", "ARMII", "::", "StMiscFrm", ":", "emitMiscLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdStMulFrm", ":", "emitLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "MulFrm", ":", "emitMulFrmInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "ExtFrm", ":", "emitExtendInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "ArithMiscFrm", ":", "emitMiscArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "SatFrm", ":", "emitSaturateInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "BrFrm", ":", "emitBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "BrMiscFrm", ":", "emitMiscBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPUnaryFrm", ":", "case", "ARMII", "::", "VFPBinaryFrm", ":", "emitVFPArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPConv1Frm", ":", "case", "ARMII", "::", "VFPConv2Frm", ":", "case", "ARMII", "::", "VFPConv3Frm", ":", "case", "ARMII", "::", "VFPConv4Frm", ":", "case", "ARMII", "::", "VFPConv5Frm", ":", "emitVFPConversionInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPLdStFrm", ":", "emitVFPLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPLdStMulFrm", ":", "emitVFPLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPMiscFrm", ":", "emitMiscInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "NGetLnFrm", ":", "case", "ARMII", "::", "NSetLnFrm", ":", "emitNEONLaneInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "NDupFrm", ":", "emitNEONDupInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N1RegModImmFrm", ":", "emitNEON1RegModImmInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N2RegFrm", ":", "emitNEON2RegInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N3RegFrm", ":", "emitNEON3RegInstruction", "(", "MI", ")", ";", "break", ";", "}", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT: \"", "\":\\t\"", "ARMII::FormMask", "\"Unhandled instruction encoding format!\"", "ARMII::MiscFrm", "ARM::LEApcrelJT", "\"Unhandled instruction encoding!\"", "ARMII::Pseudo", "ARMII::DPFrm", "ARMII::DPSoRegFrm", "ARMII::LdFrm", "ARMII::StFrm", "ARMII::LdMiscFrm", "ARMII::StMiscFrm", "ARMII::LdStMulFrm", "ARMII::MulFrm", "ARMII::ExtFrm", "ARMII::ArithMiscFrm", "ARMII::SatFrm", "ARMII::BrFrm", "ARMII::BrMiscFrm", "ARMII::VFPUnaryFrm", "ARMII::VFPBinaryFrm", "ARMII::VFPConv1Frm", "ARMII::VFPConv2Frm", "ARMII::VFPConv3Frm", "ARMII::VFPConv4Frm", "ARMII::VFPConv5Frm", "ARMII::VFPLdStFrm", "ARMII::VFPLdStMulFrm", "ARMII::VFPMiscFrm", "ARMII::NGetLnFrm", "ARMII::NSetLnFrm", "ARMII::NDupFrm", "ARMII::N1RegModImmFrm", "ARMII::N2RegFrm", "ARMII::N3RegFrm" ]

[]

[ "<s>", "static", "rtx", "arm_function_arg", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "nregs", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "const0_rtx", ";", "if", "(", "pcum", "->", "pcs_variant", "<=", "ARM_PCS_AAPCS_LOCAL", ")", "{", "aapcs_layout_arg", "(", "pcum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ")", ";", "return", "pcum", "->", "aapcs_reg", ";", "}", "if", "(", "TARGET_IWMMXT_ABI", "&&", "arm_vector_mode_supported_p", "(", "arg", ".", "mode", ")", "&&", "pcum", "->", "named_count", ">", "pcum", "->", "nargs", "+", "1", ")", "{", "if", "(", "pcum", "->", "iwmmxt_nregs", "<=", "9", ")", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "pcum", "->", "iwmmxt_nregs", "+", "FIRST_IWMMXT_REGNUM", ")", ";", "else", "{", "pcum", "->", "can_split", "=", "false", ";", "return", "NULL_RTX", ";", "}", "}", "if", "(", "(", "pcum", "->", "nregs", "&", "1", ")", "&&", "ARM_DOUBLEWORD_ALIGN", ")", "{", "int", "res", "=", "arm_needs_doubleword_align", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "if", "(", "res", "<", "0", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 7.1\"", ",", "arg", ".", "type", ")", ";", "else", "if", "(", "res", ">", "0", ")", "{", "pcum", "->", "nregs", "++", ";", "if", "(", "res", ">", "1", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 9.1\"", ",", "arg", ".", "type", ")", ";", "}", "}", "if", "(", "pcum", "->", "can_split", ")", "nregs", "=", "1", ";", "else", "nregs", "=", "ARM_NUM_REGS2", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "if", "(", "!", "arg", ".", "named", "||", "pcum", "->", "nregs", "+", "nregs", ">", "NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "pcum", "->", "nregs", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "the", "ARM", ",", "normally", "the", "first", "16", "bytes", "are", "passed", "in", "registers", "r0-r3", ";", "all", "other", "arguments", "are", "passed", "on", "the", "stack", ".", "If", "(", "NAMED", "==", "0", ")", "(", "which", "happens", "only", "in", "assign_parms", ",", "since", "TARGET_SETUP_INCOMING_VARARGS", "is", "defined", ")", ",", "say", "it", "is", "passed", "in", "the", "stack", "(", "function_prologue", "will", "indeed", "make", "it", "pass", "in", "the", "stack", "if", "necessary", ")", "." ]

[ "arm", "1", "9", "1", "0", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 7.1\"", "0", "1", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 9.1\"", "1" ]

[]

[ "<s>", "void", "BPFDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "Node", "=", "&", "*", "I", "++", ";", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "ISD", "::", "LOAD", ")", "PreprocessLoad", "(", "Node", ",", "I", ")", ";", "else", "if", "(", "Opcode", "==", "ISD", "::", "CopyToReg", ")", "PreprocessCopyToReg", "(", "Node", ")", ";", "else", "if", "(", "Opcode", "==", "ISD", "::", "AND", ")", "PreprocessTrunc", "(", "Node", ",", "I", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "BPF", "BPF", "ISD::LOAD", "ISD::CopyToReg", "ISD::AND" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "int", "frv_compare_insns", "(", "const", "void", "*", "first", ",", "const", "void", "*", "second", ")", "{", "rtx_insn", "*", "const", "*", "insn1", "=", "(", "rtx_insn", "*", "const", "*", ")", "first", ";", "rtx_insn", "*", "const", "*", "insn2", "=", "(", "rtx_insn", "*", "const", "*", ")", "second", ";", "return", "frv_insn_unit", "(", "*", "insn1", ")", "-", "frv_insn_unit", "(", "*", "insn2", ")", ";", "}", "</s>" ]

[ "Compare", "two", "instructions", "by", "their", "frv_insn_unit", "." ]

[ "frv" ]

[]

[ "<s>", "static", "void", "aarch64_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "this_regno", "=", "R0_REGNUM", ";", "rtx", "this_rtx", ",", "temp0", ",", "temp1", ",", "addr", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk", ")", ")", ";", "if", "(", "aarch64_bti_enabled", "(", ")", ")", "emit_insn", "(", "gen_bti_c", "(", ")", ")", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "this_regno", ")", ";", "temp0", "=", "gen_rtx_REG", "(", "Pmode", ",", "EP0_REGNUM", ")", ";", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "EP1_REGNUM", ")", ";", "if", "(", "vcall_offset", "==", "0", ")", "aarch64_add_offset", "(", "Pmode", ",", "this_rtx", ",", "this_rtx", ",", "delta", ",", "temp1", ",", "temp0", ",", "false", ")", ";", "else", "{", "gcc_assert", "(", "(", "vcall_offset", "&", "(", "POINTER_BYTES", "-", "1", ")", ")", "==", "0", ")", ";", "addr", "=", "this_rtx", ";", "if", "(", "delta", "!=", "0", ")", "{", "if", "(", "delta", ">=", "-", "256", "&&", "delta", "<", "256", ")", "addr", "=", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "this_rtx", ",", "plus_constant", "(", "Pmode", ",", "this_rtx", ",", "delta", ")", ")", ";", "else", "aarch64_add_offset", "(", "Pmode", ",", "this_rtx", ",", "this_rtx", ",", "delta", ",", "temp1", ",", "temp0", ",", "false", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_ZERO_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "if", "(", "vcall_offset", ">=", "-", "256", "&&", "vcall_offset", "<", "4096", "*", "POINTER_BYTES", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "temp0", ",", "vcall_offset", ")", ";", "else", "{", "aarch64_internal_mov_immediate", "(", "temp1", ",", "GEN_INT", "(", "vcall_offset", ")", ",", "true", ",", "Pmode", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp0", ",", "temp1", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_SIGN_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "rtx", "callee_abi", "=", "gen_int_mode", "(", "fndecl_abi", "(", "function", ")", ".", "id", "(", ")", ",", "DImode", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ",", "callee_abi", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk", ",", "fnname", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "aarch64", "1", "0", "1", "0", "0", "256", "256", "256", "4096", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "::", "ArgumentListType", "&", "Args", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "unsigned", "NumArgs", "=", "Args", ".", "size", "(", ")", ";", "Function", "::", "const_arg_iterator", "CurOrigArg", "=", "Args", ".", "begin", "(", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumArgs", ";", "++", "i", ",", "++", "CurOrigArg", ")", "{", "MVT", "ValVT", "=", "MVT", "::", "getVT", "(", "CurOrigArg", "->", "getType", "(", ")", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "bool", "Res", "=", "AssignFn", "(", "i", ",", "ValVT", ",", "ValVT", ",", "CCValAssign", "::", "Full", ",", "ISD", "::", "ArgFlagsTy", "(", ")", ",", "CCInfo", ")", ";", "assert", "(", "!", "Res", "&&", "\"Call operand has unhandled type\"", ")", ";", "(", "void", ")", "Res", ";", "}", "assert", "(", "ArgLocs", ".", "size", "(", ")", "==", "Args", ".", "size", "(", ")", "&&", "\"We have a different number of location and args?!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Not yet implemented\"", ")", ";", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "TargetOpcode", "::", "COPY", ",", "VRegs", "[", "i", "]", ",", "VA", ".", "getLocReg", "(", ")", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "ZExt", ":", "assert", "(", "0", "&&", "\"Not yet implemented\"", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "AArch64", "AArch64", "16", "AArch64", "AArch64", "0", "MVT::getVT", "ISD::ArgFlagsTy", "\"Call operand has unhandled type\"", "\"We have a different number of location and args?!\"", "0", "\"Not yet implemented\"", "\"Unknown loc info!\"", "0", "\"Not yet implemented\"" ]

[]

[ "<s>", "StackOffset", "RISCVFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "const", "auto", "&", "CSI", "=", "getNonLibcallCSI", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "if", "(", "FI", ">=", "MinCSFI", "&&", "FI", "<=", "MaxCSFI", ")", "{", "FrameReg", "=", "RISCV", "::", "X2", ";", "if", "(", "FirstSPAdjustAmount", ")", "Offset", "+=", "FirstSPAdjustAmount", ";", "else", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "else", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ")", "{", "if", "(", "hasBP", "(", "MF", ")", ")", "FrameReg", "=", "RISCVABI", "::", "getBPReg", "(", ")", ";", "else", "FrameReg", "=", "RISCV", "::", "X2", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FI", "<", "0", ")", "Offset", "+=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "Offset", "+=", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "FI", ">=", "0", ")", "Offset", "-=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "else", "{", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FI", "<", "0", ")", "Offset", "+=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "}", "return", "StackOffset", "::", "getFixed", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV", "0", "1", "0", "1", "RISCV::X2", "RISCVABI::getBPReg", "RISCV::X2", "0", "0", "0" ]

[]

[ "<s>", "static", "tree", "associated_type", "(", "tree", "decl", ")", "{", "return", "(", "DECL_CONTEXT", "(", "decl", ")", "&&", "TYPE_P", "(", "DECL_CONTEXT", "(", "decl", ")", ")", ")", "?", "DECL_CONTEXT", "(", "decl", ")", ":", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "the", "type", "that", "we", "should", "use", "to", "determine", "if", "DECL", "is", "imported", "or", "exported", "." ]

[ "i386" ]

[]

[ "<s>", "void", "AMDGPUInstructionSelector", "::", "setupMF", "(", "MachineFunction", "&", "MF", ",", "GISelKnownBits", "*", "KB", ",", "CodeGenCoverage", "&", "CoverageInfo", ",", "ProfileSummaryInfo", "*", "PSI", ",", "BlockFrequencyInfo", "*", "BFI", ")", "{", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "InstructionSelector", "::", "setupMF", "(", "MF", ",", "KB", ",", "CoverageInfo", ",", "PSI", ",", "BFI", ")", ";", "}", "</s>" ]

[ "Setup", "per-MF", "executor", "state", "." ]

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

[]

[ "<s>", "void", "changedInstr", "(", "MachineInstr", "&", "MI", ")", "override", "{", "}", "</s>" ]

[ "This", "instruction", "was", "mutated", "in", "some", "way", "." ]

[ "Mips" ]

[]

[ "<s>", "MachineBasicBlock", "*", "PIC16TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "CC", "=", "(", "PIC16CC", "::", "CondCodes", ")", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "PIC16", "::", "pic16brcond", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ".", "addImm", "(", "CC", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "PIC16", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16CC::CondCodes", "3", "PIC16::pic16brcond", "PIC16::PHI", "0", "2", "1" ]

[]

[ "<s>", "static", "bool", "riscv_tls_symbol_p", "(", "const_rtx", "x", ")", "{", "return", "SYMBOL_REF_P", "(", "x", ")", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "thread-local", "symbol", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "const", "uint16_t", "*", "MandarinRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "Mandarin", "0" ]

[]

[ "<s>", "bool", "s390_split_ok_p", "(", "rtx", "dst", ",", "rtx", "src", ",", "machine_mode", "mode", ",", "int", "first_subword", ")", "{", "if", "(", "FP_REG_P", "(", "src", ")", "||", "FP_REG_P", "(", "dst", ")", "||", "VECTOR_REG_P", "(", "src", ")", "||", "VECTOR_REG_P", "(", "dst", ")", ")", "return", "false", ";", "if", "(", "s_operand", "(", "src", ",", "mode", ")", "||", "s_operand", "(", "dst", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "(", "GET_CODE", "(", "src", ")", "==", "MEM", "&&", "!", "offsettable_memref_p", "(", "src", ")", ")", "||", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", "&&", "!", "offsettable_memref_p", "(", "dst", ")", ")", ")", "return", "false", ";", "if", "(", "register_operand", "(", "dst", ",", "mode", ")", ")", "{", "rtx", "subreg", "=", "operand_subword", "(", "dst", ",", "first_subword", ",", "0", ",", "mode", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "subreg", ",", "src", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "we", "can", "(", "and", "want", "to", ")", "split", "a", "double-word", "move", "in", "mode", "MODE", "from", "SRC", "to", "DST", "into", "two", "single-word", "moves", ",", "moving", "the", "subword", "FIRST_SUBWORD", "first", "." ]

[ "s390", "0" ]

[]

[ "<s>", "void", "expand_fusion_gpr_load", "(", "rtx", "*", "operands", ")", "{", "rtx", "addis_value", "=", "operands", "[", "1", "]", ";", "rtx", "target", "=", "operands", "[", "2", "]", ";", "rtx", "orig_mem", "=", "operands", "[", "3", "]", ";", "rtx", "new_addr", ",", "new_mem", ",", "orig_addr", ",", "offset", ";", "enum", "rtx_code", "plus_or_lo_sum", ";", "machine_mode", "target_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "extend_mode", "=", "target_mode", ";", "machine_mode", "ptr_mode", "=", "Pmode", ";", "enum", "rtx_code", "extend", "=", "UNKNOWN", ";", "if", "(", "GET_CODE", "(", "orig_mem", ")", "==", "ZERO_EXTEND", "||", "(", "TARGET_P8_FUSION_SIGN", "&&", "GET_CODE", "(", "orig_mem", ")", "==", "SIGN_EXTEND", ")", ")", "{", "extend", "=", "GET_CODE", "(", "orig_mem", ")", ";", "orig_mem", "=", "XEXP", "(", "orig_mem", ",", "0", ")", ";", "target_mode", "=", "GET_MODE", "(", "orig_mem", ")", ";", "}", "gcc_assert", "(", "MEM_P", "(", "orig_mem", ")", ")", ";", "orig_addr", "=", "XEXP", "(", "orig_mem", ",", "0", ")", ";", "plus_or_lo_sum", "=", "GET_CODE", "(", "orig_addr", ")", ";", "gcc_assert", "(", "plus_or_lo_sum", "==", "PLUS", "||", "plus_or_lo_sum", "==", "LO_SUM", ")", ";", "offset", "=", "XEXP", "(", "orig_addr", ",", "1", ")", ";", "new_addr", "=", "gen_rtx_fmt_ee", "(", "plus_or_lo_sum", ",", "ptr_mode", ",", "addis_value", ",", "offset", ")", ";", "new_mem", "=", "replace_equiv_address_nv", "(", "orig_mem", ",", "new_addr", ",", "false", ")", ";", "if", "(", "extend", "!=", "UNKNOWN", ")", "new_mem", "=", "gen_rtx_fmt_e", "(", "ZERO_EXTEND", ",", "extend_mode", ",", "new_mem", ")", ";", "new_mem", "=", "gen_rtx_UNSPEC", "(", "extend_mode", ",", "gen_rtvec", "(", "1", ",", "new_mem", ")", ",", "UNSPEC_FUSION_GPR", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "new_mem", ")", ")", ";", "if", "(", "extend", "==", "SIGN_EXTEND", ")", "{", "int", "sub_off", "=", "(", "(", "BYTES_BIG_ENDIAN", ")", "?", "GET_MODE_SIZE", "(", "extend_mode", ")", "-", "GET_MODE_SIZE", "(", "target_mode", ")", ":", "0", ")", ";", "rtx", "sign_reg", "=", "simplify_subreg", "(", "target_mode", ",", "target", ",", "extend_mode", ",", "sub_off", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "gen_rtx_SIGN_EXTEND", "(", "extend_mode", ",", "sign_reg", ")", ")", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "During", "the", "peephole2", "pass", ",", "adjust", "and", "expand", "the", "insns", "for", "a", "load", "fusion", "sequence", ".", "We", "adjust", "the", "addis", "register", "to", "use", "the", "target", "register", ".", "If", "the", "load", "sign", "extends", ",", "we", "adjust", "the", "code", "to", "do", "the", "zero", "extending", "load", ",", "and", "an", "explicit", "sign", "extension", "later", "since", "the", "fusion", "only", "covers", "zero", "extending", "loads", ".", "The", "operands", "are", ":", "operands", "[", "0", "]", "register", "set", "with", "addis", "(", "to", "be", "replaced", "with", "target", ")", "operands", "[", "1", "]", "value", "set", "via", "addis", "operands", "[", "2", "]", "target", "register", "being", "loaded", "operands", "[", "3", "]", "D-form", "memory", "reference", "using", "operands", "[", "0", "]", "." ]

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

[]

[ "<s>", "void", "ix86_expand_lround", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op1", ")", ";", "const", "struct", "real_format", "*", "fmt", ";", "REAL_VALUE_TYPE", "pred_half", ",", "half_minus_pred_half", ";", "rtx", "adj", ";", "fmt", "=", "REAL_MODE_FORMAT", "(", "mode", ")", ";", "real_2expN", "(", "&", "half_minus_pred_half", ",", "-", "(", "fmt", "->", "p", ")", "-", "1", ",", "mode", ")", ";", "real_arithmetic", "(", "&", "pred_half", ",", "MINUS_EXPR", ",", "&", "dconsthalf", ",", "&", "half_minus_pred_half", ")", ";", "adj", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "pred_half", ",", "mode", ")", ")", ";", "ix86_sse_copysign_to_positive", "(", "adj", ",", "adj", ",", "force_reg", "(", "mode", ",", "op1", ")", ",", "NULL_RTX", ")", ";", "adj", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "adj", ",", "op1", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "expand_fix", "(", "op0", ",", "adj", ",", "0", ")", ";", "}", "</s>" ]

[ "Expand", "SSE", "sequence", "for", "computing", "lround", "from", "OP1", "storing", "into", "OP0", "." ]

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

[]

[ "<s>", "void", "XCoreInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "LDWFI", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::LDWFI", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "hasLowDefLatency", "(", "const", "TargetSchedModel", "&", "SchedModel", ",", "const", "MachineInstr", "*", "DefMI", ",", "unsigned", "DefIdx", ")", "const", "{", "const", "InstrItineraryData", "*", "ItinData", "=", "SchedModel", ".", "getInstrItineraries", "(", ")", ";", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "false", ";", "unsigned", "DDomain", "=", "DefMI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "if", "(", "DDomain", "==", "ARMII", "::", "DomainGeneral", ")", "{", "unsigned", "DefClass", "=", "DefMI", "->", "getDesc", "(", ")", ".", "getSchedClass", "(", ")", ";", "int", "DefCycle", "=", "ItinData", "->", "getOperandCycle", "(", "DefClass", ",", "DefIdx", ")", ";", "return", "(", "DefCycle", "!=", "-", "1", "&&", "DefCycle", "<=", "2", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Compute", "operand", "latency", "of", "a", "def", "of", "'Reg", "'", "." ]

[ "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainGeneral", "1", "2" ]

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", ")", "return", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "!", "MO", ".", "isImplicit", "(", ")", ")", "RegDefs", ".", "insert", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "TII", "->", "isZeroCost", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", ";", "if", "(", "!", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", ")", "{", "assert", "(", "TII", "->", "mayBeNewStore", "(", "*", "MI", ")", "&&", "\"Expecting .new store\"", ")", ";", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "MF", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "TII", "->", "getDotNewOp", "(", "*", "MI", ")", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "assert", "(", "Resources", "->", "canReserveResources", "(", "*", "NewMI", ")", ")", ";", "Resources", "->", "reserveResources", "(", "*", "NewMI", ")", ";", "MF", "->", "DeleteMachineInstr", "(", "NewMI", ")", ";", "}", "else", "Resources", "->", "reserveResources", "(", "*", "MI", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Add instruction \"", "<<", "*", "MI", ")", ";", "if", "(", "TII", "->", "mayBeCurLoad", "(", "*", "MI", ")", ")", "for", "(", "auto", "&", "S", ":", "SU", "->", "Succs", ")", "if", "(", "S", ".", "isAssignedRegDep", "(", ")", "&&", "S", ".", "getLatency", "(", ")", "==", "0", "&&", "S", ".", "getSUnit", "(", ")", "->", "NumPredsLeft", "==", "1", ")", "{", "UsesDotCur", "=", "S", ".", "getSUnit", "(", ")", ";", "DotCurPNum", "=", "PacketNum", ";", "break", ";", "}", "if", "(", "SU", "==", "UsesDotCur", ")", "{", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "}", "UsesLoad", "=", "MI", "->", "mayLoad", "(", ")", ";", "if", "(", "TII", "->", "isHVXVec", "(", "*", "MI", ")", "&&", "!", "MI", "->", "mayLoad", "(", ")", "&&", "!", "MI", "->", "mayStore", "(", ")", ")", "for", "(", "auto", "&", "S", ":", "SU", "->", "Succs", ")", "if", "(", "S", ".", "isAssignedRegDep", "(", ")", "&&", "S", ".", "getLatency", "(", ")", "==", "0", "&&", "TII", "->", "mayBeNewStore", "(", "*", "S", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ")", "&&", "Resources", "->", "canReserveResources", "(", "*", "S", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ")", ")", "{", "PrefVectorStoreNew", "=", "S", ".", "getSUnit", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Expecting .new store\"", "\" Add instruction \"", "0", "1", "1", "0" ]

[]

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

[ "Check", "whether", "this", "section", "is", "``", "virtual", "''", ",", "that", "is", "has", "no", "actual", "object", "file", "contents", "." ]

[ "Z80" ]

[]

[ "<s>", "BitVector", "X86RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RSP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RIP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "for", "(", "MCSubRegIterator", "I", "(", "X86", "::", "RBP", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "CallingConv", "::", "ID", "CC", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "getCallPreservedMask", "(", "CC", ")", ";", "if", "(", "MachineOperand", "::", "clobbersPhysReg", "(", "RegMask", ",", "getBaseRegister", "(", ")", ")", ")", "report_fatal_error", "(", "\"Stack realignment in presence of dynamic allocas is not supported with\"", "\"this calling convention.\"", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "getBaseRegister", "(", ")", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "Reserved", ".", "set", "(", "X86", "::", "CS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "DS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ES", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "FS", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "GS", ")", ";", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "8", ";", "++", "n", ")", "Reserved", ".", "set", "(", "X86", "::", "ST0", "+", "n", ")", ";", "if", "(", "!", "Is64Bit", ")", "{", "Reserved", ".", "set", "(", "X86", "::", "SIL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "DIL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "BPL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SPL", ")", ";", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "8", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "R8", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "XMM8", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "if", "(", "!", "Is64Bit", "||", "!", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "for", "(", "unsigned", "n", "=", "16", ";", "n", "!=", "32", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "X86", "::", "XMM0", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "X86", "X86", "X86::RSP", "X86::RIP", "X86::RBP", "\"Stack realignment in presence of dynamic allocas is not supported with\"", "\"this calling convention.\"", "X86::CS", "X86::SS", "X86::DS", "X86::ES", "X86::FS", "X86::GS", "0", "8", "X86::ST0", "X86::SIL", "X86::DIL", "X86::BPL", "X86::SPL", "0", "8", "X86::R8", "X86::XMM8", "16", "32", "X86::XMM0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AVR Shift Expansion\"", ";", "}", "</s>" ]

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

[ "AVR", "\"AVR Shift Expansion\"" ]

[]

[ "<s>", "void", "altivec_expand_vec_perm_le", "(", "rtx", "operands", "[", "4", "]", ")", "{", "rtx", "notx", ",", "iorx", ",", "unspec", ";", "rtx", "target", "=", "operands", "[", "0", "]", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "sel", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", "=", "target", ";", "rtx", "norreg", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "!", "REG_P", "(", "op1", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "if", "(", "!", "REG_P", "(", "sel", ")", ")", "sel", "=", "force_reg", "(", "V16QImode", ",", "sel", ")", ";", "if", "(", "!", "REG_P", "(", "target", ")", ")", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "TARGET_P9_VECTOR", ")", "{", "unspec", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op0", ",", "op1", ",", "sel", ")", ",", "UNSPEC_VPERMR", ")", ";", "}", "else", "{", "notx", "=", "gen_rtx_NOT", "(", "V16QImode", ",", "sel", ")", ";", "iorx", "=", "(", "TARGET_P8_VECTOR", "?", "gen_rtx_IOR", "(", "V16QImode", ",", "notx", ",", "notx", ")", ":", "gen_rtx_AND", "(", "V16QImode", ",", "notx", ",", "notx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "norreg", ",", "iorx", ")", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op1", ",", "op0", ",", "norreg", ")", ",", "UNSPEC_VPERM", ")", ";", "}", "if", "(", "!", "REG_P", "(", "target", ")", ")", "{", "emit_move_insn", "(", "tmp", ",", "unspec", ")", ";", "unspec", "=", "tmp", ";", "}", "emit_move_insn", "(", "target", ",", "unspec", ")", ";", "}", "</s>" ]

[ "Similarly", "to", "altivec_expand_vec_perm_const_le", ",", "we", "must", "adjust", "the", "permute", "control", "vector", ".", "But", "here", "it", "'s", "not", "a", "constant", ",", "so", "we", "must", "generate", "a", "vector", "NAND", "or", "NOR", "to", "do", "the", "adjustment", "." ]

[ "powerpcspe", "4", "0", "1", "2", "3", "3", "3" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AAPCS_CFGuard_Check_RegMask", ";", "if", "(", "STI", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_SwiftError_RegMask", ":", "CSR_AAPCS_SwiftError_RegMask", ";", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "&&", "CC", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "CSR_iOS_CXX_TLS_RegMask", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "MMI", "->", "AnalyzeModule", "(", "M", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "Mang", "=", "new", "Mangler", "(", "OutContext", ",", "*", "TM", ".", "getDataLayout", "(", ")", ")", ";", "emitHeader", "(", "M", ",", "OS1", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS1", ".", "str", "(", ")", ")", ";", "if", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "recordAndEmitFilenames", "(", "M", ")", ";", "SmallString", "<", "128", ">", "Str2", ";", "raw_svector_ostream", "OS2", "(", "Str2", ")", ";", "emitDeclarations", "(", "M", ",", "OS2", ")", ";", "SmallVector", "<", "GlobalVariable", "*", ",", "8", ">", "Globals", ";", "DenseSet", "<", "GlobalVariable", "*", ">", "GVVisited", ";", "DenseSet", "<", "GlobalVariable", "*", ">", "GVVisiting", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "VisitGlobalVariableForEmission", "(", "I", ",", "Globals", ",", "GVVisited", ",", "GVVisiting", ")", ";", "assert", "(", "GVVisited", ".", "size", "(", ")", "==", "M", ".", "getGlobalList", "(", ")", ".", "size", "(", ")", "&&", "\"Missed a global variable\"", ")", ";", "assert", "(", "GVVisiting", ".", "size", "(", ")", "==", "0", "&&", "\"Did not fully process a global variable\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Globals", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "printModuleLevelGV", "(", "Globals", "[", "i", "]", ",", "OS2", ")", ";", "OS2", "<<", "'\\n'", ";", "OutStreamer", ".", "EmitRawText", "(", "OS2", ".", "str", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "128", "NVPTX::CUDA", "128", "8", "\"Missed a global variable\"", "0", "\"Did not fully process a global variable\"", "0" ]

[]

[ "<s>", "static", "bool", "is_indirect_tailcall_p", "(", "rtx", "call", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "call", ")", ";", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "pat", "=", "SET_SRC", "(", "pat", ")", ";", "pat", "=", "XEXP", "(", "XEXP", "(", "pat", ",", "0", ")", ",", "0", ")", ";", "return", "REG_P", "(", "pat", ")", ";", "}", "</s>" ]

[ "We", "do", "not", "know", "if", "r3", "will", "be", "available", "because", "we", "do", "have", "an", "indirect", "tailcall", "happening", "in", "this", "particular", "case", "." ]

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

[]

[ "<s>", "static", "rtx", "riscv_add_offset", "(", "rtx", "temp", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "if", "(", "!", "SMALL_OPERAND", "(", "offset", ")", ")", "{", "rtx", "high", ";", "high", "=", "gen_int_mode", "(", "CONST_HIGH_PART", "(", "offset", ")", ",", "Pmode", ")", ";", "offset", "=", "CONST_LOW_PART", "(", "offset", ")", ";", "high", "=", "riscv_force_temporary", "(", "temp", ",", "high", ",", "FALSE", ")", ";", "reg", "=", "riscv_force_temporary", "(", "temp", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "high", ",", "reg", ")", ",", "FALSE", ")", ";", "}", "return", "plus_constant", "(", "Pmode", ",", "reg", ",", "offset", ")", ";", "}", "</s>" ]

[ "Return", "a", "legitimate", "address", "for", "REG", "+", "OFFSET", ".", "TEMP", "is", "as", "for", "riscv_force_temporary", ";", "it", "is", "only", "needed", "when", "OFFSET", "is", "not", "a", "SMALL_OPERAND", "." ]

[ "riscv" ]

[]

[ "<s>", "uint64_t", "SIProgramInfo", "::", "getComputePGMRSrc1", "(", ")", "const", "{", "return", "S_00B848_VGPRS", "(", "VGPRBlocks", ")", "|", "S_00B848_SGPRS", "(", "SGPRBlocks", ")", "|", "S_00B848_PRIORITY", "(", "Priority", ")", "|", "S_00B848_FLOAT_MODE", "(", "FloatMode", ")", "|", "S_00B848_PRIV", "(", "Priv", ")", "|", "S_00B848_DX10_CLAMP", "(", "DX10Clamp", ")", "|", "S_00B848_DEBUG_MODE", "(", "DebugMode", ")", "|", "S_00B848_IEEE_MODE", "(", "IEEEMode", ")", "|", "S_00B848_WGP_MODE", "(", "WgpMode", ")", "|", "S_00B848_MEM_ORDERED", "(", "MemOrdered", ")", ";", "}", "</s>" ]

[ "Compute", "the", "value", "of", "the", "ComputePGMRsrc1", "register", "." ]

[ "AMDGPU", "SIProgramInfo::getComputePGMRSrc1" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SavedRegs", ".", "resize", "(", "HRI", ".", "getNumRegs", "(", ")", ")", ";", "if", "(", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ")", "for", "(", "const", "MCPhysReg", "*", "R", "=", "HRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "SavedRegs", ".", "set", "(", "*", "R", ")", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "NewRegs", ";", "expandSpillMacros", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "OptimizeSpillSlots", "&&", "!", "isOptNone", "(", "MF", ")", ")", "optimizeSpillSlots", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "!", "NewRegs", ".", "empty", "(", ")", "||", "mayOverflowFrameOffset", "(", "MF", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SetVector", "<", "const", "TargetRegisterClass", "*", ">", "SpillRCs", ";", "SpillRCs", ".", "insert", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "for", "(", "unsigned", "VR", ":", "NewRegs", ")", "SpillRCs", ".", "insert", "(", "MRI", ".", "getRegClass", "(", "VR", ")", ")", ";", "for", "(", "auto", "*", "RC", ":", "SpillRCs", ")", "{", "if", "(", "!", "needToReserveScavengingSpillSlots", "(", "MF", ",", "HRI", ",", "RC", ")", ")", "continue", ";", "unsigned", "Num", "=", "1", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "case", "Hexagon", "::", "IntRegsRegClassID", ":", "Num", "=", "NumberScavengerSlots", ";", "break", ";", "case", "Hexagon", "::", "HvxQRRegClassID", ":", "Num", "=", "2", ";", "break", ";", "}", "unsigned", "S", "=", "HRI", ".", "getSpillSize", "(", "*", "RC", ")", ",", "A", "=", "HRI", ".", "getSpillAlignment", "(", "*", "RC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Num", ";", "i", "++", ")", "{", "int", "NewFI", "=", "MFI", ".", "CreateSpillStackObject", "(", "S", ",", "A", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "NewFI", ")", ";", "}", "}", "}", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "8", "Hexagon::IntRegsRegClass", "1", "Hexagon::IntRegsRegClassID", "Hexagon::HvxQRRegClassID", "2", "0" ]

[]

[ "<s>", "const", "char", "*", "CJGTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "CJGISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "CJGISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "CJGISD", "::", "CMP", ":", "return", "\"CJGISD::CMP\"", ";", "case", "CJGISD", "::", "RET_FLAG", ":", "return", "\"CJGISD::RET_FLAG\"", ";", "case", "CJGISD", "::", "BR_CC", ":", "return", "\"CJGISD::BR_CC\"", ";", "case", "CJGISD", "::", "SELECT_CC", ":", "return", "\"CJGISD::SELECT_CC\"", ";", "case", "CJGISD", "::", "Wrapper", ":", "return", "\"CJGISD::Wrapper\"", ";", "case", "CJGISD", "::", "CALL", ":", "return", "\"CJGISD::CALL\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "CJGISD::NodeType", "CJGISD::FIRST_NUMBER", "CJGISD::CMP", "\"CJGISD::CMP\"", "CJGISD::RET_FLAG", "\"CJGISD::RET_FLAG\"", "CJGISD::BR_CC", "\"CJGISD::BR_CC\"", "CJGISD::SELECT_CC", "\"CJGISD::SELECT_CC\"", "CJGISD::Wrapper", "\"CJGISD::Wrapper\"", "CJGISD::CALL", "\"CJGISD::CALL\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "TGSICFGStructurizer", "::", "clone", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "MachineFunction", "*", "Func", "=", "MBB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "NewMBB", "=", "Func", "->", "CreateMachineBasicBlock", "(", ")", ";", "Func", "->", "push_back", "(", "NewMBB", ")", ";", "for", "(", "const", "MachineInstr", "&", "It", ":", "*", "MBB", ")", "NewMBB", "->", "push_back", "(", "Func", "->", "CloneMachineInstr", "(", "&", "It", ")", ")", ";", "return", "NewMBB", ";", "}", "</s>" ]

[ "Make", "a", "functionally", "equivalent", "copy", "of", "this", "MachineFunctionInfo", "in", "MF", "." ]

[ "TGSI", "TGSI" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "LittleEndian", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "LoongArch", "LoongArch" ]

[]

[ "<s>", "static", "bool", "c6x_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_PRECISION", "(", "mode", ")", "<=", "2", "*", "BITS_PER_WORD", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "." ]

[ "c6x", "2" ]

[]

[ "<s>", "bool", "rs6000_must_pass_in_stack", "(", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", "||", "TARGET_64BIT", ")", "return", "must_pass_in_stack_var_size", "(", "arg", ")", ";", "else", "return", "must_pass_in_stack_var_size_or_pad", "(", "arg", ")", ";", "}", "</s>" ]

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

[ "rs6000" ]

[]

[ "<s>", "static", "rtx", "function_arg_32", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "machine_mode", "mode", ",", "machine_mode", "orig_mode", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "bytes", ",", "HOST_WIDE_INT", "words", ")", "{", "bool", "error_p", "=", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "constm1_rtx", ";", "if", "(", "TARGET_IAMCU", ")", "{", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", "&&", "bytes", "<=", "8", ")", "goto", "pass_in_reg", ";", "return", "NULL_RTX", ";", "}", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_BLKmode", ":", "if", "(", "bytes", "<", "0", ")", "break", ";", "case", "E_DImode", ":", "case", "E_SImode", ":", "case", "E_HImode", ":", "case", "E_QImode", ":", "pass_in_reg", ":", "if", "(", "words", "<=", "cum", "->", "nregs", ")", "{", "int", "regno", "=", "cum", "->", "regno", ";", "if", "(", "cum", "->", "fastcall", ")", "{", "if", "(", "mode", "==", "BLKmode", "||", "mode", "==", "DImode", "||", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", ")", "break", ";", "if", "(", "regno", "==", "AX_REG", ")", "regno", "=", "CX_REG", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "break", ";", "case", "E_DFmode", ":", "if", "(", "cum", "->", "float_in_sse", "==", "-", "1", ")", "error_p", "=", "true", ";", "if", "(", "cum", "->", "float_in_sse", "<", "2", ")", "break", ";", "case", "E_SFmode", ":", "if", "(", "cum", "->", "float_in_sse", "==", "-", "1", ")", "error_p", "=", "true", ";", "if", "(", "cum", "->", "float_in_sse", "<", "1", ")", "break", ";", "case", "E_TImode", ":", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SImode", ":", "case", "E_V2DImode", ":", "case", "E_V8HFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2DFmode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "cum", "->", "sse_nregs", ")", "return", "gen_reg_or_parallel", "(", "mode", ",", "orig_mode", ",", "cum", "->", "sse_regno", "+", "FIRST_SSE_REG", ")", ";", "}", "break", ";", "case", "E_OImode", ":", "case", "E_XImode", ":", "gcc_unreachable", "(", ")", ";", "case", "E_V64QImode", ":", "case", "E_V32HImode", ":", "case", "E_V16SImode", ":", "case", "E_V8DImode", ":", "case", "E_V32HFmode", ":", "case", "E_V16SFmode", ":", "case", "E_V8DFmode", ":", "case", "E_V16HFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V8SImode", ":", "case", "E_V32QImode", ":", "case", "E_V16HImode", ":", "case", "E_V4DFmode", ":", "case", "E_V4DImode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "cum", "->", "sse_nregs", ")", "return", "gen_reg_or_parallel", "(", "mode", ",", "orig_mode", ",", "cum", "->", "sse_regno", "+", "FIRST_SSE_REG", ")", ";", "}", "break", ";", "case", "E_V8QImode", ":", "case", "E_V4HImode", ":", "case", "E_V4HFmode", ":", "case", "E_V2SImode", ":", "case", "E_V2SFmode", ":", "case", "E_V1TImode", ":", "case", "E_V1DImode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "cum", "->", "mmx_nregs", ")", "return", "gen_reg_or_parallel", "(", "mode", ",", "orig_mode", ",", "cum", "->", "mmx_regno", "+", "FIRST_MMX_REG", ")", ";", "}", "break", ";", "}", "if", "(", "error_p", ")", "{", "cum", "->", "float_in_sse", "=", "0", ";", "error", "(", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", ",", "cum", "->", "decl", ")", ";", "sorry", "(", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", "." ]

[ "i386", "8", "0", "1", "2", "1", "1", "0", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "RISCVInstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "const", "unsigned", "Mask", "=", "RISCVII", "::", "MO_DIRECT_FLAG_MASK", ";", "return", "std", "::", "make_pair", "(", "TF", "&", "Mask", ",", "TF", "&", "~", "Mask", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

[ "RISCV", "RISCV", "RISCVII::MO_DIRECT_FLAG_MASK" ]

[]

[ "<s>", "static", "bool", "bfin_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "e_funkind", "fkind", "=", "funkind", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "return", "fkind", "==", "SUBROUTINE", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "." ]

[ "bfin" ]

[]

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

[ "Get", "the", "size", "of", "RSA", ",", "return", "address", ",", "and", "frame", "pointer", "as", "described", "in", "VEFrameLowering.cpp", "." ]

[ "VE", "176" ]

[]

[ "<s>", "HOST_WIDE_INT", "alpha_vms_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", ")", "{", "HOST_WIDE_INT", "sa_size", "=", "alpha_sa_size", "(", ")", ";", "if", "(", "alpha_procedure_type", "==", "PT_NULL", ")", "return", "0", ";", "{", "HOST_WIDE_INT", "offset", ";", "HOST_WIDE_INT", "pv_save_size", "=", "alpha_procedure_type", "==", "PT_STACK", "?", "8", ":", "0", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "ALPHA_ROUND", "(", "sa_size", "+", "pv_save_size", ")", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "(", "ALPHA_ROUND", "(", "sa_size", "+", "pv_save_size", "+", "get_frame_size", "(", ")", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", "-", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "offset", "+=", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ";", "return", "offset", ";", "}", "}", "</s>" ]

[ "FROM", "is", "to", "be", "eliminated", "for", "TO", ".", "Return", "the", "offset", "so", "that", "TO+offset", "designates", "the", "same", "location", "as", "FROM", "." ]

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

[]

[ "<s>", "PLTEntryBase", "*", "X86PLT", "::", "create", "(", ")", "{", "if", "(", "LinkerConfig", "::", "DynObj", "==", "m_Config", ".", "codeGenType", "(", ")", ")", "return", "new", "X86_32DynPLT1", "(", "*", "m_pSectionData", ")", ";", "else", "return", "new", "X86_32ExecPLT1", "(", "*", "m_pSectionData", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCExpr", "*", "ARM64_MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "(", "DW_EH_PE_indirect", "|", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOT", ",", "getContext", "(", ")", ")", ";", "MCSymbol", "*", "PCSym", "=", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "Streamer", ".", "EmitLabel", "(", "PCSym", ")", ";", "const", "MCExpr", "*", "PC", "=", "MCSymbolRefExpr", "::", "Create", "(", "PCSym", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "CreateSub", "(", "Res", ",", "PC", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

[ "ARM64", "ARM64" ]

[]

[ "<s>", "const", "uint32_t", "*", "SHUXIRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CC_Save_RegMask", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI" ]

[]

[ "<s>", "static", "bool", "rs6000_emit_move_si_sf_subreg", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_DIRECT_MOVE_64BIT", "&&", "!", "reload_completed", "&&", "(", "!", "SUBREG_P", "(", "dest", ")", "||", "!", "sf_subreg_operand", "(", "dest", ",", "mode", ")", ")", "&&", "SUBREG_P", "(", "source", ")", "&&", "sf_subreg_operand", "(", "source", ",", "mode", ")", ")", "{", "rtx", "inner_source", "=", "SUBREG_REG", "(", "source", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE", "(", "inner_source", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "inner_mode", "==", "SFmode", ")", "{", "emit_insn", "(", "gen_movsi_from_sf", "(", "dest", ",", "inner_source", ")", ")", ";", "return", "true", ";", "}", "if", "(", "mode", "==", "SFmode", "&&", "inner_mode", "==", "SImode", ")", "{", "emit_insn", "(", "gen_movsf_from_si", "(", "dest", ",", "inner_source", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "to", "change", "moves", "with", ":", "(", "SUBREG", ":", "SF", "(", "REG", ":", "SI", ")", ")", "and", "(", "SUBREG", ":", "SI", "(", "REG", ":", "SF", ")", ")", "into", "separate", "UNSPEC", "insns", ".", "In", "the", "PowerPC", "architecture", ",", "scalar", "SFmode", "values", "are", "stored", "as", "DFmode", "values", "in", "the", "VSX", "registers", ".", "We", "need", "to", "convert", "the", "bits", "before", "we", "can", "use", "a", "direct", "move", "or", "operate", "on", "the", "bits", "in", "the", "vector", "register", "as", "an", "integer", "type", ".", "Skip", "things", "like", "(", "set", "(", "SUBREG", ":", "SI", "(", "...", ")", "(", "SUBREG", ":", "SI", "(", "...", ")", ")", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "AArch64FastISel", "::", "isTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "false", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "AArch64", "AArch64", "MVT::Other", "MVT::f128" ]

[]

[ "<s>", "int", "ix86_register_move_cost", "(", "enum", "machine_mode", "mode", ",", "enum", "reg_class", "class1", ",", "enum", "reg_class", "class2", ")", "{", "if", "(", "ix86_secondary_memory_needed", "(", "class1", ",", "class2", ",", "mode", ",", "0", ")", ")", "{", "int", "cost", "=", "1", ";", "cost", "+=", "MAX", "(", "MEMORY_MOVE_COST", "(", "mode", ",", "class1", ",", "0", ")", ",", "MEMORY_MOVE_COST", "(", "mode", ",", "class1", ",", "1", ")", ")", ";", "cost", "+=", "MAX", "(", "MEMORY_MOVE_COST", "(", "mode", ",", "class2", ",", "0", ")", ",", "MEMORY_MOVE_COST", "(", "mode", ",", "class2", ",", "1", ")", ")", ";", "if", "(", "CLASS_MAX_NREGS", "(", "class1", ",", "mode", ")", ">", "CLASS_MAX_NREGS", "(", "class2", ",", "mode", ")", ")", "cost", "+=", "20", ";", "if", "(", "(", "MMX_CLASS_P", "(", "class1", ")", "&&", "MAYBE_FLOAT_CLASS_P", "(", "class2", ")", ")", "||", "(", "MMX_CLASS_P", "(", "class2", ")", "&&", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", ")", ")", "cost", "+=", "20", ";", "return", "cost", ";", "}", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", "||", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "return", "ix86_cost", "->", "mmxsse_to_integer", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "fp_move", ";", "if", "(", "MAYBE_SSE_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "sse_move", ";", "if", "(", "MAYBE_MMX_CLASS_P", "(", "class1", ")", ")", "return", "ix86_cost", "->", "mmx_move", ";", "return", "2", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "data", "from", "a", "register", "in", "class", "CLASS1", "to", "one", "in", "class", "CLASS2", ".", "It", "is", "not", "required", "that", "the", "cost", "always", "equal", "2", "when", "FROM", "is", "the", "same", "as", "TO", ";", "on", "some", "machines", "it", "is", "expensive", "to", "move", "between", "registers", "if", "they", "are", "not", "general", "registers", "." ]

[ "i386", "0", "1", "0", "1", "0", "1", "20", "20", "2" ]

[]

[ "<s>", "bool", "R600VectorRegMerger", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "(", "Fn", ".", "getRegInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "*", "MI", "=", "MII", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "TEX_INST", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineRegisterInfo", "::", "def_instr_iterator", "It", "=", "MRI", "->", "def_instr_begin", "(", "Reg", ")", ",", "E", "=", "MRI", "->", "def_instr_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "RemoveMI", "(", "&", "(", "*", "It", ")", ")", ";", "}", "}", "continue", ";", "}", "RegSeqInfo", "RSI", "(", "*", "MRI", ",", "MI", ")", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "areAllUsesSwizzeable", "(", "Reg", ")", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying to optimize \"", ";", "MI", "->", "dump", "(", ")", ";", ")", ";", "RegSeqInfo", "CandidateRSI", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", ">", "RemapChan", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using common slots...\\n\"", ";", ")", ";", "if", "(", "tryMergeUsingCommonSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using free slots...\\n\"", ";", ")", ";", "RemapChan", ".", "clear", "(", ")", ";", "if", "(", "tryMergeUsingFreeSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "trackRSI", "(", "RSI", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "AMDGPU::REG_SEQUENCE", "R600_InstFlag::TEX_INST", "1", "SI", "0", "\"Trying to optimize \"", "SI", "\"Using common slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "\"Using free slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "inline", "bool", "s390_restore_gpr_p", "(", "int", "regno", ")", "{", "return", "(", "cfun_frame_layout", ".", "first_restore_gpr", "!=", "-", "1", "&&", "regno", ">=", "cfun_frame_layout", ".", "first_restore_gpr", "&&", "regno", "<=", "cfun_frame_layout", ".", "last_restore_gpr", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "GPR", "REGNO", "is", "supposed", "to", "be", "restored", "in", "the", "function", "epilogue", "." ]

[ "s390", "1" ]

[]

[ "<s>", "static", "void", "ft32_option_override", "(", "void", ")", "{", "init_machine_status", "=", "ft32_init_machine_status", ";", "}", "</s>" ]

[ "The", "TARGET_OPTION_OVERRIDE", "worker", ".", "All", "this", "curently", "does", "is", "set", "init_machine_status", "." ]

[ "ft32" ]

[]

[ "<s>", "TypedPointerType", "*", "TypedPointerType", "::", "get", "(", "Type", "*", "EltTy", ",", "unsigned", "AddressSpace", ")", "{", "assert", "(", "EltTy", "&&", "\"Can't get a pointer to <null> type!\"", ")", ";", "assert", "(", "isValidElementType", "(", "EltTy", ")", "&&", "\"Invalid type for pointer element!\"", ")", ";", "llvm", "::", "Any", "&", "TargetData", "=", "EltTy", "->", "getContext", "(", ")", ".", "getTargetData", "(", ")", ";", "if", "(", "!", "TargetData", ".", "hasValue", "(", ")", ")", "TargetData", "=", "Any", "{", "std", "::", "make_shared", "<", "TypedPointerTracking", ">", "(", ")", "}", ";", "assert", "(", "any_isa", "<", "std", "::", "shared_ptr", "<", "TypedPointerTracking", ">>", "(", "TargetData", ")", "&&", "\"Unexpected target data type\"", ")", ";", "std", "::", "shared_ptr", "<", "TypedPointerTracking", ">", "Tracking", "=", "any_cast", "<", "std", "::", "shared_ptr", "<", "TypedPointerTracking", ">>", "(", "TargetData", ")", ";", "std", "::", "unique_ptr", "<", "TypedPointerType", ">", "&", "Entry", "=", "AddressSpace", "==", "0", "?", "Tracking", "->", "PointerTypes", "[", "EltTy", "]", ":", "Tracking", "->", "ASPointerTypes", "[", "std", "::", "make_pair", "(", "EltTy", ",", "AddressSpace", ")", "]", ";", "if", "(", "!", "Entry", ")", "Entry", "=", "std", "::", "unique_ptr", "<", "TypedPointerType", ">", "(", "new", "TypedPointerType", "(", "EltTy", ",", "AddressSpace", ")", ")", ";", "return", "Entry", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "." ]

[ "DirectX", "\"Can't get a pointer to <null> type!\"", "\"Invalid type for pointer element!\"", "\"Unexpected target data type\"", "0" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "{", "return", "Subtarget", ".", "getInstrItineraryData", "(", ")", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "void", "push_csky_minipool_fix", "(", "rtx_insn", "*", "insn", ",", "HOST_WIDE_INT", "address", ",", "rtx", "*", "loc", ",", "machine_mode", "mode", ",", "rtx", "value", ")", "{", ":", "CSKY_LRW16_RANGE", ")", "(", "GET_MODE_SIZE", "(", "(", "mode", ")", ")", ">=", "4", "?", "GET_MODE_SIZE", "(", "(", "mode", ")", ")", ":", "4", ")", "Mfix", "*", "fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "fix", ")", ")", ";", "fix", "->", "insn", "=", "insn", ";", "fix", "->", "address", "=", "address", ";", "fix", "->", "loc", "=", "loc", ";", "fix", "->", "mode", "=", "mode", ";", "fix", "->", "fix_size", "=", "CSKY_MINIPOOL_FIX_SIZE", "(", "mode", ")", ";", "fix", "->", "value", "=", "value", ";", "fix", "->", "forwards", "=", "CSKY_CONSTANT_POOL_RANGE", ";", "fix", "->", "backwards", "=", "0", ";", "fix", "->", "minipool", "=", "NULL", ";", "gcc_assert", "(", "fix", "->", "forwards", "||", "fix", "->", "backwards", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; %smode fixup for i%d; addr %lu, range (%ld,%ld): \"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "INSN_UID", "(", "insn", ")", ",", "(", "unsigned", "long", ")", "address", ",", "-", "1", "*", "(", "long", ")", "fix", "->", "backwards", ",", "(", "long", ")", "fix", "->", "forwards", ")", ";", "print_csky_value", "(", "dump_file", ",", "fix", "->", "value", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "fix", "->", "next", "=", "NULL", ";", "if", "(", "minipool_fix_head", "!=", "NULL", ")", "minipool_fix_tail", "->", "next", "=", "fix", ";", "else", "minipool_fix_head", "=", "fix", ";", "minipool_fix_tail", "=", "fix", ";", "}", "</s>" ]

[ "Record", "INSN", ",", "which", "will", "need", "fixing", "up", "to", "load", "a", "value", "from", "the", "minipool", ".", "ADDRESS", "is", "the", "offset", "of", "the", "insn", "since", "the", "start", "of", "the", "function", ";", "LOC", "is", "a", "pointer", "to", "the", "part", "of", "the", "insn", "which", "requires", "fixing", ";", "VALUE", "is", "the", "constant", "that", "must", "be", "loaded", ",", "which", "is", "of", "type", "MODE", "." ]

[ "csky", "4", "4", "0", "\";; %smode fixup for i%d; addr %lu, range (%ld,%ld): \"", "1", "\"\\n\"" ]

[]

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

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

[ "rs6000" ]

[]

[ "<s>", "bool", "OpenRISCPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", ".", "add", "(", "createOpenRISCISelDag", "(", "getOpenRISCTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC", "OpenRISC", "OpenRISC" ]

[]

[ "<s>", "static", "void", "ix86_add_cfa_restore_note", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "cfa_offset", ")", "{", "if", "(", "!", "crtl", "->", "shrink_wrapped", "&&", "cfa_offset", "<=", "cfun", "->", "machine", "->", "fs", ".", "red_zone_offset", ")", "return", ";", "if", "(", "insn", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "queued_cfa_restores", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "queued_cfa_restores", ")", ";", "}", "</s>" ]

[ "Add", "a", "REG_CFA_RESTORE", "REG", "note", "to", "INSN", "or", "queue", "them", "until", "next", "stack", "manipulation", "insn", ".", "The", "value", "is", "on", "the", "stack", "at", "CFA", "-", "CFA_OFFSET", ".", "Do", "n't", "add", "the", "note", "if", "the", "previously", "saved", "value", "will", "be", "left", "untouched", "within", "stack", "red-zone", "till", "return", ",", "as", "unwinders", "can", "find", "the", "same", "value", "in", "the", "register", "and", "on", "the", "stack", "." ]

[ "i386", "1" ]

[]

[ "<s>", "StringRef", "SIRegisterInfo", "::", "getRegAsmName", "(", "unsigned", "Reg", ")", "const", "{", "const", "TargetRegisterClass", "*", "RC", "=", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "unsigned", "Size", "=", "getRegSizeInBits", "(", "*", "RC", ")", ";", "unsigned", "AltName", "=", "AMDGPU", "::", "NoRegAltName", ";", "switch", "(", "Size", ")", "{", "case", "32", ":", "AltName", "=", "AMDGPU", "::", "Reg32", ";", "break", ";", "case", "64", ":", "AltName", "=", "AMDGPU", "::", "Reg64", ";", "break", ";", "case", "96", ":", "AltName", "=", "AMDGPU", "::", "Reg96", ";", "break", ";", "case", "128", ":", "AltName", "=", "AMDGPU", "::", "Reg128", ";", "break", ";", "case", "160", ":", "AltName", "=", "AMDGPU", "::", "Reg160", ";", "break", ";", "case", "256", ":", "AltName", "=", "AMDGPU", "::", "Reg256", ";", "break", ";", "case", "512", ":", "AltName", "=", "AMDGPU", "::", "Reg512", ";", "break", ";", "case", "1024", ":", "AltName", "=", "AMDGPU", "::", "Reg1024", ";", "break", ";", "}", "return", "AMDGPUInstPrinter", "::", "getRegisterName", "(", "Reg", ",", "AltName", ")", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "name", "for", "Reg", "." ]

[ "AMDGPU", "SI", "AMDGPU::NoRegAltName", "32", "AMDGPU::Reg32", "64", "AMDGPU::Reg64", "96", "AMDGPU::Reg96", "128", "AMDGPU::Reg128", "160", "AMDGPU::Reg160", "256", "AMDGPU::Reg256", "512", "AMDGPU::Reg512", "1024", "AMDGPU::Reg1024", "AMDGPU" ]

[]

[ "<s>", "InstructionCost", "AArch64TTIImpl", "::", "getMinMaxReductionCost", "(", "VectorType", "*", "Ty", ",", "VectorType", "*", "CondTy", ",", "bool", "IsUnsigned", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "if", "(", "LT", ".", "second", ".", "getScalarType", "(", ")", "==", "MVT", "::", "f16", "&&", "!", "ST", "->", "hasFullFP16", "(", ")", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsUnsigned", ",", "CostKind", ")", ";", "assert", "(", "(", "isa", "<", "ScalableVectorType", ">", "(", "Ty", ")", "==", "isa", "<", "ScalableVectorType", ">", "(", "CondTy", ")", ")", "&&", "\"Both vector needs to be equally scalable\"", ")", ";", "InstructionCost", "LegalizationCost", "=", "0", ";", "if", "(", "LT", ".", "first", ">", "1", ")", "{", "Type", "*", "LegalVTy", "=", "EVT", "(", "LT", ".", "second", ")", ".", "getTypeForEVT", "(", "Ty", "->", "getContext", "(", ")", ")", ";", "unsigned", "MinMaxOpcode", "=", "Ty", "->", "isFPOrFPVectorTy", "(", ")", "?", "Intrinsic", "::", "maxnum", ":", "(", "IsUnsigned", "?", "Intrinsic", "::", "umin", ":", "Intrinsic", "::", "smin", ")", ";", "IntrinsicCostAttributes", "Attrs", "(", "MinMaxOpcode", ",", "LegalVTy", ",", "{", "LegalVTy", ",", "LegalVTy", "}", ")", ";", "LegalizationCost", "=", "getIntrinsicInstrCost", "(", "Attrs", ",", "CostKind", ")", "*", "(", "LT", ".", "first", "-", "1", ")", ";", "}", "return", "LegalizationCost", "+", "2", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "op", "costs", "for", "min/max", "reduction", "operations", "." ]

[ "AArch64", "AArch64", "MVT::f16", "\"Both vector needs to be equally scalable\"", "0", "1", "Intrinsic::maxnum", "Intrinsic::umin", "Intrinsic::smin", "1", "2" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "X86RegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opc", ")", ")", "{", "const", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_ADD", ":", "case", "TargetOpcode", "::", "G_SUB", ":", "return", "getSameOperandsMapping", "(", "MI", ",", "false", ")", ";", "break", ";", "case", "TargetOpcode", "::", "G_FADD", ":", "case", "TargetOpcode", "::", "G_FSUB", ":", "case", "TargetOpcode", "::", "G_FMUL", ":", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "getSameOperandsMapping", "(", "MI", ",", "true", ")", ";", "break", ";", "default", ":", "break", ";", "}", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "SmallVector", "<", "PartialMappingIdx", ",", "4", ">", "OpRegBankIdx", "(", "NumOperands", ")", ";", "getInstrPartialMappingIdxs", "(", "MI", ",", "MRI", ",", "false", ",", "OpRegBankIdx", ")", ";", "SmallVector", "<", "const", "ValueMapping", "*", ",", "8", ">", "OpdsMapping", "(", "NumOperands", ")", ";", "if", "(", "!", "getInstrValueMapping", "(", "MI", ",", "OpRegBankIdx", ",", "OpdsMapping", ")", ")", "return", "getInvalidInstructionMapping", "(", ")", ";", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "getOperandsMapping", "(", "OpdsMapping", ")", ",", "NumOperands", ")", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "X86", "X86", "4", "8", "1" ]

[]

[ "<s>", "static", "void", "nds32_setup_incoming_varargs", "(", "cumulative_args_t", "ca", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_args_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "total_args_regs", ";", "unsigned", "int", "num_of_used_regs", ";", "unsigned", "int", "remaining_reg_count", ";", "CUMULATIVE_ARGS", "*", "cum", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "return", ";", "cum", "=", "get_cumulative_args", "(", "ca", ")", ";", "total_args_regs", "=", "NDS32_MAX_GPR_REGS_FOR_ARGS", "+", "NDS32_GPR_ARG_FIRST_REGNUM", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "num_of_used_regs", "=", "NDS32_AVAILABLE_REGNUM_FOR_GPR_ARG", "(", "cum", "->", "gpr_offset", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", "+", "NDS32_NEED_N_REGS_FOR_ARG", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "else", "num_of_used_regs", "=", "cum", "->", "gpr_offset", "+", "NDS32_GPR_ARG_FIRST_REGNUM", ";", "remaining_reg_count", "=", "total_args_regs", "-", "num_of_used_regs", ";", "*", "pretend_args_size", "=", "remaining_reg_count", "*", "UNITS_PER_WORD", ";", "return", ";", "}", "</s>" ]

[ "Implementing", "the", "Varargs", "Macros", "." ]

[ "nds32" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "void", "aarch64_emit_sve_ptrue_op", "(", "rtx", "target", ",", "rtx", "ptrue", ",", "rtx", "op", ")", "{", "rtx", "unspec", "=", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "target", ")", ",", "gen_rtvec", "(", "2", ",", "ptrue", ",", "op", ")", ",", "UNSPEC_MERGE_PTRUE", ")", ";", "rtx_insn", "*", "insn", "=", "emit_set_insn", "(", "target", ",", "unspec", ")", ";", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "copy_rtx", "(", "op", ")", ")", ";", "}", "</s>" ]

[ "Use", "predicated", "SVE", "instructions", "to", "implement", "the", "equivalent", "of", ":", "(", "set", "TARGET", "OP", ")", "given", "that", "PTRUE", "is", "an", "all-true", "predicate", "of", "the", "appropriate", "mode", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i16", ";", "}", "</s>" ]

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "Dcpu16", "MVT::i16" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "&", "EntryBlock", "=", "*", "(", "MF", "->", "begin", "(", ")", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "RISCV", "::", "ra", "||", "Reg", "==", "RISCV", "::", "ra_64", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", ".", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "EntryBlock", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "RISCV::ra", "RISCV::ra_64" ]

[]

[ "<s>", "void", "StackFixup", "::", "optimize", "(", "bool", "IsCommutative", ")", "{", "if", "(", "Changes", ".", "empty", "(", ")", ")", "return", ";", "optimizeEqualXchgs", "(", ")", ";", "if", "(", "IsCommutative", ")", "{", "if", "(", "Changes", ".", "size", "(", ")", "==", "1u", ")", "{", "auto", "&", "Change", "=", "Changes", "[", "0", "]", ".", "first", ";", "if", "(", "auto", "*", "Xchg", "=", "std", "::", "get_if", "<", "xchgTop", ">", "(", "&", "Change", ")", ")", "{", "if", "(", "Xchg", "->", "i", "==", "1u", ")", "Changes", ".", "clear", "(", ")", ";", "}", "}", "else", "if", "(", "Changes", ".", "size", "(", ")", "==", "2u", "&&", "(", "std", "::", "holds_alternative", "<", "pushI", ">", "(", "Changes", "[", "0", "]", ".", "first", ")", "||", "std", "::", "holds_alternative", "<", "pushUndef", ">", "(", "Changes", "[", "0", "]", ".", "first", ")", ")", ")", "{", "auto", "&", "Change", "=", "Changes", "[", "1", "]", ".", "first", ";", "if", "(", "auto", "*", "Xchg", "=", "std", "::", "get_if", "<", "xchgTop", ">", "(", "&", "Change", ")", ")", "{", "if", "(", "Xchg", "->", "i", "==", "1u", ")", "Changes", ".", "pop_back", "(", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Apply", "VPlan-to-VPlan", "optimizations", "to", "Plan", ",", "including", "induction", "recipe", "optimizations", ",", "dead", "recipe", "removal", ",", "replicate", "region", "optimizations", "and", "block", "merging", "." ]

[ "TVM", "1u", "0", "1u", "2u", "0", "0", "1", "1u" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "AnalyzeFormalArguments", "(", "CCState", "&", "State", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ")", "const", "{", "State", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_AMDGPU", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "ISD::InputArg", "AMDGPU" ]

[]

[ "<s>", "static", "void", "init_softstack_frame", "(", "FILE", "*", "file", ",", "unsigned", "alignment", ",", "HOST_WIDE_INT", "size", ")", "{", "unsigned", "keep_align", "=", "BIGGEST_ALIGNMENT", "/", "BITS_PER_UNIT", ";", "size", "=", "ROUND_UP", "(", "size", ",", "keep_align", ")", ";", "int", "bits", "=", "POINTER_SIZE", ";", "const", "char", "*", "reg_stack", "=", "reg_names", "[", "STACK_POINTER_REGNUM", "]", ";", "const", "char", "*", "reg_frame", "=", "reg_names", "[", "FRAME_POINTER_REGNUM", "]", ";", "const", "char", "*", "reg_sspslot", "=", "reg_names", "[", "SOFTSTACK_SLOT_REGNUM", "]", ";", "const", "char", "*", "reg_sspprev", "=", "reg_names", "[", "SOFTSTACK_PREV_REGNUM", "]", ";", "fprintf", "(", "file", ",", "\"\\t.reg.u%d %s;\\n\"", ",", "bits", ",", "reg_stack", ")", ";", "fprintf", "(", "file", ",", "\"\\t.reg.u%d %s;\\n\"", ",", "bits", ",", "reg_frame", ")", ";", "fprintf", "(", "file", ",", "\"\\t.reg.u%d %s;\\n\"", ",", "bits", ",", "reg_sspslot", ")", ";", "fprintf", "(", "file", ",", "\"\\t.reg.u%d %s;\\n\"", ",", "bits", ",", "reg_sspprev", ")", ";", "fprintf", "(", "file", ",", "\"\\t{\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\t.reg.u32 %%fstmp0;\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\t.reg.u%d %%fstmp1;\\n\"", ",", "bits", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\t.reg.u%d %%fstmp2;\\n\"", ",", "bits", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tmov.u32 %%fstmp0, %%tid.y;\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tmul%s.u32 %%fstmp1, %%fstmp0, %d;\\n\"", ",", "bits", "==", "64", "?", "\".wide\"", ":", "\".lo\"", ",", "bits", "/", "8", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tmov.u%d %%fstmp2, __nvptx_stacks;\\n\"", ",", "bits", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tadd.u%d %s, %%fstmp2, %%fstmp1;\\n\"", ",", "bits", ",", "reg_sspslot", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tld.shared.u%d %s, [%s];\\n\"", ",", "bits", ",", "reg_sspprev", ",", "reg_sspslot", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tsub.u%d %s, %s, \"", "HOST_WIDE_INT_PRINT_DEC", "\";\\n\"", ",", "bits", ",", "reg_frame", ",", "reg_sspprev", ",", "size", ")", ";", "if", "(", "alignment", ">", "keep_align", ")", "fprintf", "(", "file", ",", "\"\\t\\tand.b%d %s, %s, %d;\\n\"", ",", "bits", ",", "reg_frame", ",", "reg_frame", ",", "-", "alignment", ")", ";", "size", "=", "crtl", "->", "outgoing_args_size", ";", "gcc_assert", "(", "size", "%", "keep_align", "==", "0", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tsub.u%d %s, %s, \"", "HOST_WIDE_INT_PRINT_DEC", "\";\\n\"", ",", "bits", ",", "reg_stack", ",", "reg_frame", ",", "size", ")", ";", "if", "(", "!", "crtl", "->", "is_leaf", ")", "fprintf", "(", "file", ",", "\"\\t\\tst.shared.u%d [%s], %s;\\n\"", ",", "bits", ",", "reg_sspslot", ",", "reg_stack", ")", ";", "fprintf", "(", "file", ",", "\"\\t}\\n\"", ")", ";", "cfun", "->", "machine", "->", "has_softstack", "=", "true", ";", "need_softstack_decl", "=", "true", ";", "}", "</s>" ]

[ "Emit", "soft", "stack", "frame", "setup", "sequence", "." ]

[ "nvptx", "\"\\t.reg.u%d %s;\\n\"", "\"\\t.reg.u%d %s;\\n\"", "\"\\t.reg.u%d %s;\\n\"", "\"\\t.reg.u%d %s;\\n\"", "\"\\t{\\n\"", "\"\\t\\t.reg.u32 %%fstmp0;\\n\"", "\"\\t\\t.reg.u%d %%fstmp1;\\n\"", "\"\\t\\t.reg.u%d %%fstmp2;\\n\"", "\"\\t\\tmov.u32 %%fstmp0, %%tid.y;\\n\"", "\"\\t\\tmul%s.u32 %%fstmp1, %%fstmp0, %d;\\n\"", "64", "\".wide\"", "\".lo\"", "8", "\"\\t\\tmov.u%d %%fstmp2, __nvptx_stacks;\\n\"", "\"\\t\\tadd.u%d %s, %%fstmp2, %%fstmp1;\\n\"", "\"\\t\\tld.shared.u%d %s, [%s];\\n\"", "\"\\t\\tsub.u%d %s, %s, \"", "\";\\n\"", "\"\\t\\tand.b%d %s, %s, %d;\\n\"", "0", "\"\\t\\tsub.u%d %s, %s, \"", "\";\\n\"", "\"\\t\\tst.shared.u%d [%s], %s;\\n\"", "\"\\t}\\n\"" ]

[]

[ "<s>", "static", "machine_mode", "ix86_split_reduction", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V8DImode", ":", "case", "E_V4DImode", ":", "return", "V2DImode", ";", "case", "E_V16SImode", ":", "case", "E_V8SImode", ":", "return", "V4SImode", ";", "case", "E_V32HImode", ":", "case", "E_V16HImode", ":", "return", "V8HImode", ";", "case", "E_V64QImode", ":", "case", "E_V32QImode", ":", "return", "V16QImode", ";", "case", "E_V16SFmode", ":", "case", "E_V8SFmode", ":", "return", "V4SFmode", ";", "case", "E_V8DFmode", ":", "case", "E_V4DFmode", ":", "return", "V2DFmode", ";", "default", ":", "return", "mode", ";", "}", "}", "</s>" ]

[ "All", "CPUs", "prefer", "to", "avoid", "cross-lane", "operations", "so", "perform", "reductions", "upper", "against", "lower", "halves", "up", "to", "SSE", "reg", "size", "." ]

[ "i386" ]

[]

[ "<s>", "void", "LC2200InstPrinter", "::", "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", "." ]

[ "LC2200", "LC2200" ]

[]

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

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

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

[]

[ "<s>", "void", "LanaiFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "LanaiInstrInfo", "&", "LII", "=", "*", "static_cast", "<", "const", "LanaiInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "Lanai", "::", "ADD_I_LO", ")", ",", "Lanai", "::", "SP", ")", ".", "addReg", "(", "Lanai", "::", "FP", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "Lanai", "::", "LDW_RI", ")", ",", "Lanai", "::", "FP", ")", ".", "addReg", "(", "Lanai", "::", "FP", ")", ".", "addImm", "(", "-", "8", ")", ".", "addImm", "(", "LPAC", "::", "ADD", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai", "Lanai", "Lanai::ADD_I_LO", "Lanai::SP", "Lanai::FP", "0", "Lanai::LDW_RI", "Lanai::FP", "Lanai::FP", "8" ]

[]

[ "<s>", "bool", "xtensa_simm8", "(", "HOST_WIDE_INT", "v", ")", "{", "return", "IN_RANGE", "(", "v", ",", "-", "128", ",", "127", ")", ";", "}", "</s>" ]

[ "Functions", "to", "test", "Xtensa", "immediate", "operand", "validity", "." ]

[ "xtensa", "128", "127" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "CallInst", "*", "CI", ")", "const", "{", "auto", "Attr", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ";", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", "||", "Attr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "Hexagon", "Hexagon", "\"disable-tail-calls\"", "\"true\"" ]

[]

[ "<s>", "int", "AArch64TargetLowering", "::", "getScalingFactorCost", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "isLegalAddressingMode", "(", "DL", ",", "AM", ",", "Ty", ",", "AS", ")", ")", "return", "AM", ".", "Scale", "!=", "0", "&&", "AM", ".", "Scale", "!=", "1", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "the", "scaling", "factor", "used", "in", "the", "addressing", "mode", "represented", "by", "AM", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "AArch64", "AArch64", "0", "1", "1" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_asm_init_sections", "(", "void", ")", "{", "read_only_data_section", "=", "get_unnamed_section", "(", "0", ",", "rs6000_xcoff_output_readonly_section_asm_op", ",", "&", "xcoff_read_only_section_name", ")", ";", "private_data_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", ",", "rs6000_xcoff_output_readwrite_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "tls_data_section", "=", "get_unnamed_section", "(", "SECTION_TLS", ",", "rs6000_xcoff_output_tls_section_asm_op", ",", "&", "xcoff_tls_data_section_name", ")", ";", "tls_private_data_section", "=", "get_unnamed_section", "(", "SECTION_TLS", ",", "rs6000_xcoff_output_tls_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "read_only_private_data_section", "=", "get_unnamed_section", "(", "0", ",", "rs6000_xcoff_output_readonly_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "toc_section", "=", "get_unnamed_section", "(", "0", ",", "rs6000_xcoff_output_toc_section_asm_op", ",", "NULL", ")", ";", "readonly_data_section", "=", "read_only_data_section", ";", "exception_section", "=", "data_section", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_INIT_SECTIONS", "." ]

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

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "Count", "%", "4", ")", "return", "false", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MCOperand", "RISCVMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "MCOperand", "(", ")", ";", "return", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "0", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "StringRef", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "}", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ",", "0", ")", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "{", "const", "BlockAddress", "*", "BA", "=", "MO", ".", "getBlockAddress", "(", ")", ";", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "BA", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "RISCV", "RISCV", "\"unknown operand type\"", "0", "0" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "O", "<<", "\"\\t.section .mdebug.\"", "<<", "emitCurrentABIString", "(", ")", "<<", "'\\n'", ";", "if", "(", "Subtarget", "->", "isABI_EABI", "(", ")", ")", "O", "<<", "\"\\t.section .gcc_compiled_long\"", "<<", "(", "Subtarget", "->", "isGP32bit", "(", ")", "?", "\"32\"", ":", "\"64\"", ")", "<<", "'\\n'", ";", "O", "<<", "\"\\t.previous\"", "<<", "'\\n'", ";", "return", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"\\t.section .mdebug.\"", "\"\\t.section .gcc_compiled_long\"", "\"32\"", "\"64\"", "\"\\t.previous\"" ]

[]

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

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

[ "PTX" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemchr", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src", ",", "SDValue", "Char", ",", "SDValue", "Length", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "EVT", "PtrVT", "=", "Src", ".", "getValueType", "(", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "PtrVT", ",", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "Length", "=", "DAG", ".", "getZExtOrTrunc", "(", "Length", ",", "DL", ",", "PtrVT", ")", ";", "Char", "=", "DAG", ".", "getZExtOrTrunc", "(", "Char", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Char", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i32", ",", "Char", ",", "DAG", ".", "getConstant", "(", "255", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Limit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Src", ",", "Length", ")", ";", "SDValue", "End", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SEARCH_STRING", ",", "DL", ",", "VTs", ",", "Chain", ",", "Limit", ",", "Src", ",", "Char", ")", ";", "Chain", "=", "End", ".", "getValue", "(", "1", ")", ";", "SDValue", "Glue", "=", "End", ".", "getValue", "(", "2", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "End", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "PtrVT", ")", ",", "DAG", ".", "getConstant", "(", "SystemZ", "::", "CCMASK_SRST", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "SystemZ", "::", "CCMASK_SRST_FOUND", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "Glue", "}", ";", "VTs", "=", "DAG", ".", "getVTList", "(", "PtrVT", ",", "MVT", "::", "Glue", ")", ";", "End", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SELECT_CCMASK", ",", "DL", ",", "VTs", ",", "Ops", ")", ";", "return", "std", "::", "make_pair", "(", "End", ",", "Chain", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memchr", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "MVT::Other", "MVT::Glue", "MVT::i32", "ISD::AND", "MVT::i32", "255", "MVT::i32", "ISD::ADD", "SystemZISD::SEARCH_STRING", "1", "2", "0", "SystemZ::CCMASK_SRST", "MVT::i32", "SystemZ::CCMASK_SRST_FOUND", "MVT::i32", "MVT::Glue", "SystemZISD::SELECT_CCMASK" ]

[]

[ "<s>", "static", "unsigned", "spu_add_stmt_cost", "(", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "unsigned", "*", "cost", "=", "(", "unsigned", "*", ")", "data", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "tree", "vectype", "=", "stmt_info", "?", "stmt_vectype", "(", "stmt_info", ")", ":", "NULL_TREE", ";", "int", "stmt_cost", "=", "spu_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "stmt_info", ")", ")", "count", "*=", "50", ";", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "cost", "[", "where", "]", "+=", "retval", ";", "}", "return", "retval", ";", "}", "</s>" ]

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

[ "spu", "0", "50" ]

[]

[ "<s>", "void", "WebAssemblyInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "assert", "(", "RegNo", "!=", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", ";", "OS", "<<", "\"(get_local \"", "<<", "RegNo", "<<", "\")\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"(get_local \"", "\")\"" ]

[]

[ "<s>", "EVT", "SITargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "{", "return", "MVT", "::", "i1", ";", "}", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "R600", "SI", "MVT::i1", "MVT::getVectorVT", "MVT::i1" ]

[]