Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "MachineBasicBlock", "::", "iterator", "AArch64InstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "MachineOutlinerInfo", "&", "MInfo", ")", "const", "{", "if", "(", "MInfo", ".", "CallConstructionID", "==", "MachineOutlinerTailCall", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "B", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "return", "It", ";", "}", "if", "(", "MInfo", ".", "CallConstructionID", "==", "MachineOutlinerNoLRSave", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "BL", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "return", "It", ";", "}", "MachineInstr", "*", "STRXpre", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "STRXpre", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "LR", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "-", "16", ")", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "STRXpre", ")", ";", "It", "++", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "BL", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "It", "++", ";", "MachineInstr", "*", "LDRXpost", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "LDRXpost", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "LR", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "16", ")", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "LDRXpost", ")", ";", "return", "It", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

[ "AArch64", "AArch64", "AArch64::B", "AArch64::BL", "AArch64::STRXpre", "AArch64::SP", "AArch64::LR", "AArch64::SP", "16", "AArch64::BL", "AArch64::LDRXpost", "AArch64::SP", "AArch64::LR", "AArch64::SP", "16" ]

[]

[ "<s>", "static", "tree", "riscv_d_handle_target_float_abi", "(", "void", ")", "{", "const", "char", "*", "abi", ";", "switch", "(", "riscv_abi", ")", "{", "case", "ABI_ILP32E", ":", "case", "ABI_ILP32", ":", "case", "ABI_LP64", ":", "abi", "=", "\"soft\"", ";", "break", ";", "case", "ABI_ILP32F", ":", "case", "ABI_LP64F", ":", "abi", "=", "\"single\"", ";", "break", ";", "case", "ABI_ILP32D", ":", "case", "ABI_LP64D", ":", "abi", "=", "\"double\"", ";", "break", ";", "default", ":", "abi", "=", "\"\"", ";", "break", ";", "}", "return", "build_string_literal", "(", "strlen", "(", "abi", ")", "+", "1", ",", "abi", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "floatAbi", "''", ")", "'", "." ]

[ "riscv", "\"soft\"", "\"single\"", "\"double\"", "\"\"", "1" ]

[]

[ "<s>", "static", "rtx", "vprop_gen", "(", "rtx", "reg", ",", "propagate_mask", "pm", ",", "unsigned", "ARG_UNUSED", "(", "count", ")", ",", "void", "*", "ARG_UNUSED", "(", "data", ")", ")", "{", "if", "(", "!", "(", "pm", "&", "PM_read_write", ")", ")", "return", "0", ";", "return", "nvptx_gen_vcast", "(", "reg", ")", ";", "}", "</s>" ]

[ "Worker", "for", "nvptx_vpropagate", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "bool", "MBlazeAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "size_t", "dotLoc", "=", "Name", ".", "find", "(", "'.'", ")", ";", "Operands", ".", "push_back", "(", "MBlazeOperand", "::", "CreateToken", "(", "Name", ".", "substr", "(", "0", ",", "dotLoc", ")", ",", "NameLoc", ")", ")", ";", "if", "(", "dotLoc", "<", "Name", ".", "size", "(", ")", ")", "Operands", ".", "push_back", "(", "MBlazeOperand", "::", "CreateToken", "(", "Name", ".", "substr", "(", "dotLoc", ")", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "!", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "!", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "if", "(", "Name", ".", "startswith", "(", "\"lw\"", ")", "||", "Name", ".", "startswith", "(", "\"sw\"", ")", "||", "Name", ".", "startswith", "(", "\"lh\"", ")", "||", "Name", ".", "startswith", "(", "\"sh\"", ")", "||", "Name", ".", "startswith", "(", "\"lb\"", ")", "||", "Name", ".", "startswith", "(", "\"sb\"", ")", ")", "return", "(", "ParseMemory", "(", "Operands", ")", "==", "NULL", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze", "\"lw\"", "\"sw\"", "\"lh\"", "\"sh\"", "\"lb\"", "\"sb\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "auto", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "auto", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "LOAD_STACK_GUARD", ":", "{", "assert", "(", "Subtarget", ".", "isTargetLinux", "(", ")", "&&", "\"Only Linux target is expected to contain LOAD_STACK_GUARD\"", ")", ";", "const", "int64_t", "Offset", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "-", "0x7010", ":", "-", "0x7008", ";", "const", "unsigned", "Reg", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "X13", ":", "PPC", "::", "R2", ";", "MI", ".", "setDesc", "(", "get", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "LD", ":", "PPC", "::", "LWZ", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "Reg", ")", ";", "return", "true", ";", "}", "case", "PPC", "::", "DFLOADf32", ":", "case", "PPC", "::", "DFLOADf64", ":", "case", "PPC", "::", "DFSTOREf32", ":", "case", "PPC", "::", "DFSTOREf64", ":", "{", "assert", "(", "Subtarget", ".", "hasP9Vector", "(", ")", "&&", "\"Invalid D-Form Pseudo-ops on non-P9 target.\"", ")", ";", "assert", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "\"D-form op must have register and immediate operands\"", ")", ";", "unsigned", "UpperOpcode", ",", "LowerOpcode", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "PPC", "::", "DFLOADf32", ":", "UpperOpcode", "=", "PPC", "::", "LXSSP", ";", "LowerOpcode", "=", "PPC", "::", "LFS", ";", "break", ";", "case", "PPC", "::", "DFLOADf64", ":", "UpperOpcode", "=", "PPC", "::", "LXSD", ";", "LowerOpcode", "=", "PPC", "::", "LFD", ";", "break", ";", "case", "PPC", "::", "DFSTOREf32", ":", "UpperOpcode", "=", "PPC", "::", "STXSSP", ";", "LowerOpcode", "=", "PPC", "::", "STFS", ";", "break", ";", "case", "PPC", "::", "DFSTOREf64", ":", "UpperOpcode", "=", "PPC", "::", "STXSD", ";", "LowerOpcode", "=", "PPC", "::", "STFD", ";", "break", ";", "}", "unsigned", "TargetReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "(", "TargetReg", ">=", "PPC", "::", "F0", "&&", "TargetReg", "<=", "PPC", "::", "F31", ")", "||", "(", "TargetReg", ">=", "PPC", "::", "VSL0", "&&", "TargetReg", "<=", "PPC", "::", "VSL31", ")", ")", "Opcode", "=", "LowerOpcode", ";", "else", "Opcode", "=", "UpperOpcode", ";", "MI", ".", "setDesc", "(", "get", "(", "Opcode", ")", ")", ";", "return", "true", ";", "}", "case", "PPC", "::", "CFENCE8", ":", "{", "auto", "Val", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "PPC", "::", "CMPD", ")", ",", "PPC", "::", "CR7", ")", ".", "addReg", "(", "Val", ")", ".", "addReg", "(", "Val", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "PPC", "::", "CTRL_DEP", ")", ")", ".", "addImm", "(", "PPC", "::", "PRED_NE_MINUS", ")", ".", "addReg", "(", "PPC", "::", "CR7", ")", ".", "addImm", "(", "1", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "PPC", "::", "ISYNC", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Only Linux target is expected to contain LOAD_STACK_GUARD\"", "PPC", "0x7010", "0x7008", "PPC", "PPC::X13", "PPC::R2", "PPC", "PPC::LD", "PPC::LWZ", "PPC::DFLOADf32", "PPC::DFLOADf64", "PPC::DFSTOREf32", "PPC::DFSTOREf64", "\"Invalid D-Form Pseudo-ops on non-P9 target.\"", "2", "1", "\"D-form op must have register and immediate operands\"", "PPC::DFLOADf32", "PPC::LXSSP", "PPC::LFS", "PPC::DFLOADf64", "PPC::LXSD", "PPC::LFD", "PPC::DFSTOREf32", "PPC::STXSSP", "PPC::STFS", "PPC::DFSTOREf64", "PPC::STXSD", "PPC::STFD", "0", "PPC::F0", "PPC::F31", "PPC::VSL0", "PPC::VSL31", "PPC::CFENCE8", "0", "PPC::CMPD", "PPC::CR7", "PPC::CTRL_DEP", "PPC::PRED_NE_MINUS", "PPC::CR7", "1", "PPC::ISYNC", "0" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getPartialRegUpdateClearance", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "OpNum", "!=", "0", "||", "!", "hasPartialRegUpdate", "(", "MI", ".", "getOpcode", "(", ")", ",", "Subtarget", ")", ")", "return", "0", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "Reg", ")", ")", "{", "if", "(", "MO", ".", "readsReg", "(", ")", "||", "MI", ".", "readsVirtualRegister", "(", "Reg", ")", ")", "return", "0", ";", "}", "else", "{", "if", "(", "MI", ".", "readsRegister", "(", "Reg", ",", "TRI", ")", ")", "return", "0", ";", "}", "return", "PartialRegUpdateClearance", ";", "}", "</s>" ]

[ "Inform", "the", "BreakFalseDeps", "pass", "how", "many", "idle", "instructions", "we", "would", "like", "before", "a", "partial", "register", "update", "." ]

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

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitGlobals", "(", "const", "Module", "&", "M", ")", "{", "SmallString", "<", "128", ">", "Str2", ";", "raw_svector_ostream", "OS2", "(", "Str2", ")", ";", "emitDeclarations", "(", "M", ",", "OS2", ")", ";", "SmallVector", "<", "const", "GlobalVariable", "*", ",", "8", ">", "Globals", ";", "DenseSet", "<", "const", "GlobalVariable", "*", ">", "GVVisited", ";", "DenseSet", "<", "const", "GlobalVariable", "*", ">", "GVVisiting", ";", "for", "(", "const", "GlobalVariable", "&", "I", ":", "M", ".", "globals", "(", ")", ")", "VisitGlobalVariableForEmission", "(", "&", "I", ",", "Globals", ",", "GVVisited", ",", "GVVisiting", ")", ";", "assert", "(", "GVVisited", ".", "size", "(", ")", "==", "M", ".", "getGlobalList", "(", ")", ".", "size", "(", ")", "&&", "\"Missed a global variable\"", ")", ";", "assert", "(", "GVVisiting", ".", "size", "(", ")", "==", "0", "&&", "\"Did not fully process a global variable\"", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "const", "NVPTXSubtarget", "&", "STI", "=", "*", "static_cast", "<", "const", "NVPTXSubtarget", "*", ">", "(", "NTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Globals", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "printModuleLevelGV", "(", "Globals", "[", "i", "]", ",", "OS2", ",", "false", ",", "STI", ")", ";", "OS2", "<<", "'\\n'", ";", "OutStreamer", "->", "emitRawText", "(", "OS2", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitGlobals", "-", "Emit", "all", "of", "the", "global", "variables", "to", "memory", ",", "storing", "their", "addresses", "into", "GlobalAddress", "." ]

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

[]

[ "<s>", "int", "small_data_operand", "(", "rtx", "op", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "sym_ref", ";", "if", "(", "rs6000_sdata", "==", "SDATA_NONE", "||", "rs6000_sdata", "==", "SDATA_DATA", ")", "return", "0", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_V4", ")", "return", "0", ";", "if", "(", "SYMBOL_REF_P", "(", "op", ")", ")", "sym_ref", "=", "op", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "!=", "PLUS", "||", "!", "SYMBOL_REF_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", "return", "0", ";", "else", "{", "rtx", "sum", "=", "XEXP", "(", "op", ",", "0", ")", ";", "HOST_WIDE_INT", "summand", ";", "summand", "=", "INTVAL", "(", "XEXP", "(", "sum", ",", "1", ")", ")", ";", "if", "(", "summand", "<", "0", "||", "summand", ">", "g_switch_value", ")", "return", "0", ";", "sym_ref", "=", "XEXP", "(", "sum", ",", "0", ")", ";", "}", "return", "SYMBOL_REF_SMALL_P", "(", "sym_ref", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "for", "an", "operand", "in", "small", "memory", "on", "V.4/eabi", "." ]

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

[]

[ "<s>", "void", "push", "(", "WeightedLeaf", "L", ",", "bool", "SeparateConst", "=", "true", ")", "{", "if", "(", "!", "HaveConst", "&&", "SeparateConst", "&&", "isa", "<", "ConstantSDNode", ">", "(", "L", ".", "Value", ")", ")", "{", "if", "(", "Opcode", "==", "ISD", "::", "MUL", "&&", "cast", "<", "ConstantSDNode", ">", "(", "L", ".", "Value", ")", "->", "getSExtValue", "(", ")", "==", "1", ")", "return", ";", "if", "(", "Opcode", "==", "ISD", "::", "ADD", "&&", "cast", "<", "ConstantSDNode", ">", "(", "L", ".", "Value", ")", "->", "getSExtValue", "(", ")", "==", "0", ")", "return", ";", "HaveConst", "=", "true", ";", "ConstElt", "=", "L", ";", "}", "else", "{", "Q", ".", "push_back", "(", "L", ")", ";", "std", "::", "push_heap", "(", "Q", ".", "begin", "(", ")", ",", "Q", ".", "end", "(", ")", ",", "WeightedLeaf", "::", "Compare", ")", ";", "}", "}", "</s>" ]

[ "Push", "the", "current", "solver", "state", "." ]

[ "Hexagon", "ISD::MUL", "1", "ISD::ADD", "0" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "CMP64ri8", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP32ri8", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP16ri8", ":", "case", "X86", "::", "CMP8ri", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "X86", "::", "SUB64rm", ":", "case", "X86", "::", "SUB32rm", ":", "case", "X86", "::", "SUB16rm", ":", "case", "X86", "::", "SUB8rm", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64rr", ":", "case", "X86", "::", "SUB32rr", ":", "case", "X86", "::", "SUB16rr", ":", "case", "X86", "::", "SUB8rr", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64ri32", ":", "case", "X86", "::", "SUB64ri8", ":", "case", "X86", "::", "SUB32ri", ":", "case", "X86", "::", "SUB32ri8", ":", "case", "X86", "::", "SUB16ri", ":", "case", "X86", "::", "SUB16ri8", ":", "case", "X86", "::", "SUB8ri", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "X86", "::", "CMP64rr", ":", "case", "X86", "::", "CMP32rr", ":", "case", "X86", "::", "CMP16rr", ":", "case", "X86", "::", "CMP8rr", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "TEST8rr", ":", "case", "X86", "::", "TEST16rr", ":", "case", "X86", "::", "TEST32rr", ":", "case", "X86", "::", "TEST64rr", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "SrcReg", ")", "return", "false", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::CMP64ri32", "X86::CMP64ri8", "X86::CMP32ri", "X86::CMP32ri8", "X86::CMP16ri", "X86::CMP16ri8", "X86::CMP8ri", "0", "0", "0", "1", "X86::SUB64rm", "X86::SUB32rm", "X86::SUB16rm", "X86::SUB8rm", "1", "0", "0", "0", "X86::SUB64rr", "X86::SUB32rr", "X86::SUB16rr", "X86::SUB8rr", "1", "2", "0", "0", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "X86::SUB16ri", "X86::SUB16ri8", "X86::SUB8ri", "1", "0", "0", "2", "X86::CMP64rr", "X86::CMP32rr", "X86::CMP16rr", "X86::CMP8rr", "0", "1", "0", "0", "X86::TEST8rr", "X86::TEST16rr", "X86::TEST32rr", "X86::TEST64rr", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "const", "MCExpr", "*", "PPC64LinuxTargetObjectFile", "::", "getDebugThreadLocalSymbol", "(", "const", "MCSymbol", "*", "Sym", ")", "const", "{", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_DTPREL", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "createAdd", "(", "Expr", ",", "MCConstantExpr", "::", "create", "(", "0x8000", ",", "getContext", "(", ")", ")", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "Describe", "a", "TLS", "variable", "address", "within", "debug", "info", "." ]

[ "PowerPC", "PPC", "0x8000" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "getRegAllocationHints", "(", "unsigned", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Hint", "=", "MRI", ".", "getRegAllocationHint", "(", "VirtReg", ")", ";", "unsigned", "Odd", ";", "switch", "(", "Hint", ".", "first", ")", "{", "case", "ARMRI", "::", "RegPairEven", ":", "Odd", "=", "0", ";", "break", ";", "case", "ARMRI", "::", "RegPairOdd", ":", "Odd", "=", "1", ";", "break", ";", "default", ":", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ")", ";", "return", ";", "}", "unsigned", "Paired", "=", "Hint", ".", "second", ";", "if", "(", "Paired", "==", "0", ")", "return", ";", "unsigned", "PairedPhys", "=", "0", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "Paired", ";", "}", "else", "if", "(", "VRM", "&&", "VRM", "->", "hasPhys", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "getPairedGPR", "(", "VRM", "->", "getPhys", "(", "Paired", ")", ",", "Odd", ",", "this", ")", ";", "}", "if", "(", "PairedPhys", "&&", "std", "::", "find", "(", "Order", ".", "begin", "(", ")", ",", "Order", ".", "end", "(", ")", ",", "PairedPhys", ")", "!=", "Order", ".", "end", "(", ")", ")", "Hints", ".", "push_back", "(", "PairedPhys", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Order", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "Order", "[", "I", "]", ";", "if", "(", "Reg", "==", "PairedPhys", "||", "(", "getEncodingValue", "(", "Reg", ")", "&", "1", ")", "!=", "Odd", ")", "continue", ";", "unsigned", "Paired", "=", "getPairedGPR", "(", "Reg", ",", "!", "Odd", ",", "this", ")", ";", "if", "(", "!", "Paired", "||", "MRI", ".", "isReserved", "(", "Paired", ")", ")", "continue", ";", "Hints", ".", "push_back", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "ARM", "ARM", "ARMRI::RegPairEven", "0", "ARMRI::RegPairOdd", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "std", "::", "vector", "<", "const", "SUnit", "*", ">", "GCNILPScheduler", "::", "schedule", "(", "ArrayRef", "<", "const", "SUnit", "*", ">", "BotRoots", ",", "const", "ScheduleDAG", "&", "DAG", ")", "{", "auto", "&", "SUnits", "=", "const_cast", "<", "ScheduleDAG", "&", ">", "(", "DAG", ")", ".", "SUnits", ";", "std", "::", "vector", "<", "SUnit", ">", "SUSavedCopy", ";", "SUSavedCopy", ".", "resize", "(", "SUnits", ".", "size", "(", ")", ")", ";", "for", "(", "const", "SUnit", "&", "SU", ":", "SUnits", ")", "SUSavedCopy", "[", "SU", ".", "NodeNum", "]", "=", "SU", ";", "SUNumbers", ".", "assign", "(", "SUnits", ".", "size", "(", ")", ",", "0", ")", ";", "for", "(", "const", "SUnit", "&", "SU", ":", "SUnits", ")", "CalcNodeSethiUllmanNumber", "(", "&", "SU", ",", "SUNumbers", ")", ";", "for", "(", "auto", "SU", ":", "BotRoots", ")", "{", "AvailQueue", ".", "push_back", "(", "*", "new", "(", "Alloc", ".", "Allocate", "(", ")", ")", "Candidate", "(", "const_cast", "<", "SUnit", "*", ">", "(", "SU", ")", ")", ")", ";", "}", "releasePredecessors", "(", "&", "DAG", ".", "ExitSU", ")", ";", "std", "::", "vector", "<", "const", "SUnit", "*", ">", "Schedule", ";", "Schedule", ".", "reserve", "(", "SUnits", ".", "size", "(", ")", ")", ";", "while", "(", "true", ")", "{", "if", "(", "AvailQueue", ".", "empty", "(", ")", "&&", "!", "PendingQueue", ".", "empty", "(", ")", ")", "{", "auto", "EarliestSU", "=", "std", "::", "min_element", "(", "PendingQueue", ".", "begin", "(", ")", ",", "PendingQueue", ".", "end", "(", ")", ",", "[", "=", "]", "(", "const", "Candidate", "&", "C1", ",", "const", "Candidate", "&", "C2", ")", "{", "return", "C1", ".", "SU", "->", "getHeight", "(", ")", "<", "C2", ".", "SU", "->", "getHeight", "(", ")", ";", "}", ")", "->", "SU", ";", "advanceToCycle", "(", "std", "::", "max", "(", "CurCycle", "+", "1", ",", "EarliestSU", "->", "getHeight", "(", ")", ")", ")", ";", "}", "if", "(", "AvailQueue", ".", "empty", "(", ")", ")", "break", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n=== Picking candidate\\n\"", "\"Ready queue:\"", ";", "for", "(", "auto", "&", "C", ":", "AvailQueue", ")", "dbgs", "(", ")", "<<", "' '", "<<", "C", ".", "SU", "->", "NodeNum", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", ")", ";", "auto", "C", "=", "pickCandidate", "(", ")", ";", "assert", "(", "C", ")", ";", "AvailQueue", ".", "remove", "(", "*", "C", ")", ";", "auto", "SU", "=", "C", "->", "SU", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selected \"", ";", "DAG", ".", "dumpNode", "(", "*", "SU", ")", ")", ";", "advanceToCycle", "(", "SU", "->", "getHeight", "(", ")", ")", ";", "releasePredecessors", "(", "SU", ")", ";", "Schedule", ".", "push_back", "(", "SU", ")", ";", "SU", "->", "isScheduled", "=", "true", ";", "}", "assert", "(", "SUnits", ".", "size", "(", ")", "==", "Schedule", ".", "size", "(", ")", ")", ";", "std", "::", "reverse", "(", "Schedule", ".", "begin", "(", ")", ",", "Schedule", ".", "end", "(", ")", ")", ";", "for", "(", "auto", "&", "SU", ":", "SUnits", ")", "SU", "=", "SUSavedCopy", "[", "SU", ".", "NodeNum", "]", ";", "return", "Schedule", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "AMDGPU", "0", "1", "\"\\n=== Picking candidate\\n\"", "\"Ready queue:\"", "\"Selected \"" ]

[]

[ "<s>", "SDValue", "TOYTargetLowering", "::", "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_TOY", ")", ";", "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", "(", "&", "TOY", "::", "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", ")", ";", "SDValue", "FIPtr", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i32", "&&", "\"Only support passing arguments as i32\"", ")", ";", "SDValue", "Load", ";", "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", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Chain", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", "||", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDValue", "TCChain", "=", "Chain", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "return", "false", ";", "bool", "HasRet", "=", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Copy", "->", "use_begin", "(", ")", ",", "UE", "=", "Copy", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "X86ISD", "::", "RET_FLAG", ")", "return", "false", ";", "if", "(", "UI", "->", "getNumOperands", "(", ")", ">", "4", ")", "return", "false", ";", "if", "(", "UI", "->", "getNumOperands", "(", ")", "==", "4", "&&", "UI", "->", "getOperand", "(", "UI", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "!=", "MVT", "::", "Glue", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "if", "(", "!", "HasRet", ")", "return", "false", ";", "Chain", "=", "TCChain", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]

[ "X86", "X86", "1", "1", "0", "ISD::CopyToReg", "1", "MVT::Glue", "0", "ISD::FP_EXTEND", "X86ISD::RET_FLAG", "4", "4", "1", "MVT::Glue" ]

[]

[ "<s>", "unsigned", "PIC16RegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "llvm_unreachable", "(", "\"PIC16 Does not have any frame register\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "PIC16", "PIC16", "\"PIC16 Does not have any frame register\"", "0" ]

[]

[ "<s>", "static", "bool", "expand_vselect_vconcat", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "unsigned", "char", "*", "perm", ",", "unsigned", "nelt", ")", "{", "machine_mode", "v2mode", ";", "rtx", "x", ";", "v2mode", "=", "GET_MODE_2XWIDER_MODE", "(", "GET_MODE", "(", "op0", ")", ")", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "v2mode", ",", "op0", ",", "op1", ")", ";", "return", "expand_vselect", "(", "target", ",", "x", ",", "perm", ",", "nelt", ")", ";", "}", "</s>" ]

[ "Similar", ",", "but", "generate", "a", "vec_concat", "from", "op0", "and", "op1", "as", "well", "." ]

[ "ia64" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "RM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "IsAndroid", "(", "false", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"mips32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips32\"", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid Arch & ABI pair.\"", "\"linux\"" ]

[]

[ "<s>", "static", "int", "rs6000_compute_pressure_classes", "(", "enum", "reg_class", "*", "pressure_classes", ")", "{", "int", "n", ";", "n", "=", "0", ";", "pressure_classes", "[", "n", "++", "]", "=", "GENERAL_REGS", ";", "if", "(", "TARGET_VSX", ")", "pressure_classes", "[", "n", "++", "]", "=", "VSX_REGS", ";", "else", "{", "if", "(", "TARGET_ALTIVEC", ")", "pressure_classes", "[", "n", "++", "]", "=", "ALTIVEC_REGS", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "pressure_classes", "[", "n", "++", "]", "=", "FLOAT_REGS", ";", "}", "pressure_classes", "[", "n", "++", "]", "=", "CR_REGS", ";", "pressure_classes", "[", "n", "++", "]", "=", "SPECIAL_REGS", ";", "return", "n", ";", "}", "</s>" ]

[ "Compute", "register", "pressure", "classes", ".", "We", "implement", "the", "target", "hook", "to", "avoid", "IRA", "picking", "something", "like", "GEN_OR_FLOAT_REGS", "as", "a", "pressure", "class", ",", "which", "can", "lead", "to", "incorrect", "estimates", "of", "number", "of", "available", "registers", "and", "therefor", "increased", "register", "pressure/spill", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "static", "bool", "find_nearest_reg_def", "(", "rtx_insn", "*", "insn", ",", "int", "regno1", ",", "int", "regno2", ")", "{", "rtx_insn", "*", "prev", "=", "insn", ";", "rtx_insn", "*", "start", "=", "BB_HEAD", "(", "BLOCK_FOR_INSN", "(", "insn", ")", ")", ";", "if", "(", "insn", "==", "start", ")", "return", "false", ";", "while", "(", "prev", "&&", "prev", "!=", "start", ")", "{", "if", "(", "!", "INSN_P", "(", "prev", ")", "||", "!", "NONDEBUG_INSN_P", "(", "prev", ")", ")", "{", "prev", "=", "PREV_INSN", "(", "prev", ")", ";", "continue", ";", "}", "if", "(", "insn_defines_reg", "(", "regno1", ",", "INVALID_REGNUM", ",", "prev", ")", ")", "return", "true", ";", "else", "if", "(", "insn_defines_reg", "(", "regno2", ",", "INVALID_REGNUM", ",", "prev", ")", ")", "return", "false", ";", "prev", "=", "PREV_INSN", "(", "prev", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "regno1", "def", "is", "nearest", "to", "the", "insn", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "isBarrier", "(", ")", "const", "{", "return", "Kind", "==", "k_Barrier", "&&", "!", "getBarriernXSModifier", "(", ")", ";", "}", "</s>" ]

[ "Tests", "if", "this", "is", "an", "Order", "dependence", "that", "is", "marked", "as", "a", "barrier", "." ]

[ "AArch64" ]

[]

[ "<s>", "const", "char", "*", "GBZ80TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "GBZ80ISD", "::", "WRAPPER", ":", "return", "\"GBZ80ISD::WRAPPER\"", ";", "case", "GBZ80ISD", "::", "SCF", ":", "return", "\"GBZ80ISD::SCF\"", ";", "case", "GBZ80ISD", "::", "CCF", ":", "return", "\"GBZ80ISD::CCF\"", ";", "case", "GBZ80ISD", "::", "RLC", ":", "return", "\"GBZ80ISD::RLC\"", ";", "case", "GBZ80ISD", "::", "RRC", ":", "return", "\"GBZ80ISD::RRC\"", ";", "case", "GBZ80ISD", "::", "RL", ":", "return", "\"GBZ80ISD::RL\"", ";", "case", "GBZ80ISD", "::", "RR", ":", "return", "\"GBZ80ISD::RR\"", ";", "case", "GBZ80ISD", "::", "SLA", ":", "return", "\"GBZ80ISD::SLA\"", ";", "case", "GBZ80ISD", "::", "SRA", ":", "return", "\"GBZ80ISD::SRA\"", ";", "case", "GBZ80ISD", "::", "SLL", ":", "return", "\"GBZ80ISD::SLL\"", ";", "case", "GBZ80ISD", "::", "SRL", ":", "return", "\"GBZ80ISD::SRL\"", ";", "case", "GBZ80ISD", "::", "SHL", ":", "return", "\"GBZ80ISD::SHL\"", ";", "case", "GBZ80ISD", "::", "LSHR", ":", "return", "\"GBZ80ISD::LSHR\"", ";", "case", "GBZ80ISD", "::", "ASHR", ":", "return", "\"GBZ80ISD::ASHR\"", ";", "case", "GBZ80ISD", "::", "CP", ":", "return", "\"GBZ80ISD::CP\"", ";", "case", "GBZ80ISD", "::", "SELECT_CC", ":", "return", "\"GBZ80ISD::SELECT_CC\"", ";", "case", "GBZ80ISD", "::", "BR_CC", ":", "return", "\"GBZ80ISD::BR_CC\"", ";", "case", "GBZ80ISD", "::", "CALL", ":", "return", "\"GBZ80ISD::CALL\"", ";", "case", "GBZ80ISD", "::", "RET", ":", "return", "\"GBZ80ISD::RET\"", ";", "}", "}", "</s>" ]

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

[ "GBZ80", "GB", "GBZ80ISD::WRAPPER", "\"GBZ80ISD::WRAPPER\"", "GBZ80ISD::SCF", "\"GBZ80ISD::SCF\"", "GBZ80ISD::CCF", "\"GBZ80ISD::CCF\"", "GBZ80ISD::RLC", "\"GBZ80ISD::RLC\"", "GBZ80ISD::RRC", "\"GBZ80ISD::RRC\"", "GBZ80ISD::RL", "\"GBZ80ISD::RL\"", "GBZ80ISD::RR", "\"GBZ80ISD::RR\"", "GBZ80ISD::SLA", "\"GBZ80ISD::SLA\"", "GBZ80ISD::SRA", "\"GBZ80ISD::SRA\"", "GBZ80ISD::SLL", "\"GBZ80ISD::SLL\"", "GBZ80ISD::SRL", "\"GBZ80ISD::SRL\"", "GBZ80ISD::SHL", "\"GBZ80ISD::SHL\"", "GBZ80ISD::LSHR", "\"GBZ80ISD::LSHR\"", "GBZ80ISD::ASHR", "\"GBZ80ISD::ASHR\"", "GBZ80ISD::CP", "\"GBZ80ISD::CP\"", "GBZ80ISD::SELECT_CC", "\"GBZ80ISD::SELECT_CC\"", "GBZ80ISD::BR_CC", "\"GBZ80ISD::BR_CC\"", "GBZ80ISD::CALL", "\"GBZ80ISD::CALL\"", "GBZ80ISD::RET", "\"GBZ80ISD::RET\"" ]

[]

[ "<s>", "void", "tilepro_emit_conditional_branch", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "cmp_mode", ")", "{", "rtx", "cmp_rtx", "=", "tilepro_emit_cc_test", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "cmp_mode", ",", "false", ")", ";", "rtx", "branch_rtx", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "3", "]", ")", ",", "pc_rtx", ")", ")", ";", "emit_jump_insn", "(", "branch_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "comparison", "for", "a", "conditional", "branch", "." ]

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

[]

[ "<s>", "static", "int", "distance_non_agu_define", "(", "unsigned", "int", "regno1", ",", "unsigned", "int", "regno2", ",", "rtx_insn", "*", "insn", ")", "{", "basic_block", "bb", "=", "BLOCK_FOR_INSN", "(", "insn", ")", ";", "int", "distance", "=", "0", ";", "bool", "found", "=", "false", ";", "if", "(", "insn", "!=", "BB_HEAD", "(", "bb", ")", ")", "distance", "=", "distance_non_agu_define_in_bb", "(", "regno1", ",", "regno2", ",", "insn", ",", "distance", ",", "PREV_INSN", "(", "insn", ")", ",", "&", "found", ")", ";", "if", "(", "!", "found", "&&", "distance", "<", "LEA_SEARCH_THRESHOLD", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "bool", "simple_loop", "=", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "e", "->", "src", "==", "bb", ")", "{", "simple_loop", "=", "true", ";", "break", ";", "}", "if", "(", "simple_loop", ")", "distance", "=", "distance_non_agu_define_in_bb", "(", "regno1", ",", "regno2", ",", "insn", ",", "distance", ",", "BB_END", "(", "bb", ")", ",", "&", "found", ")", ";", "else", "{", "int", "shortest_dist", "=", "-", "1", ";", "bool", "found_in_bb", "=", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "{", "int", "bb_dist", "=", "distance_non_agu_define_in_bb", "(", "regno1", ",", "regno2", ",", "insn", ",", "distance", ",", "BB_END", "(", "e", "->", "src", ")", ",", "&", "found_in_bb", ")", ";", "if", "(", "found_in_bb", ")", "{", "if", "(", "shortest_dist", "<", "0", ")", "shortest_dist", "=", "bb_dist", ";", "else", "if", "(", "bb_dist", ">", "0", ")", "shortest_dist", "=", "MIN", "(", "bb_dist", ",", "shortest_dist", ")", ";", "found", "=", "true", ";", "}", "}", "distance", "=", "shortest_dist", ";", "}", "}", "if", "(", "!", "found", ")", "return", "-", "1", ";", "return", "distance", ">>", "1", ";", "}", "</s>" ]

[ "Search", "backward", "for", "non-agu", "definition", "of", "register", "number", "REGNO1", "or", "register", "number", "REGNO2", "in", "INSN", "'s", "basic", "block", "until", "1", ".", "Pass", "LEA_SEARCH_THRESHOLD", "instructions", ",", "or", "2", ".", "Reach", "neighbour", "BBs", "boundary", ",", "or", "3", ".", "Reach", "agu", "definition", ".", "Returns", "the", "distance", "between", "the", "non-agu", "definition", "point", "and", "INSN", ".", "If", "no", "definition", "point", ",", "returns", "-1", "." ]

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

[]

[ "<s>", "static", "machine_mode", "mips_dwarf_frame_reg_mode", "(", "int", "regno", ")", "{", "machine_mode", "mode", "=", "default_dwarf_frame_reg_mode", "(", "regno", ")", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "mips_abi", "==", "ABI_32", "&&", "TARGET_FLOAT64", ")", "mode", "=", "SImode", ";", "return", "mode", ";", "}", "</s>" ]

[ "Implement", "TARGET_DWARF_FRAME_REG_MODE", "." ]

[ "mips" ]

[]

[ "<s>", "void", "SparcInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "STI", ",", "O", ")", "&&", "!", "printSparcAliasInstr", "(", "MI", ",", "STI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "aarch64_split_add_offset", "(", "scalar_int_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "offset_rtx", ",", "rtx", "temp1", ",", "rtx", "temp2", ")", "{", "aarch64_add_offset", "(", "mode", ",", "dest", ",", "src", ",", "rtx_to_poly_int64", "(", "offset_rtx", ")", ",", "temp1", ",", "temp2", ",", "false", ")", ";", "}", "</s>" ]

[ "Like", "aarch64_add_offset", ",", "but", "the", "offset", "is", "given", "as", "an", "rtx", "rather", "than", "a", "poly_int64", "." ]

[ "aarch64" ]

[]

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

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

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

[]

[ "<s>", "bool", "TeakTargetLowering", "::", "allowsMemoryAccess", "(", "LLVMContext", "&", "Context", ",", "const", "DataLayout", "&", "DL", ",", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "!=", "16", "&&", "VT", ".", "getSizeInBits", "(", ")", "!=", "32", ")", "return", "false", ";", "return", "TargetLowering", "::", "allowsMemoryAccess", "(", "Context", ",", "DL", ",", "VT", ",", "AddrSpace", ",", "Alignment", ",", "Flags", ",", "Fast", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "the", "memory", "access", "is", "aligned", "or", "if", "the", "target", "allows", "this", "specific", "unaligned", "memory", "access", "." ]

[ "Teak", "Teak", "16", "32" ]

[]

[ "<s>", "unsigned", "rvexRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "(", "rvex", "::", "R1", ")", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "rvex", "rvex", "rvex::R1" ]

[]

[ "<s>", "static", "rtx", "emit_multi_reg_push", "(", "unsigned", "long", "mask", ",", "unsigned", "long", "dwarf_regs_mask", ")", "{", "int", "num_regs", "=", "0", ";", "int", "num_dwarf_regs", "=", "0", ";", "int", "i", ",", "j", ";", "rtx", "par", ";", "rtx", "dwarf", ";", "int", "dwarf_par_index", ";", "rtx", "tmp", ",", "reg", ";", "dwarf_regs_mask", "&=", "~", "(", "1", "<<", "PC_REGNUM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "num_dwarf_regs", "++", ";", "}", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "16", ")", ";", "gcc_assert", "(", "(", "dwarf_regs_mask", "&", "~", "mask", ")", "==", "0", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", ")", ")", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_dwarf_regs", "+", "1", ")", ")", ";", "dwarf_par_index", "=", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "num_regs", ")", ")", ")", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ")", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "SImode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", "++", ")", "=", "tmp", ";", "}", "break", ";", "}", "}", "for", "(", "j", "=", "1", ",", "i", "++", ";", "j", "<", "num_regs", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "j", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", "++", ")", "=", "tmp", ";", "}", "j", "++", ";", "}", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "num_regs", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "tmp", ";", "add_reg_note", "(", "par", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "return", "par", ";", "}", "</s>" ]

[ "Generate", "and", "emit", "an", "insn", "that", "we", "will", "recognize", "as", "a", "push_multi", ".", "Unfortunately", ",", "since", "this", "insn", "does", "not", "reflect", "very", "well", "the", "actual", "semantics", "of", "the", "operation", ",", "we", "need", "to", "annotate", "the", "insn", "for", "the", "benefit", "of", "DWARF2", "frame", "unwind", "information", "." ]

[ "arm", "0", "0", "1", "0", "1", "1", "16", "0", "1", "1", "0", "1", "0", "0", "4", "1", "1", "1", "0", "1", "1", "0", "1", "4", "1", "0", "4", "1", "0", "0" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "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", "(", ")", ")", ";", "unsigned", "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", ")", ";", "}", "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", "\"WebAssembly doesn't support non-C calling conventions\"", "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" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "ArrayRef", "<", "SMRange", ">", "Ranges", "=", "ArrayRef", "<", "SMRange", ">", "(", ")", ",", "bool", "matchingInlineAsm", "=", "false", ")", "{", "if", "(", "matchingInlineAsm", ")", "return", "true", ";", "return", "Parser", ".", "Error", "(", "L", ",", "Msg", ",", "Ranges", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "EVT", "VT1", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "isZExtFree", "(", "VT1", ",", "VT2", ")", ")", "{", "return", "true", ";", "}", "if", "(", "Val", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "false", ";", "return", "(", "VT1", ".", "isSimple", "(", ")", "&&", "!", "VT1", ".", "isVector", "(", ")", "&&", "VT1", ".", "isInteger", "(", ")", "&&", "VT2", ".", "isSimple", "(", ")", "&&", "!", "VT2", ".", "isVector", "(", ")", "&&", "VT2", ".", "isInteger", "(", ")", "&&", "VT1", ".", "getSizeInBits", "(", ")", "<=", "32", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "AArch64", "AArch64", "ISD::LOAD", "32" ]

[]

[ "<s>", "int", "adjacent_mem_locations", "(", "rtx", "a", ",", "rtx", "b", ")", "{", "if", "(", "volatile_refs_p", "(", "a", ")", "||", "volatile_refs_p", "(", "b", ")", ")", "return", "0", ";", "if", "(", "(", "REG_P", "(", "XEXP", "(", "a", ",", "0", ")", ")", "||", "(", "GET_CODE", "(", "XEXP", "(", "a", ",", "0", ")", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "a", ",", "0", ")", ",", "1", ")", ")", ")", ")", "&&", "(", "REG_P", "(", "XEXP", "(", "b", ",", "0", ")", ")", "||", "(", "GET_CODE", "(", "XEXP", "(", "b", ",", "0", ")", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "b", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "{", "HOST_WIDE_INT", "val0", "=", "0", ",", "val1", "=", "0", ";", "rtx", "reg0", ",", "reg1", ";", "int", "val_diff", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "a", ",", "0", ")", ")", "==", "PLUS", ")", "{", "reg0", "=", "XEXP", "(", "XEXP", "(", "a", ",", "0", ")", ",", "0", ")", ";", "val0", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "a", ",", "0", ")", ",", "1", ")", ")", ";", "}", "else", "reg0", "=", "XEXP", "(", "a", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "b", ",", "0", ")", ")", "==", "PLUS", ")", "{", "reg1", "=", "XEXP", "(", "XEXP", "(", "b", ",", "0", ")", ",", "0", ")", ";", "val1", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "b", ",", "0", ")", ",", "1", ")", ")", ";", "}", "else", "reg1", "=", "XEXP", "(", "b", ",", "0", ")", ";", "if", "(", "!", "const_ok_for_op", "(", "val0", ",", "PLUS", ")", "||", "!", "const_ok_for_op", "(", "val1", ",", "PLUS", ")", ")", "return", "0", ";", "if", "(", "arm_eliminable_register", "(", "reg0", ")", ")", "return", "0", ";", "val_diff", "=", "val1", "-", "val0", ";", "if", "(", "arm_ld_sched", ")", "{", "return", "(", "optimize_size", "&&", "(", "REGNO", "(", "reg0", ")", "==", "REGNO", "(", "reg1", ")", ")", "&&", "(", "val0", "==", "0", "||", "val1", "==", "0", "||", "val0", "==", "4", "||", "val1", "==", "4", ")", "&&", "(", "val_diff", "==", "4", "||", "val_diff", "==", "-", "4", ")", ")", ";", "}", "return", "(", "(", "REGNO", "(", "reg0", ")", "==", "REGNO", "(", "reg1", ")", ")", "&&", "(", "val_diff", "==", "4", "||", "val_diff", "==", "-", "4", ")", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "If", "the", "target", "storage", "locations", "of", "arguments", "MEM1", "and", "MEM2", "are", "adjacent", ",", "then", "return", "the", "argument", "that", "has", "the", "lower", "address", ".", "Otherwise", ",", "return", "NULL_RTX", "." ]

[ "arm", "0", "0", "0", "0", "1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "4", "4", "4", "4", "4", "4", "0" ]

[]

[ "<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", "::", "HINT", ":", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "==", "0x14", ")", "return", "true", ";", "break", ";", "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::HINT", "0", "0x14", "AArch64::DSB", "AArch64::ISB" ]

[]

[ "<s>", "SDValue", "TL45TargetLowering", "::", "getAddr", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "bool", "IsLocal", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "r0", "=", "DAG", ".", "getRegister", "(", "TL45", "::", "r0", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Addr", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TL45", "::", "ADDI", ",", "DL", ",", "Ty", ",", "r0", ",", "Addr", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "the", "address", "accessed", "by", "this", "recipe", "." ]

[ "TL45", "TL45", "TL45::r0", "MVT::i32", "0", "TL45::ADDI", "0" ]

[]

[ "<s>", "int", "num_insns_constant", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "low", ",", "high", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "CONST_INT", ":", "if", "(", "(", "INTVAL", "(", "op", ")", ">>", "31", ")", "!=", "0", "&&", "(", "INTVAL", "(", "op", ")", ">>", "31", ")", "!=", "-", "1", "&&", "rs6000_is_valid_and_mask", "(", "op", ",", "mode", ")", ")", "return", "2", ";", "else", "return", "num_insns_constant_wide", "(", "INTVAL", "(", "op", ")", ")", ";", "case", "CONST_WIDE_INT", ":", "{", "int", "i", ";", "int", "ins", "=", "CONST_WIDE_INT_NUNITS", "(", "op", ")", "-", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CONST_WIDE_INT_NUNITS", "(", "op", ")", ";", "i", "++", ")", "ins", "+=", "num_insns_constant_wide", "(", "CONST_WIDE_INT_ELT", "(", "op", ",", "i", ")", ")", ";", "return", "ins", ";", "}", "case", "CONST_DOUBLE", ":", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SDmode", ")", "{", "long", "l", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "REAL_VALUE_TO_TARGET_DECIMAL32", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "else", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "return", "num_insns_constant_wide", "(", "(", "HOST_WIDE_INT", ")", "l", ")", ";", "}", "long", "l", "[", "2", "]", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "REAL_VALUE_TO_TARGET_DECIMAL64", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "else", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "high", "=", "l", "[", "WORDS_BIG_ENDIAN", "==", "0", "]", ";", "low", "=", "l", "[", "WORDS_BIG_ENDIAN", "!=", "0", "]", ";", "if", "(", "TARGET_32BIT", ")", "return", "(", "num_insns_constant_wide", "(", "low", ")", "+", "num_insns_constant_wide", "(", "high", ")", ")", ";", "else", "{", "if", "(", "(", "high", "==", "0", "&&", "low", ">=", "0", ")", "||", "(", "high", "==", "-", "1", "&&", "low", "<", "0", ")", ")", "return", "num_insns_constant_wide", "(", "low", ")", ";", "else", "if", "(", "rs6000_is_valid_and_mask", "(", "op", ",", "mode", ")", ")", "return", "2", ";", "else", "if", "(", "low", "==", "0", ")", "return", "num_insns_constant_wide", "(", "high", ")", "+", "1", ";", "else", "return", "(", "num_insns_constant_wide", "(", "high", ")", "+", "num_insns_constant_wide", "(", "low", ")", "+", "1", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "it", "takes", "to", "form", "a", "constant", "in", "as", "many", "gprs", "are", "needed", "for", "MODE", "." ]

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "TeeRISCRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "TeeRISC", "::", "IntRegsRegClass", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC", "TeeRISC::IntRegsRegClass" ]

[]

[ "<s>", "static", "rtx", "ia64_function_arg", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "return", "ia64_function_arg_1", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "false", ")", ";", "}", "</s>" ]

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

[ "ia64" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "reserveIndirectRegisters", "(", "BitVector", "&", "Reserved", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AMDGPUFrameLowering", "*", "TFL", "=", "static_cast", "<", "const", "AMDGPUFrameLowering", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "unsigned", "StackWidth", "=", "TFL", "->", "getStackWidth", "(", "MF", ")", ";", "int", "End", "=", "getIndirectIndexEnd", "(", "MF", ")", ";", "if", "(", "End", "==", "-", "1", ")", "return", ";", "for", "(", "int", "Index", "=", "getIndirectIndexBegin", "(", "MF", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "{", "unsigned", "SuperReg", "=", "AMDGPU", "::", "R600_Reg128RegClass", ".", "getRegister", "(", "Index", ")", ";", "Reserved", ".", "set", "(", "SuperReg", ")", ";", "for", "(", "unsigned", "Chan", "=", "0", ";", "Chan", "<", "StackWidth", ";", "++", "Chan", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "R600_TReg32RegClass", ".", "getRegister", "(", "(", "4", "*", "Index", ")", "+", "Chan", ")", ";", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "}", "}", "</s>" ]

[ "Reserve", "the", "registers", "that", "may", "be", "accessed", "using", "indirect", "addressing", "." ]

[ "AMDGPU", "R600", "AMDGPU", "AMDGPU", "1", "AMDGPU::R600_Reg128RegClass", "0", "AMDGPU::R600_TReg32RegClass", "4" ]

[]

[ "<s>", "MipsSubtarget", "&", "MipsSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "std", "::", "string", "CPUName", "=", "selectMipsCPU", "(", "TargetTriple", ",", "CPU", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "TM", ".", "Options", ".", "UseSoftFloat", ")", "InMips16HardFloat", "=", "true", ";", "return", "*", "this", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "nds32_cpu_cpp_builtins", "(", "struct", "cpp_reader", "*", "pfile", ")", "{", "builtin_define", "(", "\"__nds32__\"", ")", ";", "builtin_define", "(", "\"__NDS32__\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "builtin_define", "(", "\"__NDS32_ABI_2FP_PLUS__\"", ")", ";", "else", "builtin_define", "(", "\"__NDS32_ABI_2__\"", ")", ";", "if", "(", "TARGET_ISA_V2", ")", "builtin_define", "(", "\"__NDS32_ISA_V2__\"", ")", ";", "if", "(", "TARGET_ISA_V3", ")", "builtin_define", "(", "\"__NDS32_ISA_V3__\"", ")", ";", "if", "(", "TARGET_ISA_V3M", ")", "builtin_define", "(", "\"__NDS32_ISA_V3M__\"", ")", ";", "if", "(", "TARGET_FPU_SINGLE", ")", "builtin_define", "(", "\"__NDS32_EXT_FPU_SP__\"", ")", ";", "if", "(", "TARGET_FPU_DOUBLE", ")", "builtin_define", "(", "\"__NDS32_EXT_FPU_DP__\"", ")", ";", "if", "(", "TARGET_EXT_FPU_FMA", ")", "builtin_define", "(", "\"__NDS32_EXT_FPU_FMA__\"", ")", ";", "if", "(", "NDS32_EXT_FPU_DOT_E", ")", "builtin_define", "(", "\"__NDS32_EXT_FPU_DOT_E__\"", ")", ";", "if", "(", "TARGET_FPU_SINGLE", "||", "TARGET_FPU_DOUBLE", ")", "{", "switch", "(", "nds32_fp_regnum", ")", "{", "case", "0", ":", "case", "4", ":", "builtin_define", "(", "\"__NDS32_EXT_FPU_CONFIG_0__\"", ")", ";", "break", ";", "case", "1", ":", "case", "5", ":", "builtin_define", "(", "\"__NDS32_EXT_FPU_CONFIG_1__\"", ")", ";", "break", ";", "case", "2", ":", "case", "6", ":", "builtin_define", "(", "\"__NDS32_EXT_FPU_CONFIG_2__\"", ")", ";", "break", ";", "case", "3", ":", "case", "7", ":", "builtin_define", "(", "\"__NDS32_EXT_FPU_CONFIG_3__\"", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "}", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "\"__NDS32_EB__\"", ")", ";", "else", "builtin_define", "(", "\"__NDS32_EL__\"", ")", ";", "if", "(", "TARGET_REDUCED_REGS", ")", "builtin_define", "(", "\"__NDS32_REDUCED_REGS__\"", ")", ";", "if", "(", "TARGET_CMOV", ")", "builtin_define", "(", "\"__NDS32_CMOV__\"", ")", ";", "if", "(", "TARGET_EXT_PERF", ")", "builtin_define", "(", "\"__NDS32_EXT_PERF__\"", ")", ";", "if", "(", "TARGET_EXT_PERF2", ")", "builtin_define", "(", "\"__NDS32_EXT_PERF2__\"", ")", ";", "if", "(", "TARGET_EXT_STRING", ")", "builtin_define", "(", "\"__NDS32_EXT_STRING__\"", ")", ";", "if", "(", "TARGET_16_BIT", ")", "builtin_define", "(", "\"__NDS32_16_BIT__\"", ")", ";", "if", "(", "TARGET_GP_DIRECT", ")", "builtin_define", "(", "\"__NDS32_GP_DIRECT__\"", ")", ";", "if", "(", "TARGET_VH", ")", "builtin_define", "(", "\"__NDS32_VH__\"", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "\"__big_endian__\"", ")", ";", "builtin_assert", "(", "\"cpu=nds32\"", ")", ";", "builtin_assert", "(", "\"machine=nds32\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "builtin_define", "(", "\"__NDS32_ABI_2FP_PLUS\"", ")", ";", "else", "builtin_define", "(", "\"__NDS32_ABI_2\"", ")", ";", "}", "</s>" ]

[ "Run-time", "Target", "Specification", "." ]

[ "nds32", "\"__nds32__\"", "\"__NDS32__\"", "\"__NDS32_ABI_2FP_PLUS__\"", "\"__NDS32_ABI_2__\"", "\"__NDS32_ISA_V2__\"", "\"__NDS32_ISA_V3__\"", "\"__NDS32_ISA_V3M__\"", "\"__NDS32_EXT_FPU_SP__\"", "\"__NDS32_EXT_FPU_DP__\"", "\"__NDS32_EXT_FPU_FMA__\"", "\"__NDS32_EXT_FPU_DOT_E__\"", "0", "4", "\"__NDS32_EXT_FPU_CONFIG_0__\"", "1", "5", "\"__NDS32_EXT_FPU_CONFIG_1__\"", "2", "6", "\"__NDS32_EXT_FPU_CONFIG_2__\"", "3", "7", "\"__NDS32_EXT_FPU_CONFIG_3__\"", "\"__NDS32_EB__\"", "\"__NDS32_EL__\"", "\"__NDS32_REDUCED_REGS__\"", "\"__NDS32_CMOV__\"", "\"__NDS32_EXT_PERF__\"", "\"__NDS32_EXT_PERF2__\"", "\"__NDS32_EXT_STRING__\"", "\"__NDS32_16_BIT__\"", "\"__NDS32_GP_DIRECT__\"", "\"__NDS32_VH__\"", "\"__big_endian__\"", "\"cpu=nds32\"", "\"machine=nds32\"", "\"__NDS32_ABI_2FP_PLUS\"", "\"__NDS32_ABI_2\"" ]

[]

[ "<s>", "static", "void", "microblaze_machine_dependent_reorg", "(", "void", ")", "{", "if", "(", "TARGET_PREFETCH", ")", "{", "compute_bb_for_insn", "(", ")", ";", "loop_optimizer_init", "(", "AVOID_CFG_MODIFICATIONS", ")", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "insert_wic", "(", ")", ";", "loop_optimizer_finalize", "(", ")", ";", "free_bb_for_insn", "(", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "The", "reorg", "function", "defined", "through", "the", "macro", "TARGET_MACHINE_DEPENDENT_REORG", "." ]

[ "microblaze" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFPRCopy", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "COPY", ":", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ")", "||", "AArch64", "::", "FPR128RegClass", ".", "contains", "(", "DstReg", ")", ")", ";", "}", "case", "AArch64", "::", "ORRv16i8", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "3", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "\"invalid ORRv16i8 operands\"", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "rename", "an", "FPR", "without", "modifying", "bits", "?" ]

[ "AArch64", "AArch64", "0", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::ORRv16i8", "1", "2", "3", "0", "\"invalid ORRv16i8 operands\"" ]

[]

[ "<s>", "static", "void", "moxie_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "switch", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "file", ",", "\"%ld(%s)\"", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "plus", "=", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "plus", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "plus", ",", "1", ")", ")", ")", "{", "output_addr_const", "(", "file", ",", "XEXP", "(", "plus", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+%ld(%s)\"", ",", "INTVAL", "(", "XEXP", "(", "plus", ",", "1", ")", ")", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "abort", "(", ")", ";", "}", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "The", "PRINT_OPERAND_ADDRESS", "worker", "." ]

[ "moxie", "\"(%s)\"", "1", "\"%ld(%s)\"", "1", "0", "1", "\"(%s)\"", "0", "1", "0", "0", "1", "0", "\"+%ld(%s)\"", "1", "0" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isLoadBitCastBeneficial", "(", "EVT", "LoadTy", ",", "EVT", "CastTy", ",", "const", "SelectionDAG", "&", "DAG", ",", "const", "MachineMemOperand", "&", "MMO", ")", "const", "{", "assert", "(", "LoadTy", ".", "getSizeInBits", "(", ")", "==", "CastTy", ".", "getSizeInBits", "(", ")", ")", ";", "if", "(", "LoadTy", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i32", ")", "return", "false", ";", "unsigned", "LScalarSize", "=", "LoadTy", ".", "getScalarSizeInBits", "(", ")", ";", "unsigned", "CastScalarSize", "=", "CastTy", ".", "getScalarSizeInBits", "(", ")", ";", "if", "(", "(", "LScalarSize", ">=", "CastScalarSize", ")", "&&", "(", "CastScalarSize", "<", "32", ")", ")", "return", "false", ";", "bool", "Fast", "=", "false", ";", "return", "allowsMemoryAccessForAlignment", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "DAG", ".", "getDataLayout", "(", ")", ",", "CastTy", ",", "MMO", ",", "&", "Fast", ")", "&&", "Fast", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "following", "transform", "is", "beneficial", ":", "fold", "(", "conv", "(", "load", "x", ")", ")", "-", ">", "(", "load", "(", "conv", "*", ")", "x", ")", "On", "architectures", "that", "do", "n't", "natively", "support", "some", "vector", "loads", "efficiently", ",", "casting", "the", "load", "to", "a", "smaller", "vector", "of", "larger", "types", "and", "loading", "is", "more", "efficient", ",", "however", ",", "this", "can", "be", "undone", "by", "optimizations", "in", "dag", "combiner", "." ]

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

[]

[ "<s>", "BitVector", "Cpu0RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedCPURegs", "[", "]", "=", "{", "Cpu0", "::", "ZERO", ",", "Cpu0", "::", "AT", ",", "Cpu0", "::", "SP", ",", "Cpu0", "::", "LR", ",", "Cpu0", "::", "PC", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "if", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "Cpu0", "::", "FP", ")", ";", "}", "const", "Cpu0FunctionInfo", "*", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0FunctionInfo", ">", "(", ")", ";", "if", "(", "Cpu0FI", "->", "globalBaseRegFixed", "(", ")", ")", "Reserved", ".", "set", "(", "Cpu0", "::", "GP", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0::ZERO", "Cpu0::AT", "Cpu0::SP", "Cpu0::LR", "Cpu0::PC", "0", "Cpu0::FP", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0::GP" ]

[]

[ "<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", ".", "hasVInstructions", "(", ")", ")", "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", "." ]

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

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", ")", "{", "if", "(", "OptExecMaskPreRA", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIOptimizeExecMaskingPreRAID", ")", ";", "insertPass", "(", "&", "SIOptimizeExecMaskingPreRAID", ",", "&", "SIFormMemoryClausesID", ")", ";", "}", "else", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIFormMemoryClausesID", ")", ";", "}", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "insertPass", "(", "&", "SILowerControlFlowID", ",", "&", "SIFixWWMLivenessID", ",", "false", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

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

[]

[ "<s>", "static", "bool", "xstormy16_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "true", ")", ";", "}", "</s>" ]

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

[ "stormy16" ]

[]

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

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

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

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "OS", "<<", "\"MinSrc:\"", "<<", "MinSrc", "<<", "\", MaxSrc:\"", "<<", "MaxSrc", "<<", "\" {\"", ";", "for", "(", "int", "M", ":", "Mask", ")", "OS", "<<", "' '", "<<", "M", ";", "OS", "<<", "\" }\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"MinSrc:\"", "\", MaxSrc:\"", "\" {\"", "\" }\"" ]

[]

[ "<s>", "static", "tree", "sh_handle_trap_exit_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "INTEGER_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute argument not an \"", "\"integer constant\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "trap_exit", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "sh", "\"%qs attribute only applies to functions\"", "\"%qs attribute argument not an \"", "\"integer constant\"" ]

[]

[ "<s>", "bool", "pop", "(", "StringRef", "Ins", ",", "NestingType", "NT1", ",", "NestingType", "NT2", "=", "Undefined", ")", "{", "if", "(", "NestingStack", ".", "empty", "(", ")", ")", "return", "error", "(", "Twine", "(", "\"End of block construct with no start: \"", ")", "+", "Ins", ")", ";", "auto", "Top", "=", "NestingStack", ".", "back", "(", ")", ";", "if", "(", "Top", "!=", "NT1", "&&", "Top", "!=", "NT2", ")", "return", "error", "(", "Twine", "(", "\"Block construct type mismatch, expected: \"", ")", "+", "nestingString", "(", "Top", ")", ".", "second", "+", "\", instead got: \"", "+", "Ins", ")", ";", "NestingStack", ".", "pop_back", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Pop", "the", "previous", "solver", "state", "." ]

[ "WebAssembly", "\"End of block construct with no start: \"", "\"Block construct type mismatch, expected: \"", "\", instead got: \"" ]

[]

[ "<s>", "MCOperand", "M88kMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Register", ":", "return", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "case", "MachineOperand", "::", "MO_MCSymbol", ":", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "return", "lowerSymbolOperand", "(", "MO", ")", ";", "default", ":", "report_fatal_error", "(", "\"Unexpected MachineOperand type.\"", ")", ";", "}", "}", "</s>" ]

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

[ "M88k", "M88k", "\"Unexpected MachineOperand type.\"" ]

[]

[ "<s>", "bool", "NyuziDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "if", "(", "!", "SelectADDRri", "(", "Op", ",", "Op0", ",", "Op1", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "void", "aarch64_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "gcc_assert", "(", "epilogue_completed", ")", ";", "rtx", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "scratch", ",", "x", ",", "model_rtx", ";", "machine_mode", "mode", ";", "bool", "is_weak", ";", "rtx_code_label", "*", "label1", ",", "*", "label2", ";", "enum", "memmodel", "model", ";", "rval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "oldval", "=", "operands", "[", "2", "]", ";", "newval", "=", "operands", "[", "3", "]", ";", "is_weak", "=", "(", "operands", "[", "4", "]", "!=", "const0_rtx", ")", ";", "model_rtx", "=", "operands", "[", "5", "]", ";", "scratch", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "model_rtx", ")", ")", ";", "bool", "strong_zero_p", "=", "(", "!", "is_weak", "&&", "!", "aarch64_track_speculation", "&&", "oldval", "==", "const0_rtx", "&&", "mode", "!=", "TImode", ")", ";", "label1", "=", "NULL", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label1", ")", ";", "}", "label2", "=", "gen_label_rtx", "(", ")", ";", "if", "(", "is_mm_sync", "(", "model", ")", ")", "aarch64_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "GEN_INT", "(", "MEMMODEL_RELAXED", ")", ")", ";", "else", "aarch64_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "model_rtx", ")", ";", "if", "(", "strong_zero_p", ")", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "rval", ",", "const0_rtx", ")", ";", "else", "{", "rtx", "cc_reg", "=", "aarch64_gen_compare_reg_maybe_ze", "(", "NE", ",", "rval", ",", "oldval", ",", "mode", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cc_reg", ",", "const0_rtx", ")", ";", "}", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "aarch64_emit_store_exclusive", "(", "mode", ",", "scratch", ",", "mem", ",", "newval", ",", "model_rtx", ")", ";", "if", "(", "!", "is_weak", ")", "{", "if", "(", "aarch64_track_speculation", ")", "{", "rtx", "cc_reg", "=", "aarch64_gen_compare_reg", "(", "NE", ",", "scratch", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "GET_MODE", "(", "cc_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ";", "}", "else", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "scratch", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label1", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "else", "aarch64_gen_compare_reg", "(", "NE", ",", "scratch", ",", "const0_rtx", ")", ";", "emit_label", "(", "label2", ")", ";", "if", "(", "strong_zero_p", ")", "aarch64_gen_compare_reg", "(", "NE", ",", "rval", ",", "const0_rtx", ")", ";", "if", "(", "is_mm_sync", "(", "model", ")", ")", "aarch64_emit_post_barrier", "(", "model", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "DecodeStatus", "SystemZDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "Size", "=", "0", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "return", "MCDisassembler", "::", "Fail", ";", "const", "uint8_t", "*", "Table", ";", "if", "(", "Bytes", "[", "0", "]", "<", "0x40", ")", "{", "Size", "=", "2", ";", "Table", "=", "DecoderTable16", ";", "}", "else", "if", "(", "Bytes", "[", "0", "]", "<", "0xc0", ")", "{", "Size", "=", "4", ";", "Table", "=", "DecoderTable32", ";", "}", "else", "{", "Size", "=", "6", ";", "Table", "=", "DecoderTable48", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", "<", "Size", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint64_t", "Inst", "=", "0", ";", "for", "(", "uint64_t", "I", "=", "0", ";", "I", "<", "Size", ";", "++", "I", ")", "Inst", "=", "(", "Inst", "<<", "8", ")", "|", "Bytes", "[", "I", "]", ";", "return", "decodeInstruction", "(", "Table", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "SystemZ", "SystemZ", "0", "2", "0", "0x40", "2", "0", "0xc0", "4", "6", "0", "0", "8" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "HexagonRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "Hexagon", "::", "IntRegsRegClass", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_AArch64_NoRegs_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]

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

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "s390_shift_truncation_mask", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "DImode", "||", "mode", "==", "SImode", "?", "63", ":", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHIFT_TRUNCATION_MASK", "for", "integer", "shifts", "." ]

[ "s390", "63", "0" ]

[]

[ "<s>", "static", "rtx", "riscv_split_integer", "(", "HOST_WIDE_INT", "val", ",", "enum", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "loval", "=", "sext_hwi", "(", "val", ",", "32", ")", ";", "unsigned", "HOST_WIDE_INT", "hival", "=", "sext_hwi", "(", "(", "val", "-", "loval", ")", ">>", "32", ",", "32", ")", ";", "rtx", "hi", "=", "gen_reg_rtx", "(", "mode", ")", ",", "lo", "=", "gen_reg_rtx", "(", "mode", ")", ";", "riscv_move_integer", "(", "hi", ",", "hi", ",", "hival", ")", ";", "riscv_move_integer", "(", "lo", ",", "lo", ",", "loval", ")", ";", "hi", "=", "gen_rtx_fmt_ee", "(", "ASHIFT", ",", "mode", ",", "hi", ",", "GEN_INT", "(", "32", ")", ")", ";", "hi", "=", "force_reg", "(", "mode", ",", "hi", ")", ";", "return", "gen_rtx_fmt_ee", "(", "PLUS", ",", "mode", ",", "hi", ",", "lo", ")", ";", "}", "</s>" ]

[ "Try", "to", "split", "a", "64b", "integer", "into", "32b", "parts", ",", "then", "reassemble", "." ]

[ "riscv", "32", "32", "32", "32" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Multu", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHS", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHU", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Multu", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "true", ",", "false", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "DivRem", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "DivRemU", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "lowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "lowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "lowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "}", "return", "MipsTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "Mips", "Mips", "ISD::LOAD", "ISD::STORE", "ISD::SMUL_LOHI", "MipsISD::Mult", "ISD::UMUL_LOHI", "MipsISD::Multu", "ISD::MULHS", "MipsISD::Mult", "ISD::MULHU", "MipsISD::Multu", "ISD::MUL", "MipsISD::Mult", "ISD::SDIVREM", "MipsISD::DivRem", "ISD::UDIVREM", "MipsISD::DivRemU", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_VOID", "Mips" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "DL", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "MUL", ":", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Mul", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getSizeInBits", "(", ")", ">", "32", ")", "break", ";", "if", "(", "Subtarget", "->", "hasMulU24", "(", ")", "&&", "isU24", "(", "N0", ",", "DAG", ")", "&&", "isU24", "(", "N1", ",", "DAG", ")", ")", "{", "N0", "=", "DAG", ".", "getZExtOrTrunc", "(", "N0", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "N1", "=", "DAG", ".", "getZExtOrTrunc", "(", "N1", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Mul", "=", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "MUL_U24", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", ",", "N1", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "hasMulI24", "(", ")", "&&", "isI24", "(", "N0", ",", "DAG", ")", "&&", "isI24", "(", "N1", ",", "DAG", ")", ")", "{", "N0", "=", "DAG", ".", "getSExtOrTrunc", "(", "N0", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "N1", "=", "DAG", ".", "getSExtOrTrunc", "(", "N1", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Mul", "=", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "MUL_I24", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", ",", "N1", ")", ";", "}", "else", "{", "break", ";", "}", "SDValue", "Reg", "=", "DAG", ".", "getSExtOrTrunc", "(", "Mul", ",", "DL", ",", "VT", ")", ";", "return", "Reg", ";", "}", "case", "AMDGPUISD", "::", "MUL_I24", ":", "case", "AMDGPUISD", "::", "MUL_U24", ":", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "1", ")", ";", "simplifyI24", "(", "N0", ",", "DCI", ")", ";", "simplifyI24", "(", "N1", ",", "DCI", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "R600", "ISD::MUL", "0", "0", "1", "32", "MVT::i32", "MVT::i32", "AMDGPUISD::MUL_U24", "MVT::i32", "MVT::i32", "MVT::i32", "AMDGPUISD::MUL_I24", "MVT::i32", "AMDGPUISD::MUL_I24", "AMDGPUISD::MUL_U24", "0", "1" ]

[]

[ "<s>", "static", "bool", "rx_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "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>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "rx" ]

[]

[ "<s>", "void", "aarch64_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_var", "=", "0", ",", "one_var", "=", "-", "1", ";", "bool", "all_same", "=", "true", ";", "rtx", "x", ",", "mem", ";", "int", "i", ";", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "x", ")", "&&", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "n_var", "=", "1", ",", "one_var", "=", "0", ";", "for", "(", "i", "=", "1", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "x", ")", "&&", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "++", "n_var", ",", "one_var", "=", "i", ";", "if", "(", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "}", "if", "(", "n_var", "==", "0", ")", "{", "rtx", "constant", "=", "aarch64_simd_make_constant", "(", "vals", ")", ";", "if", "(", "constant", "!=", "NULL_RTX", ")", "{", "emit_move_insn", "(", "target", ",", "constant", ")", ";", "return", ";", "}", "}", "if", "(", "all_same", ")", "{", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "aarch64_emit_move", "(", "target", ",", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "x", ")", ")", ";", "return", ";", "}", "if", "(", "n_var", "==", "1", ")", "{", "rtx", "copy", "=", "copy_rtx", "(", "vals", ")", ";", "rtx", "index", "=", "GEN_INT", "(", "one_var", ")", ";", "enum", "insn_code", "icode", ";", "XVECEXP", "(", "copy", ",", "0", ",", "one_var", ")", "=", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", "^", "1", ")", ";", "aarch64_expand_vector_init", "(", "target", ",", "copy", ")", ";", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", ")", ")", ";", "icode", "=", "optab_handler", "(", "vec_set_optab", ",", "mode", ")", ";", "gcc_assert", "(", "icode", "!=", "CODE_FOR_nothing", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "x", ",", "index", ")", ")", ";", "return", ";", "}", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "i", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ")", ";", "emit_move_insn", "(", "target", ",", "mem", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "initialisation", "sequence", ",", "such", "that", "TARGET", "is", "initialised", "to", "contain", "VALS", "." ]

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

[]

[ "<s>", "static", "inline", "int", "andcosts", "(", "rtx", "x", ")", "{", "int", "i", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "1", ";", "i", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "TARGET_SHMEDIA", ")", "{", "if", "(", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "CONST_OK_FOR_I16", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "||", "EXTRA_CONSTRAINT_C16", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "1", ";", "else", "return", "2", ";", "}", "if", "(", "i", "==", "0xff", "||", "i", "==", "0xffff", ")", "return", "1", ";", "if", "(", "CONST_OK_FOR_K08", "(", "i", ")", ")", "return", "2", ";", "if", "(", "CONST_OK_FOR_I08", "(", "i", ")", ")", "return", "2", ";", "return", "3", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "an", "AND", "operation", "." ]

[ "sh", "1", "1", "1", "1", "1", "1", "1", "2", "0xff", "0xffff", "1", "2", "2", "3" ]

[]

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

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

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "static", "const", "char", "*", "avr_out_movhi_r_mr_reg_no_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_dest", "==", "reg_base", ")", "return", "avr_asm_len", "(", "\"ld __tmp_reg__,%1+\"", "CR_TAB", "\"ld %B0,%1\"", "CR_TAB", "\"mov %A0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "avr_asm_len", "(", "\"ld %A0,%1+\"", "CR_TAB", "\"ld %B0,%1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Same", "as", "movhi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", ",", "SBIW", "and", "LDD" ]

[ "avr", "0", "1", "0", "\"ld __tmp_reg__,%1+\"", "\"ld %B0,%1\"", "\"mov %A0,__tmp_reg__\"", "3", "\"ld %A0,%1+\"", "\"ld %B0,%1\"", "2", "1", "2", "\"\"" ]

[]

[ "<s>", "void", "TPCInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "{", "return", "Kind", "==", "k_Token", ";", "}", "</s>" ]

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

[ "SNES" ]

[]

[ "<s>", "bool", "Z80RegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "return", "!", "isFrameOffsetLegal", "(", "MI", ",", "getFrameRegister", "(", "MF", ")", ",", "Offset", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "rtx", "d30v_expand_builtin_saveregs", "(", ")", "{", "int", "offset", "=", "UNITS_PER_WORD", "*", "(", "GPR_ARG_LAST", "+", "1", "-", "GPR_ARG_FIRST", ")", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"expand_builtin_saveregs: offset from ap = %d\\n\"", ",", "offset", ")", ";", "return", "gen_rtx", "(", "PLUS", ",", "Pmode", ",", "virtual_incoming_args_rtx", ",", "GEN_INT", "(", "-", "offset", ")", ")", ";", "}", "</s>" ]

[ "If", "defined", ",", "is", "a", "C", "expression", "that", "produces", "the", "machine-specific", "code", "for", "a", "call", "to", "`", "__builtin_saveregs", "'", ".", "This", "code", "will", "be", "moved", "to", "the", "very", "beginning", "of", "the", "function", ",", "before", "any", "parameter", "access", "are", "made", ".", "The", "return", "value", "of", "this", "function", "should", "be", "an", "RTX", "that", "contains", "the", "value", "to", "use", "as", "the", "return", "of", "`", "__builtin_saveregs", "'", ".", "If", "this", "macro", "is", "not", "defined", ",", "the", "compiler", "will", "output", "an", "ordinary", "call", "to", "the", "library", "function", "`", "__builtin_saveregs", "'", "." ]

[ "d30v", "1", "\"expand_builtin_saveregs: offset from ap = %d\\n\"" ]

[]

[ "<s>", "unsigned", "MipsFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "if", "(", "!", "TargetSupported", ")", "return", "0", ";", "assert", "(", "TLI", ".", "getValueType", "(", "DL", ",", "AI", "->", "getType", "(", ")", ",", "true", ")", "==", "MVT", "::", "i32", "&&", "\"Alloca should always return a pointer.\"", ")", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "&", "Mips", "::", "GPR32RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Mips", "::", "LEA_ADDiu", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ".", "addImm", "(", "0", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "Mips", "Mips", "0", "MVT::i32", "\"Alloca should always return a pointer.\"", "Mips::GPR32RegClass", "Mips::LEA_ADDiu", "0", "0" ]

[]

[ "<s>", "bool", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "override", "{", "switch", "(", "(", "VE", "::", "Fixups", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "VE", "::", "fixup_ve_tls_gd_hi32", ":", "case", "VE", "::", "fixup_ve_tls_gd_lo32", ":", "case", "VE", "::", "fixup_ve_tpoff_hi32", ":", "case", "VE", "::", "fixup_ve_tpoff_lo32", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "VE", "VE::Fixups", "VE::fixup_ve_tls_gd_hi32", "VE::fixup_ve_tls_gd_lo32", "VE::fixup_ve_tpoff_hi32", "VE::fixup_ve_tpoff_lo32" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "canUseAsEpilogue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "MBB", ".", "getParent", "(", ")", "&&", "\"Block is not attached to a function!\"", ")", ";", "if", "(", "STI", ".", "isTargetWin64", "(", ")", "&&", "!", "MBB", ".", "succ_empty", "(", ")", "&&", "!", "MBB", ".", "isReturnBlock", "(", ")", ")", "return", "false", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasSwiftAsyncContext", "(", ")", ")", "return", "!", "flagsNeedToBePreservedBeforeTheTerminators", "(", "MBB", ")", ";", "if", "(", "canUseLEAForSPInEpilogue", "(", "*", "MBB", ".", "getParent", "(", ")", ")", ")", "return", "true", ";", "return", "!", "flagsNeedToBePreservedBeforeTheTerminators", "(", "MBB", ")", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "epilogue", "for", "the", "target", "." ]

[ "X86", "X86", "\"Block is not attached to a function!\"", "X86" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ",", "bool", "ForCodeSize", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", "||", "!", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "if", "(", "Subtarget", ".", "hasPrefixInstrs", "(", ")", ")", "{", "APFloat", "APFloatOfImm", "=", "Imm", ";", "return", "convertToNonDenormSingle", "(", "APFloatOfImm", ")", ";", "}", "LLVM_FALLTHROUGH", ";", "case", "MVT", "::", "ppcf128", ":", "return", "Imm", ".", "isPosZero", "(", ")", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "PowerPC", "PPC", "MVT::f32", "MVT::f64", "MVT::ppcf128" ]

[]

[ "<s>", "const", "char", "*", "rs6000_pltseq_template", "(", "rtx", "*", "operands", ",", "int", "which", ")", "{", "const", "char", "*", "rel64", "=", "TARGET_64BIT", "?", "\"64\"", ":", "\"\"", ";", "char", "tls", "[", "28", "]", ";", "tls", "[", "0", "]", "=", "0", ";", "if", "(", "TARGET_TLS_MARKERS", "&&", "GET_CODE", "(", "operands", "[", "3", "]", ")", "==", "UNSPEC", ")", "{", "if", "(", "XINT", "(", "operands", "[", "3", "]", ",", "1", ")", "==", "UNSPEC_TLSGD", ")", "sprintf", "(", "tls", ",", "\".reloc .,R_PPC%s_TLSGD,%%3\\n\\t\"", ",", "rel64", ")", ";", "else", "if", "(", "XINT", "(", "operands", "[", "3", "]", ",", "1", ")", "==", "UNSPEC_TLSLD", ")", "sprintf", "(", "tls", ",", "\".reloc .,R_PPC%s_TLSLD,%%&\\n\\t\"", ",", "rel64", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "||", "DEFAULT_ABI", "==", "ABI_V4", ")", ";", "static", "char", "str", "[", "96", "]", ";", "const", "char", "*", "off", "=", "WORDS_BIG_ENDIAN", "?", "\"+2\"", ":", "\"\"", ";", "const", "char", "*", "addend", "=", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_SECURE_PLT", "&&", "flag_pic", "==", "2", "?", "\"+32768\"", ":", "\"\"", ")", ";", "switch", "(", "which", ")", "{", "case", "0", ":", "sprintf", "(", "str", ",", "\"%s.reloc .,R_PPC%s_PLTSEQ,%%z2\\n\\t\"", "\"st%s\"", ",", "tls", ",", "rel64", ",", "TARGET_64BIT", "?", "\"d 2,24(1)\"", ":", "\"w 2,12(1)\"", ")", ";", "break", ";", "case", "1", ":", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "!", "flag_pic", ")", "sprintf", "(", "str", ",", "\"%s.reloc .%s,R_PPC%s_PLT16_HA,%%z2\\n\\t\"", "\"lis %%0,0\"", ",", "tls", ",", "off", ",", "rel64", ")", ";", "else", "sprintf", "(", "str", ",", "\"%s.reloc .%s,R_PPC%s_PLT16_HA,%%z2%s\\n\\t\"", "\"addis %%0,%%1,0\"", ",", "tls", ",", "off", ",", "rel64", ",", "addend", ")", ";", "break", ";", "case", "2", ":", "sprintf", "(", "str", ",", "\"%s.reloc .%s,R_PPC%s_PLT16_LO%s,%%z2%s\\n\\t\"", "\"l%s %%0,0(%%1)\"", ",", "tls", ",", "off", ",", "rel64", ",", "TARGET_64BIT", "?", "\"_DS\"", ":", "\"\"", ",", "addend", ",", "TARGET_64BIT", "?", "\"d\"", ":", "\"wz\"", ")", ";", "break", ";", "case", "3", ":", "sprintf", "(", "str", ",", "\"%s.reloc .,R_PPC%s_PLTSEQ,%%z2%s\\n\\t\"", "\"mtctr %%1\"", ",", "tls", ",", "rel64", ",", "addend", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "str", ";", "}", "</s>" ]

[ "Output", "indirect", "call", "insns", ".", "WHICH", "is", "0", "for", "tocsave", ",", "1", "for", "plt16_ha", ",", "2", "for", "plt16_lo", ",", "3", "for", "mtctr", "." ]

[ "rs6000", "\"64\"", "\"\"", "28", "0", "0", "3", "3", "1", "\".reloc .,R_PPC%s_TLSGD,%%3\\n\\t\"", "3", "1", "\".reloc .,R_PPC%s_TLSLD,%%&\\n\\t\"", "96", "\"+2\"", "\"\"", "2", "\"+32768\"", "\"\"", "0", "\"%s.reloc .,R_PPC%s_PLTSEQ,%%z2\\n\\t\"", "\"st%s\"", "\"d 2,24(1)\"", "\"w 2,12(1)\"", "1", "\"%s.reloc .%s,R_PPC%s_PLT16_HA,%%z2\\n\\t\"", "\"lis %%0,0\"", "\"%s.reloc .%s,R_PPC%s_PLT16_HA,%%z2%s\\n\\t\"", "\"addis %%0,%%1,0\"", "2", "\"%s.reloc .%s,R_PPC%s_PLT16_LO%s,%%z2%s\\n\\t\"", "\"l%s %%0,0(%%1)\"", "\"_DS\"", "\"\"", "\"d\"", "\"wz\"", "3", "\"%s.reloc .,R_PPC%s_PLTSEQ,%%z2%s\\n\\t\"", "\"mtctr %%1\"" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Z80 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Z80", "\"Z80 Assembly Printer\"" ]

[]

[ "<s>", "bool", "DirectXTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "raw_pwrite_stream", "&", "Out", ",", "raw_pwrite_stream", "*", "DwoOut", ",", "CodeGenFileType", "FileType", ",", "bool", "DisableVerify", ",", "MachineModuleInfoWrapperPass", "*", "MMIWP", ")", "{", "PM", ".", "add", "(", "createDXILPrepareModulePass", "(", ")", ")", ";", "switch", "(", "FileType", ")", "{", "case", "CGFT_AssemblyFile", ":", "PM", ".", "add", "(", "createPrintModulePass", "(", "Out", ",", "\"\"", ",", "true", ")", ")", ";", "break", ";", "case", "CGFT_ObjectFile", ":", "PM", ".", "add", "(", "createBitcodeWriterPass", "(", "Out", ",", "true", ",", "false", ",", "false", ")", ")", ";", "break", ";", "case", "CGFT_Null", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "DirectX", "DXIL", "\"\"" ]

[]

[ "<s>", "bool", "NVPTXPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "auto", "BlockIter", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "BlockIter", "!=", "MBB", ".", "end", "(", ")", ")", "{", "auto", "&", "MI", "=", "*", "BlockIter", "++", ";", "if", "(", "isCVTAToLocalCombinationCandidate", "(", "MI", ")", ")", "{", "CombineCVTAToLocal", "(", "MI", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "const", "NVPTXRegisterInfo", "*", "NRI", "=", "MF", ".", "getSubtarget", "<", "NVPTXSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "NRI", "->", "getFrameRegister", "(", "MF", ")", ")", ")", "{", "if", "(", "auto", "MI", "=", "MRI", ".", "getUniqueVRegDef", "(", "NRI", "->", "getFrameRegister", "(", "MF", ")", ")", ")", "{", "MI", "->", "eraseFromParentAndMarkDBGValuesForRemoval", "(", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "KudeyarTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "LOAD", ")", "{", "LoadSDNode", "*", "LD", "=", "cast", "<", "LoadSDNode", ">", "(", "N", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "}", "else", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "STORE", ")", "{", "StoreSDNode", "*", "ST", "=", "cast", "<", "StoreSDNode", ">", "(", "N", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "}", "else", "return", "false", ";", "if", "(", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i32", ")", "return", "false", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "return", "false", ";", "if", "(", "ConstantSDNode", "*", "RHS", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ")", "{", "uint64_t", "RHSC", "=", "RHS", "->", "getZExtValue", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i32", "&&", "RHSC", "!=", "4", ")", "||", "(", "VT", "==", "MVT", "::", "i16", "&&", "RHSC", "!=", "2", ")", "||", "(", "VT", "==", "MVT", "::", "i8", "&&", "RHSC", "!=", "1", ")", ")", "return", "false", ";", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "VT", ")", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "Kudeyar", "Kudeyar", "ISD::MemIndexedMode", "ISD::LOAD", "ISD::STORE", "MVT::i8", "MVT::i16", "MVT::i32", "ISD::ADD", "1", "MVT::i32", "4", "MVT::i16", "2", "MVT::i8", "1", "0", "ISD::POST_INC" ]

[]

[ "<s>", "static", "HARD_REG_SET", "sparc_zero_call_used_regs", "(", "HARD_REG_SET", "need_zeroed_hardregs", ")", "{", "for", "(", "unsigned", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "need_zeroed_hardregs", ",", "regno", ")", ")", "{", "if", "(", "regno", ">=", "SPARC_FCC_REG", "||", "(", "regno", ">=", "SPARC_FIRST_FP_REG", "&&", "!", "TARGET_VIS", ")", ")", "CLEAR_HARD_REG_BIT", "(", "need_zeroed_hardregs", ",", "regno", ")", ";", "else", "if", "(", "regno", ">=", "SPARC_FIRST_V9_FP_REG", "&&", "(", "regno", "&", "1", ")", ")", ";", "else", "{", "machine_mode", "mode", ";", "rtx", "reg", ";", "if", "(", "regno", "<", "SPARC_FIRST_FP_REG", ")", "{", "reg", "=", "regno_reg_rtx", "[", "regno", "]", ";", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "}", "else", "{", "mode", "=", "regno", "<", "SPARC_FIRST_V9_FP_REG", "?", "SFmode", ":", "DFmode", ";", "reg", "=", "gen_raw_REG", "(", "mode", ",", "regno", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "}", "}", "return", "need_zeroed_hardregs", ";", "}", "</s>" ]

[ "Implement", "TARGET_ZERO_CALL_USED_REGS", ".", "Generate", "a", "sequence", "of", "instructions", "that", "zero", "registers", "specified", "by", "NEED_ZEROED_HARDREGS", ".", "Return", "the", "ZEROED_HARDREGS", "that", "are", "actually", "zeroed", "." ]

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

[]

[ "<s>", "static", "bool", "branch_needs_nop_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "jump_insn", ";", "if", "(", "dbr_sequence_length", "(", ")", ")", "return", "FALSE", ";", "jump_insn", "=", "next_active_insn", "(", "JUMP_LABEL", "(", "insn", ")", ")", ";", "while", "(", "insn", ")", "{", "insn", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "jump_insn", "==", "insn", ")", "return", "TRUE", ";", "if", "(", "!", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", "||", "extract_asm_operands", "(", "PATTERN", "(", "insn", ")", ")", "!=", "NULL_RTX", ")", "&&", "get_attr_length", "(", "insn", ")", ">", "0", ")", "break", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "INSN", ",", "a", "forward", "jump", "insn", ",", "needs", "a", "nop", "in", "its", "delay", "slot", ".", "This", "occurs", "when", "INSN", "has", "an", "unfilled", "delay", "slot", "and", "is", "followed", "by", "an", "asm", ".", "Disaster", "can", "occur", "if", "the", "asm", "is", "empty", "and", "the", "jump", "branches", "into", "the", "delay", "slot", ".", "So", ",", "we", "add", "a", "nop", "in", "the", "delay", "slot", "when", "this", "occurs", "." ]

[ "pa", "0" ]

[]

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

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

[ "BPF" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "const", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "const", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "emitAlignment", "(", "Align", "(", "4", ")", ")", ";", "for", "(", "auto", "&", "Stub", ":", "Stubs", ")", "emitNonLazySymbolPointer", "(", "*", "OutStreamer", ",", "Stub", ".", "first", ",", "Stub", ".", "second", ")", ";", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "Stubs", "=", "MMIMacho", ".", "GetThreadLocalGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "TLOFMacho", ".", "getThreadLocalPointerSection", "(", ")", ")", ";", "emitAlignment", "(", "Align", "(", "4", ")", ")", ";", "for", "(", "auto", "&", "Stub", ":", "Stubs", ")", "emitNonLazySymbolPointer", "(", "*", "OutStreamer", ",", "Stub", ".", "first", ",", "Stub", ".", "second", ")", ";", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "}", "MCTargetStreamer", "&", "TS", "=", "*", "OutStreamer", "->", "getTargetStreamer", "(", ")", ";", "ARMTargetStreamer", "&", "ATS", "=", "static_cast", "<", "ARMTargetStreamer", "&", ">", "(", "TS", ")", ";", "if", "(", "OptimizationGoals", ">", "0", "&&", "(", "Subtarget", "->", "isTargetAEABI", "(", ")", "||", "Subtarget", "->", "isTargetGNUAEABI", "(", ")", "||", "Subtarget", "->", "isTargetMuslAEABI", "(", ")", ")", ")", "ATS", ".", "emitAttribute", "(", "ARMBuildAttrs", "::", "ABI_optimization_goals", ",", "OptimizationGoals", ")", ";", "OptimizationGoals", "=", "-", "1", ";", "ATS", ".", "finishAttributeSection", "(", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]

[ "ARM", "ARM", "4", "4", "ARM", "ARM", "0", "ARMBuildAttrs::ABI_optimization_goals", "1" ]

[]

[ "<s>", "bool", "PTXAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SetupMachineFunction", "(", "MF", ")", ";", "EmitFunctionDeclaration", "(", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PTX", "PTX" ]

[]

[ "<s>", "int", "arc_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "len", ",", "bool", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "len", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "return", "len", ";", "if", "(", "TARGET_PAD_RETURN", "&&", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_RETURN", ")", "{", "rtx_insn", "*", "prev", "=", "prev_active_insn", "(", "insn", ")", ";", "if", "(", "!", "prev", "||", "!", "(", "prev", "=", "prev_active_insn", "(", "prev", ")", ")", "||", "(", "(", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "?", "CALL_ATTR", "(", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "prev", ")", ")", "->", "insn", "(", "0", ")", ",", "NON_SIBCALL", ")", ":", "CALL_ATTR", "(", "prev", ",", "NON_SIBCALL", ")", ")", ")", "return", "len", "+", "4", ";", "}", "if", "(", "TARGET_ARC600", ")", "{", "rtx_insn", "*", "succ", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "succ", "&&", "INSN_P", "(", "succ", ")", ")", "len", "+=", "arc600_corereg_hazard", "(", "insn", ",", "succ", ")", ";", "}", "extract_constrain_insn_cached", "(", "insn", ")", ";", "return", "len", ";", "}", "</s>" ]

[ "Return", "length", "adjustment", "for", "INSN", "." ]

[ "arc", "0", "4" ]

[]

[ "<s>", "void", "BlackfinRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "assert", "(", "!", "MFI", "->", "hasCalls", "(", ")", "&&", "\"FP elimination on a non-leaf function is not supported\"", ")", ";", "adjustRegister", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "FrameSize", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "UNLINK", ")", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "4", "0", "\"Misaligned frame size\"", "\"FP elimination on a non-leaf function is not supported\"", "BF::SP", "BF::P1", "BF::UNLINK" ]

[]

[ "<s>", "void", "BPFPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "const", "BPFSubtarget", "*", "Subtarget", "=", "getBPFTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "Subtarget", "->", "getHasAlu32", "(", ")", "&&", "!", "DisableMIPeephole", ")", "addPass", "(", "createBPFMIPeepholePass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

[ "BPF", "BPF", "BPF", "BPF", "BPF" ]

[]

[ "<s>", "static", "void", "diagnose_openacc_conflict", "(", "bool", "optval", ",", "const", "char", "*", "optname", ")", "{", "if", "(", "flag_openacc", "&&", "optval", ")", "error", "(", "\"option %s is not supported together with %<-fopenacc%>\"", ",", "optname", ")", ";", "}", "</s>" ]

[ "Issue", "a", "diagnostic", "when", "option", "OPTNAME", "is", "enabled", "(", "as", "indicated", "by", "OPTVAL", ")", "and", "-fopenacc", "is", "also", "enabled", "." ]

[ "nvptx", "\"option %s is not supported together with %<-fopenacc%>\"" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_rev_global", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "poly_uint64", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", "||", "d", "->", "vec_flags", "==", "VEC_ADVSIMD", ")", "return", "false", ";", "if", "(", "!", "d", "->", "perm", ".", "series_p", "(", "0", ",", "1", ",", "nelt", "-", "1", ",", "-", "1", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "rtx", "src", "=", "gen_rtx_UNSPEC", "(", "d", "->", "vmode", ",", "gen_rtvec", "(", "1", ",", "d", "->", "op0", ")", ",", "UNSPEC_REV", ")", ";", "emit_set_insn", "(", "d", "->", "target", ",", "src", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "REV", "insn", ",", "which", "reverses", "elements", "within", "a", "full", "vector", "." ]

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

[]

[ "<s>", "static", "void", "xstormy16_encode_section_info", "(", "tree", "decl", ",", "rtx", "r", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "r", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "(", "lookup_attribute", "(", "\"below100\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "||", "lookup_attribute", "(", "\"BELOW100\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", ")", "{", "rtx", "symbol", "=", "XEXP", "(", "r", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "symbol", ")", "==", "SYMBOL_REF", ")", ";", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "|=", "SYMBOL_FLAG_XSTORMY16_BELOW100", ";", "}", "}", "</s>" ]

[ "Mark", "functions", "with", "SYMBOL_REF_FLAG", "." ]

[ "stormy16", "\"below100\"", "\"BELOW100\"", "0" ]

[]

[ "<s>", "void", "PIC16RegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

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

[ "PIC16", "PIC16" ]

[]

[ "<s>", "uint64_t", "getFeatures", "(", ")", "const", "{", "return", "Features", ";", "}", "</s>" ]

[ "Returns", "the", "vector", "of", "individual", "subtarget", "features", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ",", "uint8_t", "OperandType", ")", "const", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", "||", "OperandType", "<", "AMDGPU", "::", "OPERAND_SRC_FIRST", "||", "OperandType", ">", "AMDGPU", "::", "OPERAND_SRC_LAST", ")", "return", "false", ";", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "switch", "(", "OperandType", ")", "{", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "{", "int32_t", "Trunc", "=", "static_cast", "<", "int32_t", ">", "(", "Imm", ")", ";", "return", "Trunc", "==", "Imm", "&&", "AMDGPU", "::", "isInlinableLiteral32", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP64", ":", "{", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "MO", ".", "getImm", "(", ")", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP16", ":", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "false", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP16", ":", "{", "uint32_t", "Trunc", "=", "static_cast", "<", "uint32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"invalid bitwidth\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "SI", "AMDGPU::OPERAND_SRC_FIRST", "AMDGPU::OPERAND_SRC_LAST", "AMDGPU::OPERAND_REG_IMM_INT32", "AMDGPU::OPERAND_REG_IMM_FP32", "AMDGPU::OPERAND_REG_INLINE_C_INT32", "AMDGPU::OPERAND_REG_INLINE_C_FP32", "AMDGPU::isInlinableLiteral32", "AMDGPU::OPERAND_REG_IMM_INT64", "AMDGPU::OPERAND_REG_IMM_FP64", "AMDGPU::OPERAND_REG_INLINE_C_INT64", "AMDGPU::OPERAND_REG_INLINE_C_FP64", "AMDGPU::isInlinableLiteral64", "AMDGPU::OPERAND_REG_IMM_INT16", "AMDGPU::OPERAND_REG_IMM_FP16", "AMDGPU::OPERAND_REG_INLINE_C_INT16", "AMDGPU::OPERAND_REG_INLINE_C_FP16", "16", "16", "AMDGPU::isInlinableLiteral16", "AMDGPU::OPERAND_REG_INLINE_C_V2INT16", "AMDGPU::OPERAND_REG_INLINE_C_V2FP16", "AMDGPU::isInlinableLiteralV216", "\"invalid bitwidth\"" ]

[]

[ "<s>", "unsigned", "HexagonRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "HexagonFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "return", "Hexagon", "::", "R30", ";", "return", "Hexagon", "::", "R29", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::R30", "Hexagon::R29" ]

[]

[ "<s>", "bool", "WebAssemblyRegNumbering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MFI", ".", "initWARegs", "(", "MRI", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "if", "(", "!", "WebAssembly", "::", "isArgument", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "break", ";", "int64_t", "Imm", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg VReg \"", "<<", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "<<", "\" -> WAReg \"", "<<", "Imm", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "Imm", ")", ";", "}", "unsigned", "NumVRegs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getNumVirtRegs", "(", ")", ";", "unsigned", "NumStackRegs", "=", "0", ";", "unsigned", "CurReg", "=", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ";", "for", "(", "unsigned", "VRegIdx", "=", "0", ";", "VRegIdx", "<", "NumVRegs", ";", "++", "VRegIdx", ")", "{", "Register", "VReg", "=", "Register", "::", "index2VirtReg", "(", "VRegIdx", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "VReg", ")", ")", "continue", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "VReg", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "(", "INT32_MIN", "|", "NumStackRegs", ")", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "INT32_MIN", "|", "NumStackRegs", "++", ")", ";", "continue", ";", "}", "if", "(", "MFI", ".", "getWAReg", "(", "VReg", ")", "==", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "CurReg", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "CurReg", "++", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly::isArgument", "1", "\"Arg VReg \"", "0", "\" -> WAReg \"", "\"\\n\"", "0", "0", "0", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"", "WebAssembly", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"" ]

[]