Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "MOSPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "MOS", "MOS" ]

[]

[ "<s>", "static", "rtx", "mmix_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "MMIX_RETURN_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Implements", "TARGET_LIBCALL_VALUE", "." ]

[ "mmix" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "TargetInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", ")", "return", "true", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "DSB", ":", "case", "AArch64", "::", "ISB", ":", "return", "true", ";", "default", ":", ";", "}", "return", "isSEHInstruction", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::DSB", "AArch64::ISB" ]

[]

[ "<s>", "static", "rtx", "frv_frame_offset_rtx", "(", "int", "offset", ")", "{", "rtx", "offset_rtx", "=", "GEN_INT", "(", "offset", ")", ";", "if", "(", "IN_RANGE_P", "(", "offset", ",", "-", "2048", ",", "2047", ")", ")", "return", "offset_rtx", ";", "else", "{", "rtx", "reg_rtx", "=", "gen_rtx_REG", "(", "SImode", ",", "OFFSET_REGNO", ")", ";", "if", "(", "IN_RANGE_P", "(", "offset", ",", "-", "32768", ",", "32767", ")", ")", "emit_insn", "(", "gen_movsi", "(", "reg_rtx", ",", "offset_rtx", ")", ")", ";", "else", "{", "emit_insn", "(", "gen_movsi_high", "(", "reg_rtx", ",", "offset_rtx", ")", ")", ";", "emit_insn", "(", "gen_movsi_lo_sum", "(", "reg_rtx", ",", "offset_rtx", ")", ")", ";", "}", "return", "reg_rtx", ";", "}", "}", "</s>" ]

[ "Return", "an", "rtx", "with", "the", "value", "OFFSET", ",", "which", "will", "either", "be", "a", "register", "or", "a", "signed", "12-bit", "integer", ".", "It", "can", "be", "used", "as", "the", "second", "operand", "in", "an", "``", "add", "''", "instruction", ",", "or", "as", "the", "index", "in", "a", "load", "or", "store", ".", "The", "function", "returns", "a", "constant", "rtx", "if", "OFFSET", "is", "small", "enough", ",", "otherwise", "it", "loads", "the", "constant", "into", "register", "OFFSET_REGNO", "and", "returns", "that", "." ]

[ "frv", "2048", "2047", "32768", "32767" ]

[]

[ "<s>", "FunctionType", "*", "AMDGPUIntrinsicInfo", "::", "getType", "(", "LLVMContext", "&", "Context", ",", "unsigned", "ID", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ")", "const", "{", "llvm_unreachable", "(", "\"unhandled intrinsic\"", ")", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "AMDGPU", "AMDGPU", "\"unhandled intrinsic\"" ]

[]

[ "<s>", "const", "unsigned", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "callsEHReturn", "=", "false", ";", "bool", "ghcCall", "=", "false", ";", "if", "(", "MF", ")", "{", "callsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "ghcCall", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ":", "false", ")", ";", "}", "static", "const", "unsigned", "GhcCalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegs32Bit", "[", "]", "=", "{", "X86", "::", "ESI", ",", "X86", "::", "EDI", ",", "X86", "::", "EBX", ",", "X86", "::", "EBP", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegs32EHRet", "[", "]", "=", "{", "X86", "::", "EAX", ",", "X86", "::", "EDX", ",", "X86", "::", "ESI", ",", "X86", "::", "EDI", ",", "X86", "::", "EBX", ",", "X86", "::", "EBP", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegs64Bit", "[", "]", "=", "{", "X86", "::", "RBX", ",", "X86", "::", "R12", ",", "X86", "::", "R13", ",", "X86", "::", "R14", ",", "X86", "::", "R15", ",", "X86", "::", "RBP", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegs64EHRet", "[", "]", "=", "{", "X86", "::", "RAX", ",", "X86", "::", "RDX", ",", "X86", "::", "RBX", ",", "X86", "::", "R12", ",", "X86", "::", "R13", ",", "X86", "::", "R14", ",", "X86", "::", "R15", ",", "X86", "::", "RBP", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsWin64", "[", "]", "=", "{", "X86", "::", "RBX", ",", "X86", "::", "RBP", ",", "X86", "::", "RDI", ",", "X86", "::", "RSI", ",", "X86", "::", "R12", ",", "X86", "::", "R13", ",", "X86", "::", "R14", ",", "X86", "::", "R15", ",", "X86", "::", "XMM6", ",", "X86", "::", "XMM7", ",", "X86", "::", "XMM8", ",", "X86", "::", "XMM9", ",", "X86", "::", "XMM10", ",", "X86", "::", "XMM11", ",", "X86", "::", "XMM12", ",", "X86", "::", "XMM13", ",", "X86", "::", "XMM14", ",", "X86", "::", "XMM15", ",", "0", "}", ";", "if", "(", "ghcCall", ")", "{", "return", "GhcCalleeSavedRegs", ";", "}", "else", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CalleeSavedRegsWin64", ";", "else", "return", "(", "callsEHReturn", "?", "CalleeSavedRegs64EHRet", ":", "CalleeSavedRegs64Bit", ")", ";", "}", "else", "{", "return", "(", "callsEHReturn", "?", "CalleeSavedRegs32EHRet", ":", "CalleeSavedRegs32Bit", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "0", "X86::ESI", "X86::EDI", "X86::EBX", "X86::EBP", "0", "X86::EAX", "X86::EDX", "X86::ESI", "X86::EDI", "X86::EBX", "X86::EBP", "0", "X86::RBX", "X86::R12", "X86::R13", "X86::R14", "X86::R15", "X86::RBP", "0", "X86::RAX", "X86::RDX", "X86::RBX", "X86::R12", "X86::R13", "X86::R14", "X86::R15", "X86::RBP", "0", "X86::RBX", "X86::RBP", "X86::RDI", "X86::RSI", "X86::R12", "X86::R13", "X86::R14", "X86::R15", "X86::XMM6", "X86::XMM7", "X86::XMM8", "X86::XMM9", "X86::XMM10", "X86::XMM11", "X86::XMM12", "X86::XMM13", "X86::XMM14", "X86::XMM15", "0" ]

[]

[ "<s>", "static", "bool", "riscv_allocate_stack_slots_for_args", "(", ")", "{", "return", "!", "riscv_naked_function_p", "(", "current_function_decl", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "X86IndirectBranchTrackingPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "SubTarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "Metadata", "*", "isCFProtectionSupported", "=", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ";", "const", "X86TargetMachine", "*", "TM", "=", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "bool", "isJITwithCET", "=", "TM", "->", "isJIT", "(", ")", ";", "bool", "isJITwithCET", "=", "false", ";", "if", "(", "!", "isCFProtectionSupported", "&&", "!", "IndirectBranchTracking", "&&", "!", "isJITwithCET", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "TII", "=", "SubTarget", ".", "getInstrInfo", "(", ")", ";", "EndbrOpcode", "=", "SubTarget", ".", "is64Bit", "(", ")", "?", "X86", "::", "ENDBR64", ":", "X86", "::", "ENDBR32", ";", "if", "(", "(", "TM", "->", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "||", "MF", ".", "getFunction", "(", ")", ".", "hasAddressTaken", "(", ")", "||", "!", "MF", ".", "getFunction", "(", ")", ".", "hasLocalLinkage", "(", ")", ")", "&&", "!", "MF", ".", "getFunction", "(", ")", ".", "doesNoCfCheck", "(", ")", ")", "{", "auto", "MBB", "=", "MF", ".", "begin", "(", ")", ";", "Changed", "|=", "addENDBR", "(", "*", "MBB", ",", "MBB", "->", "begin", "(", ")", ")", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "if", "(", "MBB", ".", "hasAddressTaken", "(", ")", ")", "Changed", "|=", "addENDBR", "(", "MBB", ",", "MBB", ".", "begin", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isCall", "(", ")", "&&", "IsCallReturnTwice", "(", "I", "->", "getOperand", "(", "0", ")", ")", ")", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "}", "if", "(", "TM", "->", "Options", ".", "ExceptionModel", "==", "ExceptionHandling", "::", "SjLj", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "MBB", ".", "isEHPad", "(", ")", ")", "{", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "Changed", "|=", "addENDBR", "(", "MBB", ",", "I", ")", ";", "break", ";", "}", "else", "if", "(", "I", "->", "isEHLabel", "(", ")", ")", "{", "MCSymbol", "*", "Sym", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMCSymbol", "(", ")", ";", "if", "(", "!", "MF", ".", "hasCallSiteLandingPad", "(", "Sym", ")", ")", "continue", ";", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "break", ";", "}", "}", "}", "else", "if", "(", "MBB", ".", "isEHPad", "(", ")", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "isEHLabel", "(", ")", ")", "continue", ";", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"cf-protection-branch\"", "X86", "X86", "X86::ENDBR64", "X86::ENDBR32", "0", "0" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "SDValue", "Cpu0TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Cpu0", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "assert", "(", "RVLocs", ".", "size", "(", ")", "<=", "1", "&&", "\"Too many values to return!\"", ")", ";", "if", "(", "RVLocs", ".", "size", "(", ")", ">", "0", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "0", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "0", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "assert", "(", "false", "&&", "\"Not yet implemented\"", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "RVLocs", ".", "size", "(", ")", "==", "0", "?", "Cpu0ISD", "::", "Ret", ":", "Cpu0ISD", "::", "RetValue", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "ISD::OutputArg", "16", "Cpu0", "4", "1", "1", "\"Too many values to return!\"", "0", "0", "\"Can only return in registers!\"", "0", "1", "\"Not yet implemented\"", "0", "0", "Cpu0ISD::Ret", "Cpu0ISD::RetValue", "MVT::Other", "0" ]

[]

[ "<s>", "Register", "ARMBaseRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "ARMFunctionInfo", "*", "AFI", "=", "MBB", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "ADDriOpc", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "ADDri", ":", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "?", "ARM", "::", "tADDframe", ":", "ARM", "::", "t2ADDri", ")", ";", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", ".", "get", "(", "ADDriOpc", ")", ";", "Register", "BaseReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "ARM", "::", "GPRRegClass", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", ".", "getRegClass", "(", "MCID", ",", "0", ",", "this", ",", "MF", ")", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "MCID", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ";", "if", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ".", "add", "(", "condCodeOp", "(", ")", ")", ";", "return", "BaseReg", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::ADDri", "ARM::tADDframe", "ARM::t2ADDri", "ARM::GPRRegClass", "0", "ARMCC::AL" ]

[]

[ "<s>", "static", "int", "force_new_group", "(", "int", "sched_verbose", ",", "FILE", "*", "dump", ",", "rtx", "*", "group_insns", ",", "rtx", "next_insn", ",", "bool", "*", "group_end", ",", "int", "can_issue_more", ",", "int", "*", "group_count", ")", "{", "rtx", "nop", ";", "bool", "force", ";", "int", "issue_rate", "=", "rs6000_issue_rate", "(", ")", ";", "bool", "end", "=", "*", "group_end", ";", "int", "i", ";", "if", "(", "next_insn", "==", "NULL_RTX", ")", "return", "can_issue_more", ";", "if", "(", "rs6000_sched_insert_nops", ">", "sched_finish_regroup_exact", ")", "return", "can_issue_more", ";", "force", "=", "is_costly_group", "(", "group_insns", ",", "next_insn", ")", ";", "if", "(", "!", "force", ")", "return", "can_issue_more", ";", "if", "(", "sched_verbose", ">", "6", ")", "fprintf", "(", "dump", ",", "\"force: group count = %d, can_issue_more = %d\\n\"", ",", "*", "group_count", ",", "can_issue_more", ")", ";", "if", "(", "rs6000_sched_insert_nops", "==", "sched_finish_regroup_exact", ")", "{", "if", "(", "*", "group_end", ")", "can_issue_more", "=", "0", ";", "if", "(", "can_issue_more", "&&", "!", "is_branch_slot_insn", "(", "next_insn", ")", ")", "can_issue_more", "--", ";", "while", "(", "can_issue_more", ">", "0", ")", "{", "nop", "=", "gen_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "can_issue_more", "--", ";", "}", "*", "group_end", "=", "true", ";", "return", "0", ";", "}", "if", "(", "rs6000_sched_insert_nops", "<", "sched_finish_regroup_exact", ")", "{", "int", "n_nops", "=", "rs6000_sched_insert_nops", ";", "if", "(", "can_issue_more", "==", "0", ")", "can_issue_more", "=", "issue_rate", ";", "can_issue_more", "--", ";", "if", "(", "can_issue_more", "==", "0", ")", "{", "can_issue_more", "=", "issue_rate", "-", "1", ";", "(", "*", "group_count", ")", "++", ";", "end", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "group_insns", "[", "i", "]", "=", "0", ";", "}", "}", "while", "(", "n_nops", ">", "0", ")", "{", "nop", "=", "gen_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "if", "(", "can_issue_more", "==", "issue_rate", "-", "1", ")", "end", "=", "false", ";", "can_issue_more", "--", ";", "if", "(", "can_issue_more", "==", "0", ")", "{", "can_issue_more", "=", "issue_rate", "-", "1", ";", "(", "*", "group_count", ")", "++", ";", "end", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "group_insns", "[", "i", "]", "=", "0", ";", "}", "}", "n_nops", "--", ";", "}", "can_issue_more", "++", ";", "*", "group_end", "=", "(", "end", "||", "(", "can_issue_more", "==", "1", "&&", "!", "is_branch_slot_insn", "(", "next_insn", ")", ")", "||", "(", "can_issue_more", "<=", "2", "&&", "is_cracked_insn", "(", "next_insn", ")", ")", "||", "(", "can_issue_more", "<", "issue_rate", "&&", "insn_terminates_group_p", "(", "next_insn", ",", "previous_group", ")", ")", ")", ";", "if", "(", "*", "group_end", "&&", "end", ")", "(", "*", "group_count", ")", "--", ";", "if", "(", "sched_verbose", ">", "6", ")", "fprintf", "(", "dump", ",", "\"done force: group count = %d, can_issue_more = %d\\n\"", ",", "*", "group_count", ",", "can_issue_more", ")", ";", "return", "can_issue_more", ";", "}", "return", "can_issue_more", ";", "}", "</s>" ]

[ "Utility", "of", "the", "function", "redefine_groups", ".", "Check", "if", "it", "is", "too", "costly", "to", "schedule", "NEXT_INSN", "together", "with", "GROUP_INSNS", "in", "the", "same", "dispatch", "group", ".", "If", "so", ",", "insert", "nops", "before", "NEXT_INSN", ",", "in", "order", "to", "keep", "it", "``", "far", "''", "(", "in", "a", "separate", "group", ")", "from", "GROUP_INSNS", ",", "following", "one", "of", "the", "following", "schemes", ",", "depending", "on", "the", "value", "of", "the", "flag", "-minsert_sched_nops", "=", "X", ":", "(", "1", ")", "X", "==", "sched_finish_regroup_exact", ":", "insert", "exactly", "as", "many", "nops", "as", "needed", "in", "order", "to", "force", "NEXT_INSN", "into", "a", "separate", "group", ".", "(", "2", ")", "X", "<", "sched_finish_regroup_exact", ":", "insert", "exactly", "X", "nops", ".", "GROUP_END", ",", "CAN_ISSUE_MORE", "and", "GROUP_COUNT", "record", "the", "state", "after", "nop", "insertion", "(", "has", "a", "group", "just", "ended", ",", "how", "many", "vacant", "issue", "slots", "remain", "in", "the", "last", "group", ",", "and", "how", "many", "dispatch", "groups", "were", "encountered", "so", "far", ")", "." ]

[ "rs6000", "6", "\"force: group count = %d, can_issue_more = %d\\n\"", "0", "0", "0", "0", "0", "1", "0", "0", "0", "1", "0", "1", "0", "0", "1", "2", "6", "\"done force: group count = %d, can_issue_more = %d\\n\"" ]

[]

[ "<s>", "static", "void", "riscv_extend_comparands", "(", "rtx_code", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "word_mode", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "*", "op0", ")", ")", ".", "to_constant", "(", ")", ")", "{", "if", "(", "unsigned_condition", "(", "code", ")", "==", "code", "&&", "(", "GET_MODE", "(", "*", "op0", ")", "==", "QImode", "&&", "!", "(", "GET_CODE", "(", "*", "op0", ")", "==", "SUBREG", "&&", "SUBREG_PROMOTED_VAR_P", "(", "*", "op0", ")", "&&", "SUBREG_PROMOTED_SIGNED_P", "(", "*", "op0", ")", "&&", "(", "CONST_INT_P", "(", "*", "op1", ")", "||", "(", "GET_CODE", "(", "*", "op1", ")", "==", "SUBREG", "&&", "SUBREG_PROMOTED_VAR_P", "(", "*", "op1", ")", "&&", "SUBREG_PROMOTED_SIGNED_P", "(", "*", "op1", ")", ")", ")", ")", ")", ")", "{", "*", "op0", "=", "gen_rtx_ZERO_EXTEND", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "CONST_INT_P", "(", "*", "op1", ")", ")", "*", "op1", "=", "GEN_INT", "(", "(", "uint8_t", ")", "INTVAL", "(", "*", "op1", ")", ")", ";", "else", "*", "op1", "=", "gen_rtx_ZERO_EXTEND", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "else", "{", "*", "op0", "=", "gen_rtx_SIGN_EXTEND", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "*", "op1", "!=", "const0_rtx", ")", "*", "op1", "=", "gen_rtx_SIGN_EXTEND", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "}", "}", "</s>" ]

[ "Sign-", "or", "zero-extend", "OP0", "and", "OP1", "for", "integer", "comparisons", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "case", "'L'", ":", "case", "'H'", ":", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "Register", "RegNumber", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "RegNumber", ")", ")", "RegNumber", "=", "TRI", "->", "getSubReg", "(", "RegNumber", ",", "ExtraCode", "[", "0", "]", "==", "'L'", "?", "Hexagon", "::", "isub_lo", ":", "Hexagon", "::", "isub_hi", ")", ";", "OS", "<<", "HexagonInstPrinter", "::", "getRegisterName", "(", "RegNumber", ")", ";", "return", "false", ";", "}", "case", "'I'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "OS", "<<", "\"i\"", ";", "return", "false", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "1", "0", "0", "Hexagon::DoubleRegsRegClass", "0", "Hexagon::isub_lo", "Hexagon::isub_hi", "Hexagon", "\"i\"" ]

[]

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

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

[ "TPC" ]

[]

[ "<s>", "static", "inline", "unsigned", "long", "*", "ia64_rse_skip_regs", "(", "unsigned", "long", "*", "addr", ",", "long", "num_regs", ")", "{", "long", "delta", "=", "ia64_rse_slot_num", "(", "addr", ")", "+", "num_regs", ";", "if", "(", "num_regs", "<", "0", ")", "delta", "-=", "0x3e", ";", "return", "addr", "+", "num_regs", "+", "delta", "/", "0x3f", ";", "}", "</s>" ]

[ "The", "inverse", "of", "the", "above", ":", "given", "bspstore", "and", "the", "number", "of", "registers", ",", "calculate", "ar.bsp", "." ]

[ "ia64", "0", "0x3e", "0x3f" ]

[]

[ "<s>", "static", "bool", "spu_addr_space_subset_p", "(", "addr_space_t", "subset", ",", "addr_space_t", "superset", ")", "{", "gcc_assert", "(", "subset", "==", "ADDR_SPACE_GENERIC", "||", "subset", "==", "ADDR_SPACE_EA", ")", ";", "gcc_assert", "(", "superset", "==", "ADDR_SPACE_GENERIC", "||", "superset", "==", "ADDR_SPACE_EA", ")", ";", "if", "(", "subset", "==", "superset", ")", "return", "true", ";", "else", "if", "(", "!", "TARGET_ADDRESS_SPACE_CONVERSION", ")", "return", "false", ";", "else", "return", "(", "subset", "==", "ADDR_SPACE_GENERIC", "&&", "superset", "==", "ADDR_SPACE_EA", ")", ";", "}", "</s>" ]

[ "Determine", "if", "one", "named", "address", "space", "is", "a", "subset", "of", "another", "." ]

[ "spu" ]

[]

[ "<s>", "static", "reg_class_t", "xstormy16_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "rclass", "==", "GENERAL_REGS", "&&", "(", "MEM_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_MODIFY", ")", ")", "return", "EIGHT_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

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

[ "stormy16" ]

[]

[ "<s>", "int", "m32r_expand_block_move", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "orig_dst", "=", "operands", "[", "0", "]", ";", "rtx", "orig_src", "=", "operands", "[", "1", "]", ";", "rtx", "bytes_rtx", "=", "operands", "[", "2", "]", ";", "rtx", "align_rtx", "=", "operands", "[", "3", "]", ";", "int", "constp", "=", "CONST_INT_P", "(", "bytes_rtx", ")", ";", "HOST_WIDE_INT", "bytes", "=", "constp", "?", "INTVAL", "(", "bytes_rtx", ")", ":", "0", ";", "int", "align", "=", "INTVAL", "(", "align_rtx", ")", ";", "int", "leftover", ";", "rtx", "src_reg", ";", "rtx", "dst_reg", ";", "if", "(", "constp", "&&", "bytes", "<=", "0", ")", "return", "1", ";", "dst_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "orig_dst", ",", "0", ")", ")", ";", "src_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "orig_src", ",", "0", ")", ")", ";", "if", "(", "align", ">", "UNITS_PER_WORD", ")", "align", "=", "UNITS_PER_WORD", ";", "if", "(", "optimize_size", "||", "!", "constp", "||", "align", "!=", "UNITS_PER_WORD", ")", "{", "block_move_call", "(", "dst_reg", ",", "src_reg", ",", "bytes_rtx", ")", ";", "return", "0", ";", "}", "leftover", "=", "bytes", "%", "MAX_MOVE_BYTES", ";", "bytes", "-=", "leftover", ";", "if", "(", "bytes", ")", "{", "rtx_code_label", "*", "label", "=", "NULL", ";", "rtx", "final_src", "=", "NULL_RTX", ";", "rtx", "at_a_time", "=", "GEN_INT", "(", "MAX_MOVE_BYTES", ")", ";", "rtx", "rounded_total", "=", "GEN_INT", "(", "bytes", ")", ";", "rtx", "new_dst_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "new_src_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "bytes", ">", "MAX_MOVE_BYTES", ")", "{", "final_src", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "INT16_P", "(", "bytes", ")", ")", "emit_insn", "(", "gen_addsi3", "(", "final_src", ",", "src_reg", ",", "rounded_total", ")", ")", ";", "else", "{", "emit_insn", "(", "gen_movsi", "(", "final_src", ",", "rounded_total", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "final_src", ",", "final_src", ",", "src_reg", ")", ")", ";", "}", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "}", "emit_insn", "(", "gen_movmemsi_internal", "(", "dst_reg", ",", "src_reg", ",", "at_a_time", ",", "new_dst_reg", ",", "new_src_reg", ")", ")", ";", "emit_move_insn", "(", "dst_reg", ",", "new_dst_reg", ")", ";", "emit_move_insn", "(", "src_reg", ",", "new_src_reg", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "dst_reg", ",", "dst_reg", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "if", "(", "bytes", ">", "MAX_MOVE_BYTES", ")", "{", "rtx", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "src_reg", ",", "final_src", ")", ";", "emit_jump_insn", "(", "gen_cbranchsi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "}", "}", "if", "(", "leftover", ")", "emit_insn", "(", "gen_movmemsi_internal", "(", "dst_reg", ",", "src_reg", ",", "GEN_INT", "(", "leftover", ")", ",", "gen_reg_rtx", "(", "SImode", ")", ",", "gen_reg_rtx", "(", "SImode", ")", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Expand", "string/block", "move", "operations", ".", "operands", "[", "0", "]", "is", "the", "pointer", "to", "the", "destination", ".", "operands", "[", "1", "]", "is", "the", "pointer", "to", "the", "source", ".", "operands", "[", "2", "]", "is", "the", "number", "of", "bytes", "to", "move", ".", "operands", "[", "3", "]", "is", "the", "alignment", "." ]

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

[]

[ "<s>", "bool", "X86WinAllocaExpander", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasWinAlloca", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "StackPtr", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "SlotSize", "=", "TRI", "->", "getSlotSize", "(", ")", ";", "StackProbeSize", "=", "4096", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"stack-probe-size\"", ")", ")", "{", "MF", ".", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"stack-probe-size\"", ")", ".", "getValueAsString", "(", ")", ".", "getAsInteger", "(", "0", ",", "StackProbeSize", ")", ";", "}", "LoweringMap", "Lowerings", ";", "computeLowerings", "(", "MF", ",", "Lowerings", ")", ";", "for", "(", "auto", "&", "P", ":", "Lowerings", ")", "lower", "(", "P", ".", "first", ",", "P", ".", "second", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "4096", "\"stack-probe-size\"", "\"stack-probe-size\"", "0" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "&&", "!", "Subtarget", "->", "callRegIndirect", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "MVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getSimpleValueType", "(", ")", ";", "MVT", "DstVT", "=", "N", "->", "getSimpleValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "const", "X86TargetLowering", "*", "X86Lowering", "=", "static_cast", "<", "const", "X86TargetLowering", "*", ">", "(", "getTargetLowering", "(", ")", ")", ";", "bool", "SrcIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "MVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "X86", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "void", "output_dbcc_and_branch", "(", "rtx", "*", "operands", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", ")", "{", "case", "EQ", ":", "output_asm_insn", "(", "\"dbeq %0,%l1\\n\\tjeq %l2\"", ",", "operands", ")", ";", "break", ";", "case", "NE", ":", "output_asm_insn", "(", "\"dbne %0,%l1\\n\\tjne %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GT", ":", "output_asm_insn", "(", "\"dbgt %0,%l1\\n\\tjgt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GTU", ":", "output_asm_insn", "(", "\"dbhi %0,%l1\\n\\tjhi %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LT", ":", "output_asm_insn", "(", "\"dblt %0,%l1\\n\\tjlt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LTU", ":", "output_asm_insn", "(", "\"dbcs %0,%l1\\n\\tjcs %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GE", ":", "output_asm_insn", "(", "\"dbge %0,%l1\\n\\tjge %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GEU", ":", "output_asm_insn", "(", "\"dbcc %0,%l1\\n\\tjcc %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LE", ":", "output_asm_insn", "(", "\"dble %0,%l1\\n\\tjle %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LEU", ":", "output_asm_insn", "(", "\"dbls %0,%l1\\n\\tjls %l2\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "SImode", ":", "output_asm_insn", "(", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\"", ",", "operands", ")", ";", "break", ";", "case", "HImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "dbCC", ";", "jCC", "sequence", ".", "Note", "we", "do", "not", "handle", "the", "floating", "point", "version", "of", "this", "sequence", "(", "Fdbcc", ")", ".", "We", "also", "do", "not", "handle", "alternative", "conditions", "when", "CC_NO_OVERFLOW", "is", "set", ".", "It", "is", "assumed", "that", "valid_dbcc_comparison_p", "and", "flags_in_68881", "will", "kick", "those", "out", "before", "we", "get", "here", "." ]

[ "m68k", "3", "\"dbeq %0,%l1\\n\\tjeq %l2\"", "\"dbne %0,%l1\\n\\tjne %l2\"", "\"dbgt %0,%l1\\n\\tjgt %l2\"", "\"dbhi %0,%l1\\n\\tjhi %l2\"", "\"dblt %0,%l1\\n\\tjlt %l2\"", "\"dbcs %0,%l1\\n\\tjcs %l2\"", "\"dbge %0,%l1\\n\\tjge %l2\"", "\"dbcc %0,%l1\\n\\tjcc %l2\"", "\"dble %0,%l1\\n\\tjle %l2\"", "\"dbls %0,%l1\\n\\tjls %l2\"", "0", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\"" ]

[]

[ "<s>", "MVT", "SPIRVTargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorNumElements", "(", ")", "==", "3", ")", "{", "if", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "MVT", "::", "v4i1", ";", "else", "if", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i8", ")", "return", "MVT", "::", "v4i8", ";", "}", "return", "getRegisterType", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV", "3", "MVT::i1", "MVT::v4i1", "MVT::i8", "MVT::v4i8" ]

[]

[ "<s>", "void", "Emitter", "<", "CodeEmitter", ">", "::", "emitInstruction", "(", "const", "MachineInstr", "&", "MI", ")", "{", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"JIT: \"", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "\":\\t\"", "<<", "MI", ")", ";", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ")", ";", "NumEmitted", "++", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "{", "default", ":", "{", "llvm_unreachable", "(", "\"Unhandled instruction encoding format!\"", ")", ";", "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", "::", "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", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "altivec_build_resolved_builtin", "(", "tree", "*", "args", ",", "int", "n", ",", "tree", "fntype", ",", "tree", "ret_type", ",", "rs6000_gen_builtins", "bif_id", ",", "rs6000_gen_builtins", "ovld_id", ")", "{", "tree", "argtypes", "=", "TYPE_ARG_TYPES", "(", "fntype", ")", ";", "tree", "arg_type", "[", "MAX_OVLD_ARGS", "]", ";", "tree", "fndecl", "=", "rs6000_builtin_decls", "[", "bif_id", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "arg_type", "[", "i", "]", "=", "TREE_VALUE", "(", "argtypes", ")", ";", "argtypes", "=", "TREE_CHAIN", "(", "argtypes", ")", ";", "}", "if", "(", "n", "==", "3", "&&", "ovld_id", "==", "RS6000_OVLD_VEC_CMPGE_P", "&&", "bif_id", "!=", "RS6000_BIF_VCMPGEFP_P", "&&", "bif_id", "!=", "RS6000_BIF_XVCMPGEDP_P", ")", "{", "std", "::", "swap", "(", "args", "[", "1", "]", ",", "args", "[", "2", "]", ")", ";", "std", "::", "swap", "(", "arg_type", "[", "1", "]", ",", "arg_type", "[", "2", "]", ")", ";", "args", "[", "0", "]", "=", "fold_build2", "(", "BIT_XOR_EXPR", ",", "TREE_TYPE", "(", "args", "[", "0", "]", ")", ",", "args", "[", "0", "]", ",", "build_int_cst", "(", "NULL_TREE", ",", "2", ")", ")", ";", "}", "for", "(", "int", "j", "=", "0", ";", "j", "<", "n", ";", "j", "++", ")", "args", "[", "j", "]", "=", "fully_fold_convert", "(", "arg_type", "[", "j", "]", ",", "args", "[", "j", "]", ")", ";", "gcc_assert", "(", "MAX_OVLD_ARGS", "<=", "4", ")", ";", "tree", "call", ";", "switch", "(", "n", ")", "{", "case", "0", ":", "call", "=", "build_call_expr", "(", "fndecl", ",", "0", ")", ";", "break", ";", "case", "1", ":", "call", "=", "build_call_expr", "(", "fndecl", ",", "1", ",", "args", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "call", "=", "build_call_expr", "(", "fndecl", ",", "2", ",", "args", "[", "0", "]", ",", "args", "[", "1", "]", ")", ";", "break", ";", "case", "3", ":", "call", "=", "build_call_expr", "(", "fndecl", ",", "3", ",", "args", "[", "0", "]", ",", "args", "[", "1", "]", ",", "args", "[", "2", "]", ")", ";", "break", ";", "case", "4", ":", "call", "=", "build_call_expr", "(", "fndecl", ",", "4", ",", "args", "[", "0", "]", ",", "args", "[", "1", "]", ",", "args", "[", "2", "]", ",", "args", "[", "3", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "fold_convert", "(", "ret_type", ",", "call", ")", ";", "}", "</s>" ]

[ "Build", "a", "tree", "for", "a", "function", "call", "to", "an", "Altivec", "non-overloaded", "builtin", ".", "The", "overloaded", "builtin", "that", "matched", "the", "types", "and", "args", "is", "described", "by", "DESC", ".", "The", "N", "arguments", "are", "given", "in", "ARGS", ",", "respectively", ".", "Actually", "the", "only", "thing", "it", "does", "is", "calling", "fold_convert", "on", "ARGS", ",", "with", "a", "small", "exception", "for", "vec_", "{", "all", ",", "any", "}", "_", "{", "ge", ",", "le", "}", "predicates", "." ]

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

[]

[ "<s>", "unsigned", "char", "M68kSubtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "switch", "(", "TM", ".", "getCodeModel", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported code model\"", ")", ";", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Kernel", ":", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "return", "M68kII", "::", "MO_GOTPCREL", ";", "return", "M68kII", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "case", "CodeModel", "::", "Medium", ":", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "return", "M68kII", "::", "MO_GOTPCREL", ";", "if", "(", "atLeastM68020", "(", ")", ")", "return", "M68kII", "::", "MO_PC_RELATIVE_ADDRESS", ";", "return", "M68kII", "::", "MO_ABSOLUTE_ADDRESS", ";", "}", "}", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "M68k", "M68k", "\"Unsupported code model\"", "M68kII::MO_GOTPCREL", "M68kII::MO_PC_RELATIVE_ADDRESS", "M68kII::MO_GOTPCREL", "M68kII::MO_PC_RELATIVE_ADDRESS", "M68kII::MO_ABSOLUTE_ADDRESS" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "Mask", ",", "int", "&", "Value", ")", "const", "{", "assert", "(", "MI", "->", "isCompare", "(", ")", "&&", "\"Caller should have checked for a comparison\"", ")", ";", "if", "(", "MI", "->", "getNumExplicitOperands", "(", ")", "==", "2", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "{", "SrcReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "Value", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Mask", "=", "~", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Caller should have checked for a comparison\"", "2", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "void", "aarch64_emit_sve_pred_move", "(", "rtx", "dest", ",", "rtx", "pred", ",", "rtx", "src", ")", "{", "expand_operand", "ops", "[", "3", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "dest", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "pred", ",", "GET_MODE", "(", "pred", ")", ")", ";", "create_input_operand", "(", "&", "ops", "[", "2", "]", ",", "src", ",", "mode", ")", ";", "expand_insn", "(", "code_for_aarch64_pred_mov", "(", "mode", ")", ",", "3", ",", "ops", ")", ";", "}", "</s>" ]

[ "Emit", "an", "SVE", "predicated", "move", "from", "SRC", "to", "DEST", ".", "PRED", "is", "a", "predicate", "that", "is", "known", "to", "contain", "PTRUE", "." ]

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

[]

[ "<s>", "bool", "AMDGPUMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "return", "true", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "createReg", "(", "AMDGPU", "::", "getMCReg", "(", "MO", ".", "getReg", "(", ")", ",", "ST", ")", ")", ";", "return", "true", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "{", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "!=", "0", ")", "{", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "getLongBranchBlockExpr", "(", "*", "MO", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MO", ")", ")", ";", "}", "else", "{", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "}", "return", "true", ";", "}", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "SmallString", "<", "128", ">", "SymbolName", ";", "AP", ".", "getNameWithPrefix", "(", "SymbolName", ",", "GV", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "SymbolName", ")", ";", "const", "MCExpr", "*", "SymExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "getVariantKind", "(", "MO", ".", "getTargetFlags", "(", ")", ")", ",", "Ctx", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MCBinaryExpr", "::", "createAdd", "(", "SymExpr", ",", "MCConstantExpr", "::", "create", "(", "MO", ".", "getOffset", "(", ")", ",", "Ctx", ")", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "return", "true", ";", "}", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "StringRef", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "Sym", "->", "setExternal", "(", "true", ")", ";", "const", "MCSymbolRefExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "return", "true", ";", "}", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"unknown operand type\"", "AMDGPU::getMCReg", "0", "128" ]

[]

[ "<s>", "gimple", "*", "gimple_fold_builtin", "(", "unsigned", "int", "code", ",", "gimple_stmt_iterator", "*", "gsi", ",", "gcall", "*", "stmt", ")", "{", "registered_function", "&", "rfn", "=", "*", "(", "*", "registered_functions", ")", "[", "code", "]", ";", "return", "gimple_folder", "(", "rfn", ".", "instance", ",", "rfn", ".", "decl", ",", "gsi", ",", "stmt", ")", ".", "fold", "(", ")", ";", "}", "</s>" ]

[ "Attempt", "to", "fold", "STMT", ",", "given", "that", "it", "'s", "a", "call", "to", "the", "SVE", "function", "with", "subcode", "CODE", ".", "Return", "the", "new", "statement", "on", "success", "and", "null", "on", "failure", ".", "Insert", "any", "other", "new", "statements", "at", "GSI", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "scan_record_type", "(", "const_tree", "type", ",", "int", "*", "intregs_p", ",", "int", "*", "fpregs_p", ",", "int", "*", "packed_p", ")", "{", "tree", "field", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "RECORD_TYPE", ")", "scan_record_type", "(", "TREE_TYPE", "(", "field", ")", ",", "intregs_p", ",", "fpregs_p", ",", "0", ")", ";", "else", "if", "(", "(", "FLOAT_TYPE_P", "(", "TREE_TYPE", "(", "field", ")", ")", "||", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "VECTOR_TYPE", ")", "&&", "TARGET_FPU", ")", "*", "fpregs_p", "=", "1", ";", "else", "*", "intregs_p", "=", "1", ";", "if", "(", "packed_p", "&&", "DECL_PACKED", "(", "field", ")", ")", "*", "packed_p", "=", "1", ";", "}", "}", "}", "</s>" ]

[ "Scan", "the", "record", "type", "TYPE", "and", "return", "the", "following", "predicates", ":", "-", "INTREGS_P", ":", "the", "record", "contains", "at", "least", "one", "field", "or", "sub-field", "that", "is", "eligible", "for", "promotion", "in", "integer", "registers", ".", "-", "FP_REGS_P", ":", "the", "record", "contains", "at", "least", "one", "field", "or", "sub-field", "that", "is", "eligible", "for", "promotion", "in", "floating-point", "registers", ".", "-", "PACKED_P", ":", "the", "record", "contains", "at", "least", "one", "field", "that", "is", "packed", ".", "Sub-fields", "are", "not", "taken", "into", "account", "for", "the", "PACKED_P", "predicate", "." ]

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

[]

[ "<s>", "InstructionCost", "RISCVTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"getIntImmCost can only estimate cost of materialising integers\"", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "bool", "Takes12BitImm", "=", "false", ";", "unsigned", "ImmArgIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "case", "Instruction", "::", "GetElementPtr", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "And", ":", "if", "(", "Imm", "==", "UINT64_C", "(", "0xffff", ")", "&&", "ST", "->", "hasStdExtZbb", "(", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", "==", "UINT64_C", "(", "0xffffffff", ")", "&&", "ST", "->", "hasStdExtZbb", "(", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "Mul", ":", "Takes12BitImm", "=", "true", ";", "break", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "Takes12BitImm", "=", "true", ";", "ImmArgIdx", "=", "1", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "Takes12BitImm", ")", "{", "if", "(", "Instruction", "::", "isCommutative", "(", "Opcode", ")", "||", "Idx", "==", "ImmArgIdx", ")", "{", "if", "(", "Imm", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "getTLI", "(", ")", "->", "isLegalAddImmediate", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "{", "return", "TTI", "::", "TCC_Free", ";", "}", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "return", "TTI", "::", "TCC_Free", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "RISCV", "RISCV", "\"getIntImmCost can only estimate cost of materialising integers\"", "0", "0U", "0xffff", "0xffffffff", "1", "64" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCOFF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Collect LOH **********\\n\"", "<<", "\"Looking in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LOHInfo", "LOHInfos", "[", "N_GPR_REGS", "]", ";", "AArch64FunctionInfo", "&", "AFI", "=", "*", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "memset", "(", "LOHInfos", ",", "0", ",", "sizeof", "(", "LOHInfos", ")", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "{", "for", "(", "const", "auto", "&", "LI", ":", "Succ", "->", "liveins", "(", ")", ")", "{", "int", "RegIdx", "=", "mapRegToGPRIndex", "(", "LI", ".", "PhysReg", ")", ";", "if", "(", "RegIdx", ">=", "0", ")", "LOHInfos", "[", "RegIdx", "]", ".", "OneUser", "=", "true", ";", "}", "}", "for", "(", "const", "MachineInstr", "&", "MI", ":", "instructionsWithoutDebug", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ")", ")", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDRWui", ":", "if", "(", "canDefBePartOfLOH", "(", "MI", ")", ")", "{", "const", "MachineOperand", "&", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "Def", ".", "isReg", "(", ")", "&&", "Def", ".", "isDef", "(", ")", "&&", "\"Expected reg def\"", ")", ";", "assert", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "\"Expected reg use\"", ")", ";", "int", "DefIdx", "=", "mapRegToGPRIndex", "(", "Def", ".", "getReg", "(", ")", ")", ";", "int", "OpIdx", "=", "mapRegToGPRIndex", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "DefIdx", ">=", "0", "&&", "OpIdx", ">=", "0", "&&", "handleMiddleInst", "(", "MI", ",", "LOHInfos", "[", "DefIdx", "]", ",", "LOHInfos", "[", "OpIdx", "]", ")", ")", "continue", ";", "}", "break", ";", "case", "AArch64", "::", "ADRP", ":", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "int", "Idx", "=", "mapRegToGPRIndex", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "if", "(", "Idx", ">=", "0", ")", "{", "handleADRP", "(", "MI", ",", "AFI", ",", "LOHInfos", "[", "Idx", "]", ",", "LOHInfos", ")", ";", "continue", ";", "}", "break", ";", "}", "handleNormalInst", "(", "MI", ",", "LOHInfos", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Collect LOH **********\\n\"", "\"Looking in function \"", "AArch64", "AArch64", "0", "0", "AArch64::ADDXri", "AArch64::LDRXui", "AArch64::LDRWui", "0", "1", "\"Expected reg def\"", "\"Expected reg use\"", "0", "0", "AArch64::ADRP", "0", "0" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "struct", "constant_pool", "*", "s390_mainpool_start", "(", "void", ")", "{", "struct", "constant_pool", "*", "pool", ";", "rtx_insn", "*", "insn", ";", "pool", "=", "s390_alloc_pool", "(", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "1", ")", "==", "UNSPECV_MAIN_POOL", ")", "{", "if", "(", "pool", "->", "pool_insn", ")", "{", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "delete_insn", "(", "NEXT_INSN", "(", "insn", ")", ")", ";", "continue", ";", "}", "pool", "->", "pool_insn", "=", "insn", ";", "}", "if", "(", "!", "TARGET_CPU_ZARCH", "&&", "s390_execute_label", "(", "insn", ")", ")", "{", "s390_add_execute", "(", "pool", ",", "insn", ")", ";", "}", "else", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "||", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "pool_ref", "=", "NULL_RTX", ";", "find_constant_pool_ref", "(", "PATTERN", "(", "insn", ")", ",", "&", "pool_ref", ")", ";", "if", "(", "pool_ref", ")", "{", "rtx", "constant", "=", "get_pool_constant", "(", "pool_ref", ")", ";", "machine_mode", "mode", "=", "get_pool_mode", "(", "pool_ref", ")", ";", "s390_add_constant", "(", "pool", ",", "constant", ",", "mode", ")", ";", "}", "}", "if", "(", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_SWITCH_TEXT_SECTIONS", "&&", "!", "pool", "->", "emit_pool_after", ")", "pool", "->", "emit_pool_after", "=", "PREV_INSN", "(", "insn", ")", ";", "}", "gcc_assert", "(", "pool", "->", "pool_insn", "||", "pool", "->", "size", "==", "0", ")", ";", "if", "(", "pool", "->", "size", ">=", "4096", ")", "{", "remove_insn", "(", "pool", "->", "pool_insn", ")", ";", "s390_free_pool", "(", "pool", ")", ";", "pool", "=", "NULL", ";", "}", "if", "(", "pool", "&&", "!", "pool", "->", "emit_pool_after", ")", "pool", "->", "emit_pool_after", "=", "get_last_insn", "(", ")", ";", "return", "pool", ";", "}", "</s>" ]

[ "Collect", "main", "literal", "pool", ".", "Return", "NULL", "on", "overflow", "." ]

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

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "LEG" ]

[]

[ "<s>", "static", "rtx", "riscv_emit_binary", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "return", "riscv_emit_set", "(", "dest", ",", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "dest", ")", ",", "x", ",", "y", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "instruction", "of", "the", "form", "(", "set", "DEST", "(", "CODE", "X", "Y", ")", ")", "." ]

[ "riscv" ]

[]

[ "<s>", "int", "current_function_special_page_vector", "(", "rtx", "x", ")", "{", "int", "num", ";", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "&&", "(", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "SYMBOL_FLAG_FUNCVEC_FUNCTION", ")", ")", "{", "tree", "list", ";", "tree", "t", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "if", "(", "TREE_CODE", "(", "t", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "list", "=", "M32C_ATTRIBUTES", "(", "t", ")", ";", "while", "(", "list", ")", "{", "if", "(", "is_attribute_p", "(", "\"function_vector\"", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "{", "num", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "list", ")", ")", ")", ";", "return", "num", ";", "}", "list", "=", "TREE_CHAIN", "(", "list", ")", ";", "}", "return", "0", ";", "}", "else", "return", "0", ";", "}", "</s>" ]

[ "If", "the", "function", "is", "assigned", "the", "attribute", "'function_vector", "'", ",", "it", "returns", "the", "function", "vector", "number", ",", "otherwise", "returns", "zero", "." ]

[ "m32c", "0", "\"function_vector\"", "0", "0" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "{", "if", "(", "NextInstKind", "!=", "CurInstKind", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Instruction Type Switch\\n\"", ")", ";", "if", "(", "NextInstKind", "!=", "IDAlu", ")", "OccupedSlotsMask", "|=", "31", ";", "CurEmitted", "=", "0", ";", "CurInstKind", "=", "NextInstKind", ";", "}", "if", "(", "CurInstKind", "==", "IDAlu", ")", "{", "AluInstCount", "++", ";", "switch", "(", "getAluKind", "(", "SU", ")", ")", "{", "case", "AluT_XYZW", ":", "CurEmitted", "+=", "4", ";", "break", ";", "case", "AluDiscarded", ":", "break", ";", "default", ":", "{", "++", "CurEmitted", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "It", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_begin", "(", ")", ",", "E", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineOperand", "&", "MO", "=", "*", "It", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "R600", "::", "ALU_LITERAL_X", ")", "++", "CurEmitted", ";", "}", "}", "}", "}", "else", "{", "++", "CurEmitted", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "CurEmitted", "<<", "\" Instructions Emitted in this clause\\n\"", ")", ";", "if", "(", "CurInstKind", "!=", "IDFetch", ")", "{", "MoveUnits", "(", "Pending", "[", "IDFetch", "]", ",", "Available", "[", "IDFetch", "]", ")", ";", "}", "else", "FetchInstCount", "++", ";", "}", "</s>" ]

[ "ScheduleDAGMI", "has", "scheduled", "an", "instruction", "-", "tell", "HazardRec", "about", "it", "." ]

[ "AMDGPU", "R600", "\"Instruction Type Switch\\n\"", "31", "0", "4", "R600::ALU_LITERAL_X", "\" Instructions Emitted in this clause\\n\"" ]

[]

[ "<s>", "void", "emitZerofill", "(", "MCSection", "*", "Section", ",", "MCSymbol", "*", "Symbol", "=", "nullptr", ",", "uint64_t", "Size", "=", "0", ",", "unsigned", "ByteAlignment", "=", "0", ",", "SMLoc", "Loc", "=", "SMLoc", "(", ")", ")", "override", "{", "}", "</s>" ]

[ "Emit", "the", "zerofill", "section", "and", "an", "optional", "symbol", "." ]

[ "Patmos", "0", "0" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "is64bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "is64bit", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "make_unique", "<", "SparcELFTargetObjectFile", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "is64bit", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "ldsRequiresM0Init", "(", ")", "const", "{", "return", "getGeneration", "(", ")", "<", "GFX9", ";", "}", "</s>" ]

[ "Return", "if", "most", "LDS", "instructions", "have", "an", "m0", "use", "that", "require", "m0", "to", "be", "initialized", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "char", "*", "thumb1_unexpanded_epilogue", "(", "void", ")", "{", "arm_stack_offsets", "*", "offsets", ";", "int", "regno", ";", "unsigned", "long", "live_regs_mask", "=", "0", ";", "int", "high_regs_pushed", "=", "0", ";", "int", "extra_pop", ";", "int", "had_to_push_lr", ";", "int", "size", ";", "if", "(", "cfun", "->", "machine", "->", "return_used_this_function", "!=", "0", ")", "return", "\"\"", ";", "if", "(", "IS_NAKED", "(", "arm_current_func_type", "(", ")", ")", ")", "return", "\"\"", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "live_regs_mask", "=", "offsets", "->", "saved_regs_mask", ";", "high_regs_pushed", "=", "bit_count", "(", "live_regs_mask", "&", "0x0f00", ")", ";", "size", "=", "arm_size_return_regs", "(", ")", ";", "extra_pop", "=", "thumb1_extra_regs_pushed", "(", "offsets", ",", "false", ")", ";", "if", "(", "extra_pop", ">", "0", ")", "{", "unsigned", "long", "extra_mask", "=", "(", "1", "<<", "extra_pop", ")", "-", "1", ";", "live_regs_mask", "|=", "extra_mask", "<<", "ARM_NUM_INTS", "(", "size", ")", ";", "}", "if", "(", "high_regs_pushed", ")", "{", "unsigned", "long", "mask", "=", "live_regs_mask", "&", "0xff", ";", "int", "next_hi_reg", ";", "mask", "|=", "thumb1_epilogue_unused_call_clobbered_lo_regs", "(", ")", ";", "if", "(", "mask", "==", "0", ")", "internal_error", "(", "\"no low registers available for popping high registers\"", ")", ";", "for", "(", "next_hi_reg", "=", "12", ";", "next_hi_reg", ">", "LAST_LO_REGNUM", ";", "next_hi_reg", "--", ")", "if", "(", "live_regs_mask", "&", "(", "1", "<<", "next_hi_reg", ")", ")", "break", ";", "while", "(", "high_regs_pushed", ")", "{", "for", "(", "regno", "=", "LAST_LO_REGNUM", ";", "regno", ">=", "0", ";", "regno", "--", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "regno", ")", ")", "high_regs_pushed", "--", ";", "if", "(", "high_regs_pushed", "==", "0", ")", "break", ";", "}", "if", "(", "high_regs_pushed", "==", "0", "&&", "regno", ">=", "0", ")", "mask", "&=", "~", "(", "(", "1", "<<", "regno", ")", "-", "1", ")", ";", "thumb_pop", "(", "asm_out_file", ",", "mask", ")", ";", "for", "(", "regno", "=", "LAST_LO_REGNUM", ";", "regno", ">=", "0", ";", "regno", "--", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "regno", ")", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "next_hi_reg", ",", "regno", ")", ";", "for", "(", "next_hi_reg", "--", ";", "next_hi_reg", ">", "LAST_LO_REGNUM", ";", "next_hi_reg", "--", ")", "if", "(", "live_regs_mask", "&", "(", "1", "<<", "next_hi_reg", ")", ")", "break", ";", "}", "}", "}", "live_regs_mask", "&=", "~", "0x0f00", ";", "}", "had_to_push_lr", "=", "(", "live_regs_mask", "&", "(", "1", "<<", "LR_REGNUM", ")", ")", "!=", "0", ";", "live_regs_mask", "&=", "0xff", ";", "if", "(", "crtl", "->", "args", ".", "pretend_args_size", "==", "0", "||", "TARGET_BACKTRACE", ")", "{", "if", "(", "had_to_push_lr", ")", "live_regs_mask", "|=", "1", "<<", "PC_REGNUM", ";", "if", "(", "live_regs_mask", ")", "thumb_pop", "(", "asm_out_file", ",", "live_regs_mask", ")", ";", "if", "(", "!", "had_to_push_lr", ")", "thumb_exit", "(", "asm_out_file", ",", "LR_REGNUM", ")", ";", "}", "else", "{", "if", "(", "live_regs_mask", ")", "thumb_pop", "(", "asm_out_file", ",", "live_regs_mask", ")", ";", "if", "(", "had_to_push_lr", ")", "{", "if", "(", "size", ">", "12", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "IP_REGNUM", ",", "LAST_ARG_REGNUM", ")", ";", "}", "thumb_pop", "(", "asm_out_file", ",", "1", "<<", "LAST_ARG_REGNUM", ")", ";", "if", "(", "size", ">", "12", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "LR_REGNUM", ",", "LAST_ARG_REGNUM", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "LAST_ARG_REGNUM", ",", "IP_REGNUM", ")", ";", "regno", "=", "LR_REGNUM", ";", "}", "else", "regno", "=", "LAST_ARG_REGNUM", ";", "}", "else", "regno", "=", "LR_REGNUM", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tadd\\t%r, %r, #%d\\n\"", ",", "SP_REGNUM", ",", "SP_REGNUM", ",", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "thumb_exit", "(", "asm_out_file", ",", "regno", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "The", "bits", "which", "are", "n't", "usefully", "expanded", "as", "rtl", "." ]

[ "arm", "0", "0", "0", "\"\"", "\"\"", "0x0f00", "0", "1", "1", "0xff", "0", "\"no low registers available for popping high registers\"", "12", "1", "0", "1", "0", "0", "0", "1", "1", "0", "1", "\"\\tmov\\t%r, %r\\n\"", "1", "0x0f00", "1", "0", "0xff", "0", "1", "12", "\"\\tmov\\t%r, %r\\n\"", "1", "12", "\"\\tmov\\t%r, %r\\n\"", "\"\\tmov\\t%r, %r\\n\"", "\"\\tadd\\t%r, %r, #%d\\n\"", "\"\"" ]

[]

[ "<s>", "static", "int", "ix86_fp_cmp_code_to_pcmp_immediate", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "0x08", ";", "case", "NE", ":", "return", "0x04", ";", "case", "GT", ":", "return", "0x16", ";", "case", "LE", ":", "return", "0x1a", ";", "case", "GE", ":", "return", "0x15", ";", "case", "LT", ":", "return", "0x19", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Helper", "for", "ix86_cmp_code_to_pcmp_immediate", "for", "fp", "modes", "." ]

[ "i386", "0x08", "0x04", "0x16", "0x1a", "0x15", "0x19" ]

[]

[ "<s>", "bool", "FPGATTIImpl", "::", "isSourceOfDivergence", "(", "const", "Value", "*", "V", ")", "{", "if", "(", "const", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ")", "return", "!", "IsKernelFunction", "(", "*", "Arg", "->", "getParent", "(", ")", ")", ";", "if", "(", "const", "Instruction", "*", "I", "=", "dyn_cast", "<", "Instruction", ">", "(", "V", ")", ")", "{", "if", "(", "const", "LoadInst", "*", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "I", ")", ")", "{", "unsigned", "AS", "=", "LI", "->", "getPointerAddressSpace", "(", ")", ";", "return", "AS", "==", "0", ";", "}", "if", "(", "const", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "I", ")", ")", "{", "unsigned", "AS", "=", "AI", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "return", "AS", "==", "0", ";", "}", "if", "(", "I", "->", "isAtomic", "(", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "I", ")", ")", "{", "if", "(", "readsLocalId", "(", "II", ")", ")", "return", "true", ";", "if", "(", "readWorkgroupInvariant", "(", "II", ")", ")", "return", "false", ";", "if", "(", "isPureFunction", "(", "II", ")", ")", "return", "false", ";", "}", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "whether", "V", "is", "a", "source", "of", "divergence", "." ]

[ "FPGA", "FPGA", "0", "0" ]

[]

[ "<s>", "static", "int", "riscv_build_integer", "(", "struct", "riscv_integer_op", "*", "codes", ",", "HOST_WIDE_INT", "value", ",", "enum", "machine_mode", "mode", ")", "{", "int", "cost", "=", "riscv_build_integer_1", "(", "codes", ",", "value", ",", "mode", ")", ";", "if", "(", "value", ">", "0", "&&", "cost", ">", "2", ")", "{", "struct", "riscv_integer_op", "alt_codes", "[", "RISCV_MAX_INTEGER_OPS", "]", ";", "int", "alt_cost", ",", "shift", "=", "clz_hwi", "(", "value", ")", ";", "HOST_WIDE_INT", "shifted_val", ";", "shifted_val", "=", "(", "value", "<<", "shift", ")", "|", "(", "(", "(", "(", "HOST_WIDE_INT", ")", "1", ")", "<<", "shift", ")", "-", "1", ")", ";", "alt_cost", "=", "1", "+", "riscv_build_integer_1", "(", "alt_codes", ",", "shifted_val", ",", "mode", ")", ";", "if", "(", "alt_cost", "<", "cost", ")", "{", "alt_codes", "[", "alt_cost", "-", "1", "]", ".", "code", "=", "LSHIFTRT", ";", "alt_codes", "[", "alt_cost", "-", "1", "]", ".", "value", "=", "shift", ";", "memcpy", "(", "codes", ",", "alt_codes", ",", "sizeof", "(", "alt_codes", ")", ")", ";", "cost", "=", "alt_cost", ";", "}", "shifted_val", "=", "value", "<<", "shift", ";", "alt_cost", "=", "1", "+", "riscv_build_integer_1", "(", "alt_codes", ",", "shifted_val", ",", "mode", ")", ";", "if", "(", "alt_cost", "<", "cost", ")", "{", "alt_codes", "[", "alt_cost", "-", "1", "]", ".", "code", "=", "LSHIFTRT", ";", "alt_codes", "[", "alt_cost", "-", "1", "]", ".", "value", "=", "shift", ";", "memcpy", "(", "codes", ",", "alt_codes", ",", "sizeof", "(", "alt_codes", ")", ")", ";", "cost", "=", "alt_cost", ";", "}", "}", "return", "cost", ";", "}", "</s>" ]

[ "Fill", "CODES", "with", "a", "sequence", "of", "rtl", "operations", "to", "load", "VALUE", ".", "Return", "the", "number", "of", "operations", "needed", "." ]

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

[]

[ "<s>", "bool", "msp430_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "(", "mode1", "==", "PSImode", "||", "mode2", "==", "SImode", ")", "||", "(", "mode1", "==", "SImode", "||", "mode2", "==", "PSImode", ")", ")", "return", "false", ";", "return", "(", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_COMPLEX_FLOAT", ")", "==", "(", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_COMPLEX_FLOAT", ")", ")", ";", "}", "</s>" ]

[ "Implements", "MODES_TIEABLE_P", "." ]

[ "msp430" ]

[]

[ "<s>", "bool", "Z80TargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "isVarArg", ",", "Type", "*", "RetTy", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "*", "CallerF", "=", "MF", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", "->", "getCallingConv", "(", ")", ";", "if", "(", "CalleeCC", "!=", "CallingConv", "::", "C", "||", "CallerCC", "!=", "CallingConv", "::", "C", ")", "return", "false", ";", "LLVMContext", "&", "C", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "if", "(", "!", "CCState", "::", "resultsCompatible", "(", "CalleeCC", ",", "CallerCC", ",", "MF", ",", "C", ",", "Ins", ",", "RetCC_Z80_C", ",", "RetCC_Z80_C", ")", ")", "return", "false", ";", "if", "(", "!", "Outs", ".", "empty", "(", ")", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CalleeCC", ",", "isVarArg", ",", "MF", ",", "ArgLocs", ",", "C", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "getCCAssignFn", "(", "CalleeCC", ")", ")", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ")", "return", "false", ";", "if", "(", "VA", ".", "isMemLoc", "(", ")", "&&", "!", "MatchingStackOffset", "(", "Arg", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "Flags", ",", "MFI", ",", "MRI", ",", "TII", ")", ")", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

[ "Z80", "Z80", "ISD::OutputArg", "ISD::InputArg", "Z80", "Z80", "16", "0", "ISD::ArgFlagsTy" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineLocation", "DstML", ",", "SrcML", ";", "TII", ".", "makeFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "I", "->", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "unsigned", "DReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Shrink-wrapping not yet supported\"", "Mips", "Mips", "0", "Mips::SP", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "assert", "(", "Cond", "[", "0", "]", ".", "isImm", "(", ")", "&&", "\"First entry in the cond vector not imm-val\"", ")", ";", "unsigned", "opcode", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "assert", "(", "get", "(", "opcode", ")", ".", "isBranch", "(", ")", "&&", "\"Should be a branching condition.\"", ")", ";", "if", "(", "isEndLoopN", "(", "opcode", ")", ")", "return", "true", ";", "unsigned", "NewOpcode", "=", "getInvertedPredicatedOpcode", "(", "opcode", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "NewOpcode", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "Hexagon", "Hexagon", "0", "\"First entry in the cond vector not imm-val\"", "0", "\"Should be a branching condition.\"", "0" ]

[]

[ "<s>", "LM32TargetLowering", "::", "ConstraintType", "LM32TargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "case", "'f'", ":", "return", "C_RegisterClass", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "LM32", "LM32", "LM32", "1", "0" ]

[]

[ "<s>", "const", "SparcRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "Mang", "=", "new", "Mangler", "(", "M", ",", "\"\"", ",", "TAI", "->", "getPrivateGlobalPrefix", "(", ")", ")", ";", "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", "false", ";", "}", "</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>", "void", "rs6000_expand_interleave", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "bool", "highp", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "unsigned", "i", ",", "high", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "vec_perm_builder", "perm", "(", "nelt", ",", "nelt", ",", "1", ")", ";", "high", "=", "(", "highp", "?", "0", ":", "nelt", "/", "2", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", "/", "2", ";", "i", "++", ")", "{", "perm", ".", "quick_push", "(", "i", "+", "high", ")", ";", "perm", ".", "quick_push", "(", "i", "+", "nelt", "+", "high", ")", ";", "}", "rs6000_do_expand_vec_perm", "(", "target", ",", "op0", ",", "op1", ",", "vmode", ",", "perm", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "interleave", "operation", "." ]

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

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "OperandMatchResultTy", "MINA32AsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "const", "AsmToken", "&", "Tok", "=", "getParser", "(", ")", ".", "getTok", "(", ")", ";", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "RegNo", "=", "matchRegisterName", "(", "lowerCase", ")", ";", "if", "(", "RegNo", "!=", "0", ")", "{", "return", "MatchOperand_Success", ";", "}", "}", "return", "MatchOperand_NoMatch", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "MINA32", "MINA32", "0" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ")", "{", "if", "(", "isa", "<", "VectorType", ">", "(", "DataTy", ")", "&&", "DataTy", "->", "getVectorNumElements", "(", ")", "==", "1", ")", "return", "false", ";", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "int", "DataWidth", "=", "isa", "<", "PointerType", ">", "(", "ScalarTy", ")", "?", "DL", ".", "getPointerSizeInBits", "(", ")", ":", "ScalarTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "(", "(", "DataWidth", "==", "32", "||", "DataWidth", "==", "64", ")", "&&", "ST", "->", "hasAVX", "(", ")", ")", "||", "(", "(", "DataWidth", "==", "8", "||", "DataWidth", "==", "16", ")", "&&", "ST", "->", "hasBWI", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "load", "." ]

[ "X86", "X86", "1", "32", "64", "8", "16" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "AArch64TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "GPR64commonRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "GPR32commonRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR32RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR64RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR128RegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR128_loRegClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AArch64", "::", "NZCV", ")", ",", "&", "AArch64", "::", "CCRRegClass", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Res", ";", "Res", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "!", "Res", ".", "second", ")", "{", "unsigned", "Size", "=", "Constraint", ".", "size", "(", ")", ";", "if", "(", "(", "Size", "==", "4", "||", "Size", "==", "5", ")", "&&", "Constraint", "[", "0", "]", "==", "'{'", "&&", "tolower", "(", "Constraint", "[", "1", "]", ")", "==", "'v'", "&&", "Constraint", "[", "Size", "-", "1", "]", "==", "'}'", ")", "{", "const", "std", "::", "string", "Reg", "=", "std", "::", "string", "(", "&", "Constraint", "[", "2", "]", ",", "&", "Constraint", "[", "Size", "-", "1", "]", ")", ";", "int", "RegNo", "=", "atoi", "(", "Reg", ".", "c_str", "(", ")", ")", ";", "if", "(", "RegNo", ">=", "0", "&&", "RegNo", "<=", "31", ")", "{", "Res", ".", "first", "=", "AArch64", "::", "FPR128RegClass", ".", "getRegister", "(", "RegNo", ")", ";", "Res", ".", "second", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "}", "}", "}", "return", "Res", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "AArch64", "AArch64", "1", "0", "64", "0U", "AArch64::GPR64commonRegClass", "0U", "AArch64::GPR32commonRegClass", "MVT::f32", "0U", "AArch64::FPR32RegClass", "64", "0U", "AArch64::FPR64RegClass", "128", "0U", "AArch64::FPR128RegClass", "128", "0U", "AArch64::FPR128_loRegClass", "\"{cc}\"", "AArch64::NZCV", "AArch64::CCRRegClass", "4", "5", "0", "1", "1", "2", "1", "0", "31", "AArch64::FPR128RegClass", "AArch64::FPR128RegClass" ]

[]

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

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

[ "PowerPC", "PPC", "PPC", "1", "0", "\"wc\"" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "!", "callingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "WebAssembly", "::", "ARGUMENTS", ")", ";", "for", "(", "const", "ISD", "::", "InputArg", "&", "In", ":", "Ins", ")", "{", "if", "(", "In", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isNest", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented nest arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last arguments\"", ")", ";", "InVals", ".", "push_back", "(", "In", ".", "Used", "?", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "In", ".", "VT", ",", "DAG", ".", "getTargetConstant", "(", "InVals", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ":", "DAG", ".", "getUNDEF", "(", "In", ".", "VT", ")", ")", ";", "MFI", "->", "addParam", "(", "In", ".", "VT", ")", ";", "}", "if", "(", "IsVarArg", ")", "{", "MVT", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "Register", "VarargVreg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "getRegClassFor", "(", "PtrVT", ")", ")", ";", "MFI", "->", "setVarargBufferVreg", "(", "VarargVreg", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VarargVreg", ",", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "PtrVT", ",", "DAG", ".", "getTargetConstant", "(", "Ins", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ")", ";", "MFI", "->", "addParam", "(", "PtrVT", ")", ";", "}", "SmallVector", "<", "MVT", ",", "4", ">", "Params", ";", "SmallVector", "<", "MVT", ",", "4", ">", "Results", ";", "computeSignatureVTs", "(", "MF", ".", "getFunction", "(", ")", ".", "getFunctionType", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ",", "DAG", ".", "getTarget", "(", ")", ",", "Params", ",", "Results", ")", ";", "for", "(", "MVT", "VT", ":", "Results", ")", "MFI", "->", "addResult", "(", "VT", ")", ";", "assert", "(", "MFI", "->", "getParams", "(", ")", ".", "size", "(", ")", "==", "Params", ".", "size", "(", ")", "&&", "std", "::", "equal", "(", "MFI", "->", "getParams", "(", ")", ".", "begin", "(", ")", ",", "MFI", "->", "getParams", "(", ")", ".", "end", "(", ")", ",", "Params", ".", "begin", "(", ")", ")", ")", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::InputArg", "\"WebAssembly doesn't support non-C calling conventions\"", "WebAssembly", "WebAssembly::ARGUMENTS", "ISD::InputArg", "\"WebAssembly hasn't implemented inalloca arguments\"", "\"WebAssembly hasn't implemented nest arguments\"", "\"WebAssembly hasn't implemented cons regs arguments\"", "\"WebAssembly hasn't implemented cons regs last arguments\"", "WebAssemblyISD::ARGUMENT", "MVT::i32", "WebAssemblyISD::ARGUMENT", "MVT::i32", "4", "4" ]

[]

[ "<s>", "static", "bool", "v850_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "TRUNCATE", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MINUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "LABEL_REF", ")", "{", "rtx_code_label", "*", "label", "=", "dyn_cast", "<", "rtx_code_label", "*", ">", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", ";", "if", "(", "label", "&&", "label", "->", "deleted", "(", ")", ")", "return", "true", ";", "}", "output_addr_const", "(", "file", ",", "x", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "When", "assemble_integer", "is", "used", "to", "emit", "the", "offsets", "for", "a", "switch", "table", "it", "can", "encounter", "(", "TRUNCATE", ":", "HI", "(", "MINUS", ":", "SI", "(", "LABEL_REF", ":", "SI", ")", "(", "LABEL_REF", ":", "SI", ")", ")", ")", ".", "output_addr_const", "will", "normally", "barf", "at", "this", ",", "but", "it", "is", "OK", "to", "omit", "the", "truncate", "and", "just", "emit", "the", "difference", "of", "the", "two", "labels", ".", "The", ".hword", "directive", "will", "automatically", "handle", "the", "truncation", "for", "us", ".", "Returns", "1", "if", "rtx", "was", "handled", ",", "0", "otherwise", "." ]

[ "v850", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "char", "*", "rs6000_offload_options", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "return", "xstrdup", "(", "\"-foffload-abi=lp64\"", ")", ";", "else", "return", "xstrdup", "(", "\"-foffload-abi=ilp32\"", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_OFFLOAD_OPTIONS", "hook", "." ]

[ "rs6000", "\"-foffload-abi=lp64\"", "\"-foffload-abi=ilp32\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function: \"", ";", "MF", ".", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "initialize", "(", "MF", ")", ";", "if", "(", "!", "collectISELInstructions", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"No ISEL instructions in this function\\n\"", ")", ";", "return", "false", ";", "}", "DumpISELInstructions", "(", ")", ";", "expandAndMergeISELs", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "\"Function: \"", "\"\\n\"", "\"No ISEL instructions in this function\\n\"" ]

[]

[ "<s>", "SDValue", "LEGTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "!", "isVarArg", "&&", "\"VarArg not supported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_LEG", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "assert", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "i32", "&&", "\"Only support MVT::i32 register passing\"", ")", ";", "const", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "LEG", "::", "GRRegsRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgIn", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgIn", ")", ";", "continue", ";", "}", "assert", "(", "VA", ".", "isMemLoc", "(", ")", "&&", "\"Can only pass arguments as either registers or via the stack\"", ")", ";", "const", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "const", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "EVT", "PtrTy", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "FIPtr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "PtrTy", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i32", "&&", "\"Only support passing arguments as i32\"", ")", ";", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "VA", ".", "getValVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIPtr", ",", "MachinePointerInfo", "(", ")", ")", ";", "InVals", ".", "push_back", "(", "Load", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "ISD::InputArg", "\"VarArg not supported\"", "16", "LEG", "MVT::i32", "\"Only support MVT::i32 register passing\"", "LEG::GRRegsRegClass", "\"Can only pass arguments as either registers or via the stack\"", "4", "MVT::i32", "\"Only support passing arguments as i32\"" ]

[]

[ "<s>", "void", "aarch64_expand_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "bval", ",", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ",", "x", ";", "machine_mode", "mode", ",", "cmp_mode", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "bval", "=", "operands", "[", "0", "]", ";", "rval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "operands", "[", "5", "]", ";", "mod_s", "=", "operands", "[", "6", "]", ";", "mod_f", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "cmp_mode", "=", "mode", ";", "if", "(", "INTVAL", "(", "mod_f", ")", "==", "MEMMODEL_ACQUIRE", "&&", "INTVAL", "(", "mod_s", ")", "==", "MEMMODEL_RELEASE", ")", "mod_s", "=", "GEN_INT", "(", "MEMMODEL_ACQ_REL", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "cmp_mode", "=", "SImode", ";", "rval", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "oldval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "oldval", ",", "true", ")", ";", "case", "SImode", ":", "case", "DImode", ":", "if", "(", "!", "aarch64_plus_operand", "(", "oldval", ",", "mode", ")", ")", "oldval", "=", "force_reg", "(", "cmp_mode", ",", "oldval", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "gen", "=", "gen_atomic_compare_and_swapqi_1", ";", "break", ";", "case", "HImode", ":", "gen", "=", "gen_atomic_compare_and_swaphi_1", ";", "break", ";", "case", "SImode", ":", "gen", "=", "gen_atomic_compare_and_swapsi_1", ";", "break", ";", "case", "DImode", ":", "gen", "=", "gen_atomic_compare_and_swapdi_1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ")", ")", ";", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "gen_lowpart", "(", "mode", ",", "rval", ")", ")", ";", "x", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_EQ", "(", "SImode", ",", "x", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "bval", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "compare", "and", "swap", "pattern", "." ]

[ "aarch64", "0", "1", "2", "3", "4", "5", "6", "7", "1" ]

[]

[ "<s>", "static", "const", "uint16_t", "*", "lookup", "(", "unsigned", "opcode", ",", "unsigned", "domain", ")", "{", "for", "(", "const", "uint16_t", "(", "&", "Row", ")", "[", "3", "]", ":", "ReplaceableInstrs", ")", "if", "(", "Row", "[", "domain", "-", "1", "]", "==", "opcode", ")", "return", "Row", ";", "return", "nullptr", ";", "}", "</s>" ]

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

[ "X86", "3", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SIInstrInfo", "::", "getRegClass", "(", "const", "MCInstrDesc", "&", "TID", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "OpNum", ">=", "TID", ".", "getNumOperands", "(", ")", ")", "return", "nullptr", ";", "auto", "RegClass", "=", "TID", ".", "OpInfo", "[", "OpNum", "]", ".", "RegClass", ";", "bool", "IsAllocatable", "=", "false", ";", "if", "(", "TID", ".", "TSFlags", "&", "(", "SIInstrFlags", "::", "DS", "|", "SIInstrFlags", "::", "FLAT", ")", ")", "{", "const", "int", "VDstIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "TID", ".", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "const", "int", "DataIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "TID", ".", "Opcode", ",", "(", "TID", ".", "TSFlags", "&", "SIInstrFlags", "::", "DS", ")", "?", "AMDGPU", "::", "OpName", "::", "data0", ":", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "if", "(", "DataIdx", "!=", "-", "1", ")", "{", "IsAllocatable", "=", "VDstIdx", "!=", "-", "1", "||", "AMDGPU", "::", "getNamedOperandIdx", "(", "TID", ".", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "data1", ")", "!=", "-", "1", ";", "}", "}", "return", "adjustAllocatableRegClass", "(", "ST", ",", "RI", ",", "MF", ".", "getRegInfo", "(", ")", ",", "TID", ",", "RegClass", ",", "IsAllocatable", ")", ";", "}", "</s>" ]

[ "Given", "a", "machine", "instruction", "descriptor", ",", "returns", "the", "register", "class", "constraint", "for", "OpNum", ",", "or", "NULL", "." ]

[ "AMDGPU", "SI", "SIInstrFlags::DS", "SIInstrFlags::FLAT", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "SIInstrFlags::DS", "AMDGPU::OpName", "AMDGPU::OpName", "1", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1" ]

[]

[ "<s>", "static", "void", "alpha_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "SWCR_STATUS_MASK", "=", "(", "0x3fUL", "<<", "17", ")", ";", "tree", "fenv_var", ",", "get_fpscr", ",", "set_fpscr", ",", "mask", ",", "ld_fenv", ",", "masked_fenv", ";", "tree", "new_fenv_var", ",", "reload_fenv", ",", "restore_fnenv", ";", "tree", "update_call", ",", "atomic_feraiseexcept", ",", "hold_fnclex", ";", "if", "(", "!", "TARGET_ABI_OSF", ")", "return", ";", "fenv_var", "=", "create_tmp_var_raw", "(", "long_unsigned_type_node", ")", ";", "get_fpscr", "=", "build_fn_decl", "(", "\"__ieee_get_fp_control\"", ",", "build_function_type_list", "(", "long_unsigned_type_node", ",", "NULL", ")", ")", ";", "set_fpscr", "=", "build_fn_decl", "(", "\"__ieee_set_fp_control\"", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL", ")", ")", ";", "mask", "=", "build_int_cst", "(", "long_unsigned_type_node", ",", "~", "SWCR_STATUS_MASK", ")", ";", "ld_fenv", "=", "build4", "(", "TARGET_EXPR", ",", "long_unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "0", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "masked_fenv", "=", "build2", "(", "BIT_AND_EXPR", ",", "long_unsigned_type_node", ",", "fenv_var", ",", "mask", ")", ";", "hold_fnclex", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "masked_fenv", ",", "ld_fenv", ")", ",", "hold_fnclex", ")", ";", "*", "clear", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "new_fenv_var", "=", "create_tmp_var_raw", "(", "long_unsigned_type_node", ")", ";", "reload_fenv", "=", "build4", "(", "TARGET_EXPR", ",", "long_unsigned_type_node", ",", "new_fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "0", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "restore_fnenv", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "fenv_var", ")", ";", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "update_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "fold_convert", "(", "integer_type_node", ",", "new_fenv_var", ")", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "reload_fenv", ",", "restore_fnenv", ")", ",", "update_call", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "." ]

[ "alpha", "0x3fUL", "17", "\"__ieee_get_fp_control\"", "\"__ieee_set_fp_control\"", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "void", "output_pop_multiple", "(", "rtx", "insn", ",", "rtx", "*", "operands", ")", "{", "char", "buf", "[", "80", "]", ";", "int", "ok", ";", "ok", "=", "analyze_pop_multiple_operation", "(", "PATTERN", "(", "insn", ")", ")", ";", "gcc_assert", "(", "ok", ")", ";", "if", "(", "first_dreg_to_save", "==", "8", ")", "sprintf", "(", "buf", ",", "\"( p5:%d ) = [sp++];\\n\"", ",", "first_preg_to_save", ")", ";", "else", "if", "(", "first_preg_to_save", "==", "6", ")", "sprintf", "(", "buf", ",", "\"( r7:%d ) = [sp++];\\n\"", ",", "first_dreg_to_save", ")", ";", "else", "sprintf", "(", "buf", ",", "\"( r7:%d, p5:%d ) = [sp++];\\n\"", ",", "first_dreg_to_save", ",", "first_preg_to_save", ")", ";", "output_asm_insn", "(", "buf", ",", "operands", ")", ";", "}", "</s>" ]

[ "Emit", "assembly", "code", "for", "one", "multi-register", "pop", "described", "by", "INSN", ",", "with", "operands", "in", "OPERANDS", "." ]

[ "bfin", "80", "8", "\"( p5:%d ) = [sp++];\\n\"", "6", "\"( r7:%d ) = [sp++];\\n\"", "\"( r7:%d, p5:%d ) = [sp++];\\n\"" ]

[]

[ "<s>", "uint64_t", "MipsAbiFlags", "::", "size", "(", ")", "{", "return", "sizeof", "(", "ElfMipsAbiFlags", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

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

[]

[ "<s>", "void", "R600MCCodeEmitter", "::", "Emit", "(", "uint64_t", "Value", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "{", "EmitByte", "(", "(", "Value", ">>", "(", "8", "*", "i", ")", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "</s>" ]

[ "Emit", "-", "Top", "level", "entry", "point", "." ]

[ "R600", "0", "8", "8", "0xff" ]

[]

[ "<s>", "bool", "memreg_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "MEM_P", "(", "op", ")", "&&", "REG_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "(", "mem", "(", "reg", "...", ")", ")", ".", "This", "is", "used", "in", "insn", "length", "calcs", "." ]

[ "m32r", "0" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "AArch64Operand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_FPImm", ":", "OS", "<<", "\"<fpimm \"", "<<", "getFPImm", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ";", "if", "(", "!", "getFPImmIsExact", "(", ")", ")", "OS", "<<", "\" (inexact)\"", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Barrier", ":", "{", "StringRef", "Name", "=", "getBarrierName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<barrier \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<barrier invalid #\"", "<<", "getBarrier", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "k_ShiftedImm", ":", "{", "unsigned", "Shift", "=", "getShiftedImmShift", "(", ")", ";", "OS", "<<", "\"<shiftedimm \"", ";", "OS", "<<", "*", "getShiftedImmVal", "(", ")", ";", "OS", "<<", "\", lsl #\"", "<<", "AArch64_AM", "::", "getShiftValue", "(", "Shift", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_CondCode", ":", "OS", "<<", "\"<condcode \"", "<<", "getCondCode", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_VectorList", ":", "{", "OS", "<<", "\"<vectorlist \"", ";", "unsigned", "Reg", "=", "getVectorListStart", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "getVectorListCount", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "OS", "<<", "Reg", "+", "i", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "}", "case", "k_VectorIndex", ":", "OS", "<<", "\"<vectorindex \"", "<<", "getVectorIndex", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_SysReg", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "k_SysCR", ":", "OS", "<<", "\"c\"", "<<", "getSysCR", "(", ")", ";", "break", ";", "case", "k_Prefetch", ":", "{", "StringRef", "Name", "=", "getPrefetchName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<prfop \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<prfop invalid #\"", "<<", "getPrefetch", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_PSBHint", ":", "OS", "<<", "getPSBHintName", "(", ")", ";", "break", ";", "case", "k_BTIHint", ":", "OS", "<<", "getBTIHintName", "(", ")", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "if", "(", "!", "getShiftExtendAmount", "(", ")", "&&", "!", "hasShiftExtendAmount", "(", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "k_ShiftExtend", ":", "OS", "<<", "\"<\"", "<<", "AArch64_AM", "::", "getShiftExtendName", "(", "getShiftExtendType", "(", ")", ")", "<<", "\" #\"", "<<", "getShiftExtendAmount", "(", ")", ";", "if", "(", "!", "hasShiftExtendAmount", "(", ")", ")", "OS", "<<", "\"<imp>\"", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"<fpimm \"", "\" (inexact)\"", "\">\"", "\"<barrier \"", "\">\"", "\"<barrier invalid #\"", "\">\"", "\"<shiftedimm \"", "\", lsl #\"", "AArch64_AM::getShiftValue", "\">\"", "\"<condcode \"", "\">\"", "\"<vectorlist \"", "0", "\" \"", "\">\"", "\"<vectorindex \"", "\">\"", "\"<sysreg: \"", "\"'\"", "\"'\"", "\"c\"", "\"<prfop \"", "\">\"", "\"<prfop invalid #\"", "\">\"", "\"<register \"", "\">\"", "\"<\"", "AArch64_AM::getShiftExtendName", "\" #\"", "\"<imp>\"" ]

[]

[ "<s>", "static", "bool", "optimizeCall", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "MachineDominatorTree", "&", "MDT", ",", "LiveIntervals", "&", "LIS", ",", "const", "WebAssemblyTargetLowering", "&", "TLI", ",", "const", "TargetLibraryInfo", "&", "LibInfo", ")", "{", "MachineOperand", "&", "Op1", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "Op1", ".", "isSymbol", "(", ")", ")", "return", "false", ";", "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "bool", "CallReturnsInput", "=", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ";", "if", "(", "!", "CallReturnsInput", ")", "return", "false", ";", "LibFunc", "Func", ";", "if", "(", "!", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "return", "false", ";", "Register", "FromReg", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "Register", "ToReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FromReg", ")", "!=", "MRI", ".", "getRegClass", "(", "ToReg", ")", ")", "report_fatal_error", "(", "\"Memory Intrinsic results: call to builtin function \"", "\"with wrong signature, from/to mismatch\"", ")", ";", "return", "replaceDominatedUses", "(", "MBB", ",", "MI", ",", "FromReg", ",", "ToReg", ",", "MRI", ",", "MDT", ",", "LIS", ")", ";", "}", "</s>" ]

[ "optimizeCall", "-", "Take", "the", "given", "call", "instruction", "and", "return", "a", "more", "optimal", "value", "to", "replace", "the", "instruction", "with", "or", "0", "if", "a", "more", "optimal", "form", "ca", "n't", "be", "found", "." ]

[ "WebAssembly", "WebAssembly", "1", "2", "0", "\"Memory Intrinsic results: call to builtin function \"", "\"with wrong signature, from/to mismatch\"" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vuzp", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "odd", ",", "mask", ",", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "rtx", "out0", ",", "out1", ",", "in0", ",", "in1", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "first_elem", ";", "int", "swap_nelt", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ">=", "8", ")", "return", "false", ";", "swap_nelt", "=", "BYTES_BIG_ENDIAN", "&&", "!", "d", "->", "one_vector_p", "&&", "GET_MODE_SIZE", "(", "d", "->", "vmode", ")", "==", "8", "?", "nelt", ":", "0", ";", "first_elem", "=", "d", "->", "perm", "[", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "0", ")", "]", "^", "swap_nelt", ";", "if", "(", "first_elem", "==", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "0", ")", ")", "odd", "=", "0", ";", "else", "if", "(", "first_elem", "==", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "1", ")", ")", "odd", "=", "1", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "(", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "i", ")", "*", "2", "+", "odd", ")", "&", "mask", ";", "if", "(", "(", "d", "->", "perm", "[", "i", "]", "^", "swap_nelt", ")", "!=", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "elt", ")", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "gen", "=", "gen_neon_vuzpv16qi_internal", ";", "break", ";", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vuzpv8qi_internal", ";", "break", ";", "case", "E_V8HImode", ":", "gen", "=", "gen_neon_vuzpv8hi_internal", ";", "break", ";", "case", "E_V4HImode", ":", "gen", "=", "gen_neon_vuzpv4hi_internal", ";", "break", ";", "case", "E_V8HFmode", ":", "gen", "=", "gen_neon_vuzpv8hf_internal", ";", "break", ";", "case", "E_V4HFmode", ":", "gen", "=", "gen_neon_vuzpv4hf_internal", ";", "break", ";", "case", "E_V4SImode", ":", "gen", "=", "gen_neon_vuzpv4si_internal", ";", "break", ";", "case", "E_V2SImode", ":", "gen", "=", "gen_neon_vuzpv2si_internal", ";", "break", ";", "case", "E_V2SFmode", ":", "gen", "=", "gen_neon_vuzpv2sf_internal", ";", "break", ";", "case", "E_V4SFmode", ":", "gen", "=", "gen_neon_vuzpv4sf_internal", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "swap_nelt", "!=", "0", ")", "std", "::", "swap", "(", "in0", ",", "in1", ")", ";", "out0", "=", "d", "->", "target", ";", "out1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "if", "(", "odd", ")", "std", "::", "swap", "(", "out0", ",", "out1", ")", ";", "emit_insn", "(", "gen", "(", "out0", ",", "in0", ",", "in1", ",", "out1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "cris_side_effect_mode_ok", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "ops", ",", "int", "lreg", ",", "int", "rreg", ",", "int", "rval", ",", "int", "multop", ",", "int", "other_op", ")", "{", "int", "mult", "=", "multop", "<", "0", "?", "1", ":", "INTVAL", "(", "ops", "[", "multop", "]", ")", ";", "rtx", "reg_rtx", "=", "ops", "[", "rreg", "]", ";", "rtx", "val_rtx", "=", "ops", "[", "rval", "]", ";", "if", "(", "!", "cris_base_p", "(", "reg_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "reg_rtx", "=", "val_rtx", ",", "val_rtx", "=", "ops", "[", "rreg", "]", ";", "if", "(", "!", "cris_base_p", "(", "reg_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "0", ";", "if", "(", "!", "TARGET_SIDE_EFFECT_PREFIXES", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "MULT", ")", "{", "mult", "=", "INTVAL", "(", "XEXP", "(", "val_rtx", ",", "1", ")", ")", ";", "val_rtx", "=", "XEXP", "(", "val_rtx", ",", "0", ")", ";", "code", "=", "MULT", ";", "}", "if", "(", "other_op", ">=", "0", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "ops", "[", "other_op", "]", ")", ")", ">", "UNITS_PER_WORD", ")", "return", "0", ";", "if", "(", "(", "cris_base_p", "(", "ops", "[", "lreg", "]", ",", "reload_in_progress", "||", "reload_completed", ")", "&&", "cris_base_p", "(", "ops", "[", "other_op", "]", ",", "reload_in_progress", "||", "reload_completed", ")", "&&", "REGNO", "(", "ops", "[", "lreg", "]", ")", "==", "REGNO", "(", "ops", "[", "other_op", "]", ")", ")", "||", "rtx_equal_p", "(", "ops", "[", "other_op", "]", ",", "ops", "[", "lreg", "]", ")", ")", "return", "0", ";", "}", "if", "(", "ops", "[", "lreg", "]", "==", "frame_pointer_rtx", "||", "ops", "[", "rreg", "]", "==", "frame_pointer_rtx", "||", "ops", "[", "rval", "]", "==", "frame_pointer_rtx", "||", "(", "other_op", ">=", "0", "&&", "ops", "[", "other_op", "]", "==", "frame_pointer_rtx", ")", ")", "return", "0", ";", "if", "(", "code", "==", "PLUS", "&&", "!", "cris_base_p", "(", "val_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "reg_rtx", ")", "&&", "CONST_INT_P", "(", "val_rtx", ")", "&&", "(", "INTVAL", "(", "val_rtx", ")", "<=", "63", "&&", "INTVAL", "(", "val_rtx", ")", ">=", "-", "63", ")", ")", "return", "0", ";", "if", "(", "CONSTANT_P", "(", "val_rtx", ")", ")", "return", "1", ";", "if", "(", "MEM_P", "(", "val_rtx", ")", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "SIGN_EXTEND", "&&", "MEM_P", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ")", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ",", "0", ")", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "1", ";", "return", "0", ";", "}", "else", "if", "(", "code", "==", "MULT", "||", "(", "code", "==", "PLUS", "&&", "cris_base_p", "(", "val_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "reg_rtx", ")", "||", "(", "mult", "==", "1", "&&", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "val_rtx", ")", ")", ")", "return", "0", ";", "if", "(", "mult", "!=", "1", "&&", "mult", "!=", "2", "&&", "mult", "!=", "4", ")", "return", "0", ";", "if", "(", "!", "cris_base_p", "(", "reg_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "0", ";", "return", "1", ";", "}", "internal_error", "(", "\"internal error: cris_side_effect_mode_ok with bad operands\"", ")", ";", "}", "</s>" ]

[ "Check", "various", "objections", "to", "the", "side-effect", ".", "Used", "in", "the", "test-part", "of", "an", "anonymous", "insn", "describing", "an", "insn", "with", "a", "possible", "side-effect", ".", "Returns", "nonzero", "if", "the", "implied", "side-effect", "is", "ok.", "code", ":", "PLUS", "or", "MULT", "ops", ":", "An", "array", "of", "rtx", ":", "es", ".", "lreg", ",", "rreg", ",", "rval", ",", "The", "variables", "multop", "and", "other_op", "are", "indexes", "into", "this", ",", "or", "-1", "if", "they", "are", "not", "applicable", ".", "lreg", ":", "The", "register", "that", "gets", "assigned", "in", "the", "side-effect", ".", "rreg", ":", "One", "register", "in", "the", "side-effect", "expression", "rval", ":", "The", "other", "register", ",", "or", "an", "int", ".", "multop", ":", "An", "integer", "to", "multiply", "rval", "with", ".", "other_op", ":", "One", "of", "the", "entities", "of", "the", "main", "effect", ",", "whose", "mode", "we", "must", "consider", "." ]

[ "cris", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0", "0", "63", "63", "0", "1", "0", "1", "0", "0", "0", "1", "0", "1", "0", "1", "2", "4", "0", "0", "1", "\"internal error: cris_side_effect_mode_ok with bad operands\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARMFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "DebugLoc", "dl", "=", "Old", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignSPAdjust", "(", "Amount", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This eliminateCallFramePseudoInstr does not support Thumb1!\"", ")", ";", "bool", "isARM", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", ";", "unsigned", "Opc", "=", "Old", "->", "getOpcode", "(", ")", ";", "int", "PIdx", "=", "Old", "->", "findFirstPredOperandIdx", "(", ")", ";", "ARMCC", "::", "CondCodes", "Pred", "=", "(", "PIdx", "==", "-", "1", ")", "?", "ARMCC", "::", "AL", ":", "(", "ARMCC", "::", "CondCodes", ")", "Old", "->", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "unsigned", "PredReg", "=", "Old", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "-", "Amount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "else", "{", "unsigned", "PredReg", "=", "Old", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "Amount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "0", "0", "ARM", "ARM", "\"This eliminateCallFramePseudoInstr does not support Thumb1!\"", "ARM", "ARMCC::CondCodes", "1", "ARMCC::AL", "ARMCC::CondCodes", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "2", "ARM", "3", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP", "ARM" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "Optional", "<", "unsigned", ">", "FirstMaskArgument", ";", "if", "(", "Subtarget", ".", "hasStdExtV", "(", ")", ")", "FirstMaskArgument", "=", "preAssignMask", "(", "Outs", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Outs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MVT", "VT", "=", "Outs", "[", "i", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "RISCVABI", "::", "ABI", "ABI", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getTargetABI", "(", ")", ";", "if", "(", "CC_RISCV", "(", "MF", ".", "getDataLayout", "(", ")", ",", "ABI", ",", "i", ",", "VT", ",", "VT", ",", "CCValAssign", "::", "Full", ",", "ArgFlags", ",", "CCInfo", ",", "true", ",", "true", ",", "nullptr", ",", "*", "this", ",", "FirstMaskArgument", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "ISD::OutputArg", "16", "0", "ISD::ArgFlagsTy", "RISCVABI::ABI", "RISCV", "RISCV" ]

[]

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

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

[ "Kudeyar", "Kudeyar" ]

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "isLabel", "(", "AsmToken", "&", "Token", ")", "{", "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "AsmToken", "const", "&", "Second", "=", "Lexer", ".", "getTok", "(", ")", ";", "AsmToken", "Third", "=", "Lexer", ".", "peekTok", "(", ")", ";", "StringRef", "String", "=", "Token", ".", "getString", "(", ")", ";", "if", "(", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "LCurly", ")", "||", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "RCurly", ")", ")", "return", "false", ";", "if", "(", "!", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "Identifier", ")", ")", "return", "true", ";", "if", "(", "!", "MatchRegisterName", "(", "String", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "(", "void", ")", "Second", ";", "assert", "(", "Second", ".", "is", "(", "AsmToken", "::", "Colon", ")", ")", ";", "StringRef", "Raw", "(", "String", ".", "data", "(", ")", ",", "Third", ".", "getString", "(", ")", ".", "data", "(", ")", "-", "String", ".", "data", "(", ")", "+", "Third", ".", "getString", "(", ")", ".", "size", "(", ")", ")", ";", "std", "::", "string", "Collapsed", "=", "Raw", ";", "Collapsed", ".", "erase", "(", "std", "::", "remove_if", "(", "Collapsed", ".", "begin", "(", ")", ",", "Collapsed", ".", "end", "(", ")", ",", "isspace", ")", ",", "Collapsed", ".", "end", "(", ")", ")", ";", "StringRef", "Whole", "=", "Collapsed", ";", "std", "::", "pair", "<", "StringRef", ",", "StringRef", ">", "DotSplit", "=", "Whole", ".", "split", "(", "'.'", ")", ";", "if", "(", "!", "MatchRegisterName", "(", "DotSplit", ".", "first", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "MachineInstr", "represents", "a", "label", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "pre_incdec_with_reg", "(", "rtx", "op", ",", "unsigned", "int", "reg", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PRE_DEC", "&&", "GET_CODE", "(", "op", ")", "!=", "PRE_INC", ")", "return", "false", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "op", ")", ")", "return", "false", ";", "return", "REGNO", "(", "op", ")", "==", "reg", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "a", "PRE_INC", "or", "PRE_DEC", "instruction", "using", "REG", ",", "FALSE", "otherwise", "." ]

[ "h8300", "0", "0" ]

[]

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

[ "Handle", "TARGET_FUNCTION_VALUE_REGNO_P", ".", "We", "always", "return", "values", "in", "register", "$", "r0", "for", "moxie", "." ]

[ "moxie" ]

[]

[ "<s>", "unsigned", "int", "rs6000_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "type", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", "||", "(", "TARGET_HARD_FLOAT", "&&", "!", "is_complex_IBM_long_double", "(", "mode", ")", "&&", "FLOAT128_2REG_P", "(", "mode", ")", ")", ")", ")", "return", "64", ";", "else", "if", "(", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "return", "128", ";", "else", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "8", "&&", "int_size_in_bytes", "(", "type", ")", "<", "16", ")", "return", "64", ";", "else", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "elt_mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "16", ")", ")", "return", "128", ";", "if", "(", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "&&", "!", "rs6000_compat_align_parm", ")", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "!", "SCALAR_FLOAT_MODE_P", "(", "elt_mode", ")", ")", "return", "128", ";", "}", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_abi", "&&", "mode", "==", "BLKmode", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "return", "128", ";", "return", "PARM_BOUNDARY", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "expression", "that", "gives", "the", "alignment", "boundary", ",", "in", "bits", ",", "of", "an", "argument", "with", "the", "specified", "mode", "and", "type", ".", "If", "it", "is", "not", "defined", ",", "PARM_BOUNDARY", "is", "used", "for", "all", "arguments", ".", "V.4", "wants", "long", "longs", "and", "doubles", "to", "be", "double", "word", "aligned", ".", "Just", "testing", "the", "mode", "size", "is", "a", "boneheaded", "way", "to", "do", "this", "as", "it", "means", "that", "other", "types", "such", "as", "complex", "int", "are", "also", "double", "word", "aligned", ".", "However", ",", "we", "'re", "stuck", "with", "this", "because", "changing", "the", "ABI", "might", "break", "existing", "library", "interfaces", ".", "Quadword", "align", "Altivec/VSX", "vectors", ".", "Quadword", "align", "large", "synthetic", "vector", "types", "." ]

[ "rs6000", "8", "64", "128", "8", "16", "64", "16", "128", "64", "128", "64", "128" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "split", "(", "MachineInstr", "&", "MI", ",", "std", "::", "set", "<", "unsigned", ">", "&", "UpdRegs", ")", "{", "if", "(", "TfrLimitActive", ")", "{", "if", "(", "TfrCounter", ">=", "TfrLimit", ")", "return", "false", ";", "TfrCounter", "++", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nsplitting \"", "<<", "printMBBReference", "(", "*", "MI", ".", "getParent", "(", ")", ")", "<<", "\": \"", "<<", "MI", ")", ";", "MachineOperand", "&", "MD", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "MP", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "MD", ".", "isDef", "(", ")", ")", ";", "unsigned", "DR", "=", "MD", ".", "getReg", "(", ")", ",", "DSR", "=", "MD", ".", "getSubReg", "(", ")", ";", "bool", "ReadUndef", "=", "MD", ".", "isUndef", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "At", "=", "MI", ";", "auto", "updateRegs", "=", "[", "&", "UpdRegs", "]", "(", "const", "MachineInstr", "&", "MI", ")", "->", "void", "{", "for", "(", "auto", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "Op", ".", "isReg", "(", ")", ")", "UpdRegs", ".", "insert", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", ";", "MachineOperand", "&", "ST", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "MachineOperand", "&", "SF", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "if", "(", "ST", ".", "isReg", "(", ")", "&&", "SF", ".", "isReg", "(", ")", ")", "{", "RegisterRef", "RT", "(", "ST", ")", ";", "if", "(", "RT", "==", "RegisterRef", "(", "SF", ")", ")", "{", "updateRegs", "(", "MI", ")", ";", "MI", ".", "setDesc", "(", "HII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ";", "unsigned", "S", "=", "getRegState", "(", "ST", ")", ";", "while", "(", "MI", ".", "getNumOperands", "(", ")", ">", "1", ")", "MI", ".", "RemoveOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "1", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstrBuilder", "(", "MF", ",", "MI", ")", ".", "addReg", "(", "RT", ".", "Reg", ",", "S", ",", "RT", ".", "Sub", ")", ";", "return", "true", ";", "}", "}", "MachineInstr", "*", "TfrT", "=", "genCondTfrFor", "(", "ST", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "true", ",", "ReadUndef", ",", "false", ")", ";", "MachineInstr", "*", "TfrF", "=", "genCondTfrFor", "(", "SF", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "false", ",", "ReadUndef", ",", "true", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrT", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrF", ")", ";", "updateRegs", "(", "MI", ")", ";", "removeInstr", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Split", "into", "substrings", "around", "the", "occurrences", "of", "a", "separator", "character", "." ]

[ "Hexagon", "Hexagon", "\"\\nsplitting \"", "\": \"", "0", "1", "2", "3", "1", "1" ]

[]

[ "<s>", "inline", "set_of_reg", "sh_find_set_of_reg", "(", "rtx", "reg", ",", "rtx_insn", "*", "insn", ",", "F", "stepfunc", ",", "bool", "ignore_reg_reg_copies", "=", "false", ")", "{", "set_of_reg", "result", ";", "result", ".", "insn", "=", "insn", ";", "result", ".", "set_rtx", "=", "NULL_RTX", ";", "result", ".", "set_src", "=", "NULL_RTX", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "insn", "==", "NULL_RTX", ")", "return", "result", ";", "rtx_insn", "*", "previnsn", "=", "insn", ";", "for", "(", "result", ".", "insn", "=", "stepfunc", "(", "insn", ")", ";", "result", ".", "insn", "!=", "NULL_RTX", ";", "previnsn", "=", "result", ".", "insn", ",", "result", ".", "insn", "=", "stepfunc", "(", "result", ".", "insn", ")", ")", "{", "if", "(", "BARRIER_P", "(", "result", ".", "insn", ")", ")", "break", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "result", ".", "insn", ")", ")", "continue", ";", "if", "(", "reg_set_p", "(", "reg", ",", "result", ".", "insn", ")", ")", "{", "result", ".", "set_rtx", "=", "set_of", "(", "reg", ",", "result", ".", "insn", ")", ";", "if", "(", "result", ".", "set_rtx", "==", "NULL_RTX", "||", "GET_CODE", "(", "result", ".", "set_rtx", ")", "!=", "SET", ")", "break", ";", "result", ".", "set_src", "=", "XEXP", "(", "result", ".", "set_rtx", ",", "1", ")", ";", "if", "(", "ignore_reg_reg_copies", "&&", "REG_P", "(", "result", ".", "set_src", ")", ")", "{", "reg", "=", "result", ".", "set_src", ";", "continue", ";", "}", "if", "(", "ignore_reg_reg_copies", "&&", "SUBREG_P", "(", "result", ".", "set_src", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "result", ".", "set_src", ")", ")", ")", "{", "reg", "=", "SUBREG_REG", "(", "result", ".", "set_src", ")", ";", "continue", ";", "}", "break", ";", "}", "}", "if", "(", "result", ".", "insn", "==", "NULL", ")", "result", ".", "insn", "=", "previnsn", ";", "if", "(", "result", ".", "set_src", "!=", "NULL", ")", "gcc_assert", "(", "result", ".", "insn", "!=", "NULL", "&&", "result", ".", "set_rtx", "!=", "NULL", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Given", "a", "reg", "rtx", "and", "a", "start", "insn", ",", "try", "to", "find", "the", "insn", "that", "sets", "the", "specified", "reg", "by", "using", "the", "specified", "insn", "stepping", "function", ",", "such", "as", "'prev_nonnote_insn_bb", "'", ".", "When", "the", "insn", "is", "found", ",", "try", "to", "extract", "the", "rtx", "of", "the", "reg", "set", "." ]

[ "sh", "1" ]

[]

[ "<s>", "static", "rtx", "ix86_static_chain", "(", "const_tree", "fndecl_or_type", ",", "bool", "incoming_p", ")", "{", "unsigned", "regno", ";", "if", "(", "TARGET_64BIT", ")", "{", "regno", "=", "R10_REG", ";", "}", "else", "{", "const_tree", "fntype", ",", "fndecl", ";", "unsigned", "int", "ccvt", ";", "regno", "=", "CX_REG", ";", "if", "(", "TREE_CODE", "(", "fndecl_or_type", ")", "==", "FUNCTION_DECL", ")", "{", "fntype", "=", "TREE_TYPE", "(", "fndecl_or_type", ")", ";", "fndecl", "=", "fndecl_or_type", ";", "}", "else", "{", "fntype", "=", "fndecl_or_type", ";", "fndecl", "=", "NULL", ";", "}", "ccvt", "=", "ix86_get_callcvt", "(", "fntype", ")", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "{", "regno", "=", "AX_REG", ";", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "0", ")", "{", "regno", "=", "AX_REG", ";", "}", "else", "if", "(", "ix86_function_regparm", "(", "fntype", ",", "fndecl", ")", "==", "3", ")", "{", "if", "(", "incoming_p", ")", "{", "if", "(", "fndecl", "==", "current_function_decl", "&&", "!", "ix86_static_chain_on_stack", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "ix86_static_chain_on_stack", "=", "true", ";", "}", "return", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "-", "8", ")", ")", ";", "}", "regno", "=", "SI_REG", ";", "}", "}", "return", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Find", "a", "location", "for", "the", "static", "chain", "incoming", "to", "a", "nested", "function", ".", "This", "is", "a", "register", ",", "unless", "all", "free", "registers", "are", "used", "by", "arguments", "." ]

[ "i386", "0", "0", "3", "8" ]

[]

[ "<s>", "SDValue", "LanaiSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", ",", "const", "SDLoc", "&", ",", "SDValue", ",", "SDValue", ",", "SDValue", ",", "SDValue", "Size", ",", "unsigned", ",", "bool", ",", "bool", ",", "MachinePointerInfo", ",", "MachinePointerInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "void", "nvptx_expand_call", "(", "rtx", "retval", ",", "rtx", "address", ")", "{", "rtx", "callee", "=", "XEXP", "(", "address", ",", "0", ")", ";", "rtx", "varargs", "=", "NULL_RTX", ";", "unsigned", "parallel", "=", "0", ";", "if", "(", "!", "call_insn_operand", "(", "callee", ",", "Pmode", ")", ")", "{", "callee", "=", "force_reg", "(", "Pmode", ",", "callee", ")", ";", "address", "=", "change_address", "(", "address", ",", "QImode", ",", "callee", ")", ";", "}", "if", "(", "GET_CODE", "(", "callee", ")", "==", "SYMBOL_REF", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "callee", ")", ";", "if", "(", "decl", "!=", "NULL_TREE", ")", "{", "if", "(", "DECL_STATIC_CHAIN", "(", "decl", ")", ")", "cfun", "->", "machine", "->", "has_chain", "=", "true", ";", "tree", "attr", "=", "oacc_get_fn_attrib", "(", "decl", ")", ";", "if", "(", "attr", ")", "{", "tree", "dims", "=", "TREE_VALUE", "(", "attr", ")", ";", "parallel", "=", "GOMP_DIM_MASK", "(", "GOMP_DIM_MAX", ")", "-", "1", ";", "for", "(", "int", "ix", "=", "0", ";", "ix", "!=", "GOMP_DIM_MAX", ";", "ix", "++", ")", "{", "if", "(", "TREE_PURPOSE", "(", "dims", ")", "&&", "!", "integer_zerop", "(", "TREE_PURPOSE", "(", "dims", ")", ")", ")", "break", ";", "parallel", "^=", "GOMP_DIM_MASK", "(", "ix", ")", ";", "dims", "=", "TREE_CHAIN", "(", "dims", ")", ";", "}", "}", "}", "}", "unsigned", "nargs", "=", "cfun", "->", "machine", "->", "num_args", ";", "if", "(", "cfun", "->", "machine", "->", "is_varadic", ")", "{", "varargs", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "varargs", ",", "stack_pointer_rtx", ")", ";", "}", "rtvec", "vec", "=", "rtvec_alloc", "(", "nargs", "+", "1", ")", ";", "rtx", "pat", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "int", "vec_pos", "=", "0", ";", "rtx", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "address", ",", "const0_rtx", ")", ";", "rtx", "tmp_retval", "=", "retval", ";", "if", "(", "retval", ")", "{", "if", "(", "!", "nvptx_register_operand", "(", "retval", ",", "GET_MODE", "(", "retval", ")", ")", ")", "tmp_retval", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "retval", ")", ")", ";", "call", "=", "gen_rtx_SET", "(", "tmp_retval", ",", "call", ")", ";", "}", "XVECEXP", "(", "pat", ",", "0", ",", "vec_pos", "++", ")", "=", "call", ";", "for", "(", "rtx", "arg", "=", "cfun", "->", "machine", "->", "call_args", ";", "arg", ";", "arg", "=", "XEXP", "(", "arg", ",", "1", ")", ")", "XVECEXP", "(", "pat", ",", "0", ",", "vec_pos", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "XEXP", "(", "arg", ",", "0", ")", ")", ";", "if", "(", "varargs", ")", "XVECEXP", "(", "pat", ",", "0", ",", "vec_pos", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "varargs", ")", ";", "gcc_assert", "(", "vec_pos", "=", "XVECLEN", "(", "pat", ",", "0", ")", ")", ";", "nvptx_emit_forking", "(", "parallel", ",", "true", ")", ";", "emit_call_insn", "(", "pat", ")", ";", "nvptx_emit_joining", "(", "parallel", ",", "true", ")", ";", "if", "(", "tmp_retval", "!=", "retval", ")", "emit_move_insn", "(", "retval", ",", "tmp_retval", ")", ";", "}", "</s>" ]

[ "Emit", "the", "sequence", "for", "a", "call", "." ]

[ "nvptx", "0", "0", "1", "0", "1", "0", "0", "1", "0", "0", "0", "0" ]

[]

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

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

[ "Teak", "Teak", "1", "TeakCC::True", "1", "TeakCC::True" ]

[]

[ "<s>", "void", "CSKYInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "CSKY", "::", "CARRYRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "if", "(", "STI", ".", "hasE2", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "BTSTI32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "assert", "(", "SrcReg", "<", "CSKY", "::", "R8", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "BTSTI16", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "return", ";", "}", "if", "(", "CSKY", "::", "CARRYRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "CSKY", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "if", "(", "STI", ".", "hasE2", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "MVC32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "assert", "(", "DestReg", "<", "CSKY", "::", "R16", ")", ";", "assert", "(", "DestReg", "<", "CSKY", "::", "R8", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "MOVI16", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "ADDC16", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "DestReg", ",", "getKillRegState", "(", "true", ")", ")", ".", "addReg", "(", "DestReg", ",", "getKillRegState", "(", "true", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "true", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "BTSTI16", ")", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "return", ";", "}", "unsigned", "Opcode", "=", "0", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "CSKY", "::", "MOV32", ";", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"src = \"", "<<", "SrcReg", "<<", "\", dst = \"", "<<", "DestReg", ")", ";", "LLVM_DEBUG", "(", "I", "->", "dump", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Unknown RegisterClass\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY::GPRRegClass", "CSKY::CARRYRegClass", "CSKY::BTSTI32", "0", "CSKY::R8", "CSKY::BTSTI16", "0", "CSKY::CARRYRegClass", "CSKY::GPRRegClass", "CSKY::MVC32", "CSKY::R16", "CSKY::R8", "CSKY::MOVI16", "0", "CSKY::ADDC16", "CSKY::BTSTI16", "0", "0", "CSKY::GPRRegClass", "CSKY::MOV32", "\"src = \"", "\", dst = \"", "\"Unknown RegisterClass\"" ]

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "bool", "isMicroMips", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMicroMipsMode", "(", ")", ";", "unsigned", "Opc", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "expandRetRA", "(", "MBB", ",", "MI", ",", "Mips", "::", "RET", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI", ":", "Opc", "=", "isMicroMips", "?", "Mips", "::", "MFHI16_MM", ":", "Mips", "::", "MFHI", ";", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Opc", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO", ":", "Opc", "=", "isMicroMips", "?", "Mips", "::", "MFLO16_MM", ":", "Mips", "::", "MFLO", ";", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Opc", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFHI64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFLO64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO", ",", "Mips", "::", "MTHI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI64", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO64", ",", "Mips", "::", "MTHI64", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI_DSP", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO_DSP", ",", "Mips", "::", "MTHI_DSP", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D32_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D32_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_W", ",", "Mips", "::", "MTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64_64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64_64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "MIPSeh_return32", ":", "case", "Mips", "::", "MIPSeh_return64", ":", "expandEhReturn", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::RetRA", "Mips::RET", "Mips::PseudoMFHI", "Mips", "Mips::MFHI16_MM", "Mips::MFHI", "Mips::PseudoMFLO", "Mips", "Mips::MFLO16_MM", "Mips::MFLO", "Mips::PseudoMFHI64", "Mips::MFHI64", "Mips::PseudoMFLO64", "Mips::MFLO64", "Mips::PseudoMTLOHI", "Mips::MTLO", "Mips::MTHI", "Mips::PseudoMTLOHI64", "Mips::MTLO64", "Mips::MTHI64", "Mips::PseudoMTLOHI_DSP", "Mips::MTLO_DSP", "Mips::MTHI_DSP", "Mips::PseudoCVT_S_W", "Mips::CVT_S_W", "Mips::MTC1", "Mips::PseudoCVT_D32_W", "Mips::CVT_D32_W", "Mips::MTC1", "Mips::PseudoCVT_S_L", "Mips::CVT_S_L", "Mips::DMTC1", "Mips::PseudoCVT_D64_W", "Mips::CVT_D64_W", "Mips::MTC1", "Mips::PseudoCVT_D64_L", "Mips::CVT_D64_L", "Mips::DMTC1", "Mips::BuildPairF64", "Mips::BuildPairF64_64", "Mips::ExtractElementF64", "Mips::ExtractElementF64_64", "Mips::MIPSeh_return32", "Mips::MIPSeh_return64" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_case_values_threshold", "(", "void", ")", "{", "if", "(", "optimize", ">", "2", "&&", "selected_cpu", "->", "tune", "->", "max_case_values", "!=", "0", ")", "return", "selected_cpu", "->", "tune", "->", "max_case_values", ";", "else", "return", "optimize_size", "?", "default_case_values_threshold", "(", ")", ":", "17", ";", "}", "</s>" ]

[ "Implement", "TARGET_CASE_VALUES_THRESHOLD", "." ]

[ "aarch64", "2", "0", "17" ]

[]

[ "<s>", "void", "M68kMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EncodeInstruction: \"", "<<", "MCII", ".", "getName", "(", "Opcode", ")", "<<", "\"(\"", "<<", "Opcode", "<<", "\")\\n\"", ")", ";", "APInt", "EncodedInst", "(", "16", ",", "0U", ")", ";", "APInt", "Scratch", "(", "16", ",", "0U", ")", ";", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "EncodedInst", ",", "Scratch", ",", "STI", ")", ";", "ArrayRef", "<", "uint64_t", ">", "Data", "(", "EncodedInst", ".", "getRawData", "(", ")", ",", "EncodedInst", ".", "getNumWords", "(", ")", ")", ";", "int64_t", "InstSize", "=", "EncodedInst", ".", "getBitWidth", "(", ")", ";", "for", "(", "uint64_t", "Word", ":", "Data", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "4", "&&", "InstSize", ">", "0", ";", "++", "i", ",", "InstSize", "-=", "16", ")", "{", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "static_cast", "<", "uint16_t", ">", "(", "Word", ")", ",", "support", "::", "big", ")", ";", "Word", ">>=", "16", ";", "}", "}", "}", "</s>" ]

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

[ "M68k", "M68k", "\"EncodeInstruction: \"", "\"(\"", "\")\\n\"", "16", "0U", "16", "0U", "0", "4", "0", "16", "support::endian", "support::big", "16" ]

[]

[ "<s>", "void", "ia64_asm_output_external", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ")", "{", "if", "(", "TREE_SYMBOL_REFERENCED", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ")", "{", "int", "need_visibility", "=", "(", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", "&&", "maybe_assemble_visibility", "(", "decl", ")", ")", ";", "if", "(", "(", "TARGET_HPUX_LD", "||", "!", "TARGET_GNU_AS", ")", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "(", "*", "targetm", ".", "asm_out", ".", "globalize_decl_name", ")", "(", "file", ",", "decl", ")", ";", "else", "if", "(", "need_visibility", "&&", "!", "TARGET_GNU_AS", ")", "(", "*", "targetm", ".", "asm_out", ".", "globalize_label", ")", "(", "file", ",", "name", ")", ";", "}", "}", "</s>" ]

[ "Emit", "text", "to", "declare", "externally", "defined", "variables", "and", "functions", ",", "because", "the", "Intel", "assembler", "does", "not", "support", "undefined", "externals", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "0", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "0", "1", "0", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "1", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3", "1", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "bool", "AArch64FastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "return", "selectAddSub", "(", "I", ")", ";", "case", "Instruction", "::", "Mul", ":", "return", "selectMul", "(", "I", ")", ";", "case", "Instruction", "::", "SDiv", ":", "return", "selectSDiv", "(", "I", ")", ";", "case", "Instruction", "::", "SRem", ":", "if", "(", "!", "selectBinaryOp", "(", "I", ",", "ISD", "::", "SREM", ")", ")", "return", "selectRem", "(", "I", ",", "ISD", "::", "SREM", ")", ";", "return", "true", ";", "case", "Instruction", "::", "URem", ":", "if", "(", "!", "selectBinaryOp", "(", "I", ",", "ISD", "::", "UREM", ")", ")", "return", "selectRem", "(", "I", ",", "ISD", "::", "UREM", ")", ";", "return", "true", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "return", "selectShift", "(", "I", ")", ";", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "return", "selectLogicalOp", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "selectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "IndirectBr", ":", "return", "selectIndirectBr", "(", "I", ")", ";", "case", "Instruction", "::", "BitCast", ":", "if", "(", "!", "FastISel", "::", "selectBitCast", "(", "I", ")", ")", "return", "selectBitCast", "(", "I", ")", ";", "return", "true", ";", "case", "Instruction", "::", "FPToSI", ":", "if", "(", "!", "selectCast", "(", "I", ",", "ISD", "::", "FP_TO_SINT", ")", ")", "return", "selectFPToInt", "(", "I", ",", "true", ")", ";", "return", "true", ";", "case", "Instruction", "::", "FPToUI", ":", "return", "selectFPToInt", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "return", "selectIntExt", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "if", "(", "!", "selectCast", "(", "I", ",", "ISD", "::", "TRUNCATE", ")", ")", "return", "selectTrunc", "(", "I", ")", ";", "return", "true", ";", "case", "Instruction", "::", "FPExt", ":", "return", "selectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "selectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "if", "(", "!", "selectCast", "(", "I", ",", "ISD", "::", "SINT_TO_FP", ")", ")", "return", "selectIntToFP", "(", "I", ",", "true", ")", ";", "return", "true", ";", "case", "Instruction", "::", "UIToFP", ":", "return", "selectIntToFP", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "Load", ":", "return", "selectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "selectStore", "(", "I", ")", ";", "case", "Instruction", "::", "FCmp", ":", "case", "Instruction", "::", "ICmp", ":", "return", "selectCmp", "(", "I", ")", ";", "case", "Instruction", "::", "Select", ":", "return", "selectSelect", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "selectRet", "(", "I", ")", ";", "case", "Instruction", "::", "FRem", ":", "return", "selectFRem", "(", "I", ")", ";", "case", "Instruction", "::", "GetElementPtr", ":", "return", "selectGetElementPtr", "(", "I", ")", ";", "}", "return", "selectOperator", "(", "I", ",", "I", "->", "getOpcode", "(", ")", ")", ";", "(", "void", ")", "&", "CC_AArch64_DarwinPCS_VarArg", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "AArch64", "AArch64", "ISD::SREM", "ISD::SREM", "ISD::UREM", "ISD::UREM", "ISD::FP_TO_SINT", "ISD::TRUNCATE", "ISD::SINT_TO_FP", "AArch64" ]

[]

[ "<s>", "void", "WebAssemblyMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "assert", "(", "false", "&&", "\"FIXME: not implemented yet\"", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"FIXME: not implemented yet\"" ]

[]

[ "<s>", "const", "char", "*", "output_condmove_single", "(", "rtx", "operands", "[", "]", ",", "rtx", "insn", ")", "{", "rtx", "dest", "=", "operands", "[", "2", "]", ";", "rtx", "src", "=", "operands", "[", "3", "]", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "REG", ")", "{", "int", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "GPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "return", "\"cmov %z3, %2, %1, %e0\"", ";", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "return", "\"cmovfg %3, %2, %1, %e0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_QImode", ":", "return", "\"cldsb%I3%U3 %M3, %2, %1, %e0\"", ";", "case", "E_HImode", ":", "return", "\"cldsh%I3%U3 %M3, %2, %1, %e0\"", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "return", "\"cld%I3%U3 %M3, %2, %1, %e0\"", ";", "}", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "return", "\"cmov %., %2, %1, %e0\"", ";", "}", "else", "if", "(", "FPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "return", "\"cmovgf %3, %2, %1, %e0\"", ";", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "TARGET_HARD_FLOAT", ")", "return", "\"cfmovs %3,%2,%1,%e0\"", ";", "else", "return", "\"cmor %3, %3, %2, %1, %e0\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", "return", "\"cldf%I3%U3 %M3, %2, %1, %e0\"", ";", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "return", "\"cmovgf %., %2, %1, %e0\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_QImode", ":", "return", "\"cstb%I2%U2 %3, %M2, %1, %e0\"", ";", "case", "E_HImode", ":", "return", "\"csth%I2%U2 %3, %M2, %1, %e0\"", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "return", "\"cst%I2%U2 %3, %M2, %1, %e0\"", ";", "}", "}", "else", "if", "(", "FPR_P", "(", "src_regno", ")", "&&", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", ")", "return", "\"cstf%I2%U2 %3, %M2, %1, %e0\"", ";", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_QImode", ":", "return", "\"cstb%I2%U2 %., %M2, %1, %e0\"", ";", "case", "E_HImode", ":", "return", "\"csth%I2%U2 %., %M2, %1, %e0\"", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "return", "\"cst%I2%U2 %., %M2, %1, %e0\"", ";", "}", "}", "}", "fatal_insn", "(", "\"bad output_condmove_single operand\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "output", "a", "single", "word", "conditional", "move", ".", "Operand0", "--", "EQ/NE", "of", "ccr", "register", "and", "0", "Operand1", "--", "CCR", "register", "Operand2", "--", "destination", "Operand3", "--", "source" ]

[ "frv", "2", "3", "\"cmov %z3, %2, %1, %e0\"", "\"cmovfg %3, %2, %1, %e0\"", "\"cldsb%I3%U3 %M3, %2, %1, %e0\"", "\"cldsh%I3%U3 %M3, %2, %1, %e0\"", "\"cld%I3%U3 %M3, %2, %1, %e0\"", "\"cmov %., %2, %1, %e0\"", "\"cmovgf %3, %2, %1, %e0\"", "\"cfmovs %3,%2,%1,%e0\"", "\"cmor %3, %3, %2, %1, %e0\"", "\"cldf%I3%U3 %M3, %2, %1, %e0\"", "\"cmovgf %., %2, %1, %e0\"", "\"cstb%I2%U2 %3, %M2, %1, %e0\"", "\"csth%I2%U2 %3, %M2, %1, %e0\"", "\"cst%I2%U2 %3, %M2, %1, %e0\"", "\"cstf%I2%U2 %3, %M2, %1, %e0\"", "\"cstb%I2%U2 %., %M2, %1, %e0\"", "\"csth%I2%U2 %., %M2, %1, %e0\"", "\"cst%I2%U2 %., %M2, %1, %e0\"", "\"bad output_condmove_single operand\"", "\"\"" ]

[]