Datasets:

---

docz1105

/

ComBack

like 9

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

[ "targetHandlesStackFrameRounding", "-", "Returns", "true", "if", "the", "target", "is", "responsible", "for", "rounding", "up", "the", "stack", "frame", "(", "probably", "at", "emitPrologue", "time", ")", "." ]

[ "VE" ]

[]

[ "<s>", "int", "riscv_load_store_insns", "(", "rtx", "mem", ",", "rtx_insn", "*", "insn", ")", "{", "machine_mode", "mode", ";", "bool", "might_split_p", ";", "rtx", "set", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "might_split_p", "=", "true", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ".", "to_constant", "(", ")", "<=", "32", ")", "might_split_p", "=", "false", ";", "else", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ".", "to_constant", "(", ")", "==", "64", ")", "{", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "!", "riscv_split_64bit_move_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "set", ")", ")", ")", "might_split_p", "=", "false", ";", "}", "return", "riscv_address_insns", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "mode", ",", "might_split_p", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "implement", "INSN", ",", "given", "that", "it", "loads", "from", "or", "stores", "to", "MEM", "." ]

[ "riscv", "32", "64", "0" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "unsigned", "ARCInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"Code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "!", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "0", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "!", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "1", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "ARC", "ARC", "\"Code size not handled\"", "0", "0", "1", "1", "2" ]

[]

[ "<s>", "static", "int", "tilepro_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", "&&", "dep_type", "==", "REG_DEP_TRUE", ")", "{", "rtx", "target", "=", "get_jump_target", "(", "insn", ")", ";", "if", "(", "!", "REG_P", "(", "target", ")", "||", "!", "set_of", "(", "target", ",", "dep_insn", ")", ")", "return", "0", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_ADJUST_COST", "." ]

[ "tilepro", "0" ]

[]

[ "<s>", "void", "BPFMIPreEmitPeephole", "::", "initialize", "(", "MachineFunction", "&", "MFParm", ")", "{", "MF", "=", "&", "MFParm", ";", "TRI", "=", "MF", "->", "getSubtarget", "<", "BPFSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** BPF PreEmit peephole pass ***\\n\\n\"", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "BPF", "BPF", "BPF", "\"*** BPF PreEmit peephole pass ***\\n\\n\"" ]

[]

[ "<s>", "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "BoolRC", "=", "TRI", "->", "getBoolRC", "(", ")", ";", "InsertKillCleanups", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", ";", "if", "(", "ST", ".", "isWave32", "(", ")", ")", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B32", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B32", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B32", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B32_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B32_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B32_term", ";", "OrTermrOpc", "=", "AMDGPU", "::", "S_OR_B32_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ";", "Exec", "=", "AMDGPU", "::", "EXEC_LO", ";", "}", "else", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B64", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B64", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B64", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B64_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B64_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B64_term", ";", "OrTermrOpc", "=", "AMDGPU", "::", "S_OR_B64_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "Exec", "=", "AMDGPU", "::", "EXEC", ";", "}", "SmallVector", "<", "MachineInstr", "*", ",", "32", ">", "Worklist", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ";", "BI", "!=", "MF", ".", "end", "(", ")", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "E", ",", "Next", ";", "E", "=", "MBB", "->", "end", "(", ")", ";", "for", "(", "I", "=", "MBB", "->", "begin", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "MachineBasicBlock", "*", "SplitMBB", "=", "MBB", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_IF", ":", "SplitMBB", "=", "process", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "case", "AMDGPU", "::", "SI_LOOP", ":", "case", "AMDGPU", "::", "SI_END_CF", ":", "if", "(", "InsertKillCleanups", ")", "Worklist", ".", "push_back", "(", "&", "MI", ")", ";", "else", "SplitMBB", "=", "process", "(", "MI", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "SplitMBB", "!=", "MBB", ")", "{", "MBB", "=", "Next", "->", "getParent", "(", ")", ";", "E", "=", "MBB", "->", "end", "(", ")", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "Worklist", ")", "process", "(", "*", "MI", ")", ";", "optimizeEndCf", "(", ")", ";", "LoweredEndCf", ".", "clear", "(", ")", ";", "LoweredIf", ".", "clear", "(", ")", ";", "NeedsKillCleanup", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU::S_AND_B32", "AMDGPU::S_OR_B32", "AMDGPU::S_XOR_B32", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_ANDN2_B32_term", "AMDGPU::S_XOR_B32_term", "AMDGPU::S_OR_B32_term", "AMDGPU::S_OR_SAVEEXEC_B32", "AMDGPU::EXEC_LO", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64", "AMDGPU::S_XOR_B64", "AMDGPU::S_MOV_B64_term", "AMDGPU::S_ANDN2_B64_term", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_OR_B64_term", "AMDGPU::S_OR_SAVEEXEC_B64", "AMDGPU::EXEC", "32", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_IF_BREAK", "AMDGPU::SI_LOOP", "AMDGPU::SI_END_CF" ]

[]

[ "<s>", "bool", "F2003fInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "isIndirectBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "F2003f", "::", "KRZx", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "assert", "(", "getMalkrzFromFiMalkrz", "(", "I", "->", "getOpcode", "(", ")", ")", "==", "F2003f", "::", "MALKRZx", "&&", "\"Invalid conditional branch\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "I", "->", "getOpcode", "(", ")", ")", ")", ";", "for", "(", "unsigned", "i", "=", "1", ";", "i", "<", "I", "->", "getNumOperands", "(", ")", ";", "i", "++", ")", "{", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "i", ")", ")", ";", "}", "continue", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "F2003f", "F2003f", "F2003f::KRZx", "0", "0", "0", "F2003f::MALKRZx", "\"Invalid conditional branch\"", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Annotate Uniform Values\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Annotate Uniform Values\"" ]

[]

[ "<s>", "void", "AVRPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR" ]

[]

[ "<s>", "static", "MachineInstr", "*", "findLoopInstr", "(", "MachineBasicBlock", "*", "BB", ",", "int", "EndLoopOp", ",", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "&", "Visited", ")", "{", "int", "LOOPi", ";", "int", "LOOPr", ";", "if", "(", "EndLoopOp", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "LOOPi", "=", "Hexagon", "::", "J2_loop0i", ";", "LOOPr", "=", "Hexagon", "::", "J2_loop0r", ";", "}", "else", "{", "LOOPi", "=", "Hexagon", "::", "J2_loop1i", ";", "LOOPr", "=", "Hexagon", "::", "J2_loop1r", ";", "}", "for", "(", "MachineBasicBlock", "::", "pred_iterator", "PB", "=", "BB", "->", "pred_begin", "(", ")", ",", "PE", "=", "BB", "->", "pred_end", "(", ")", ";", "PB", "!=", "PE", ";", "++", "PB", ")", "{", "if", "(", "!", "Visited", ".", "insert", "(", "*", "PB", ")", ".", "second", ")", "continue", ";", "if", "(", "*", "PB", "==", "BB", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "reverse_instr_iterator", "I", "=", "(", "*", "PB", ")", "->", "instr_rbegin", "(", ")", ",", "E", "=", "(", "*", "PB", ")", "->", "instr_rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "LOOPi", "||", "Opc", "==", "LOOPr", ")", "return", "&", "*", "I", ";", "if", "(", "Opc", "==", "EndLoopOp", ")", "return", "0", ";", "}", "MachineInstr", "*", "loop", "=", "findLoopInstr", "(", "*", "PB", ",", "EndLoopOp", ",", "Visited", ")", ";", "if", "(", "loop", ")", "return", "loop", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Find", "the", "hardware", "loop", "instruction", "used", "to", "set-up", "the", "specified", "loop", "." ]

[ "Hexagon", "8", "Hexagon::ENDLOOP0", "Hexagon::J2_loop0i", "Hexagon::J2_loop0r", "Hexagon::J2_loop1i", "Hexagon::J2_loop1r", "0", "0" ]

[]

[ "<s>", "void", "Initialize", "(", "MCContext", "&", "ctx", ",", "const", "TargetMachine", "&", "TM", ")", "override", "{", "TargetLoweringObjectFile", "::", "Initialize", "(", "ctx", ",", "TM", ")", ";", "TextSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getText", "(", ")", ")", ";", "DataSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getData", "(", ")", ")", ";", "BSSSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "ReadOnlySection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "StaticCtorSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "StaticDtorSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "LSDASection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "EHFrameSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfAbbrevSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfInfoSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfLineSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfFrameSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfPubTypesSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfDebugInlineSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfStrSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfLocSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfARangesSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfRangesSection", "=", "new", "TGSISection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI", "TGSI" ]

[]

[ "<s>", "bool", "X86RetpolineThunks", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "Is64Bit", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ".", "getMMI", "(", ")", ";", "Module", "&", "M", "=", "const_cast", "<", "Module", "&", ">", "(", "*", "MMI", "->", "getModule", "(", ")", ")", ";", "if", "(", "!", "MF", ".", "getName", "(", ")", ".", "startswith", "(", "ThunkNamePrefix", ")", ")", "{", "if", "(", "InsertedThunks", ")", "return", "false", ";", "if", "(", "(", "!", "STI", "->", "useRetpolineIndirectCalls", "(", ")", "&&", "!", "STI", "->", "useRetpolineIndirectBranches", "(", ")", ")", "||", "STI", "->", "useRetpolineExternalThunk", "(", ")", ")", "return", "false", ";", "if", "(", "Is64Bit", ")", "createThunkFunction", "(", "M", ",", "R11ThunkName", ")", ";", "else", "for", "(", "StringRef", "Name", ":", "{", "EAXThunkName", ",", "ECXThunkName", ",", "EDXThunkName", ",", "EDIThunkName", "}", ")", "createThunkFunction", "(", "M", ",", "Name", ")", ";", "InsertedThunks", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Is64Bit", ")", "{", "assert", "(", "MF", ".", "getName", "(", ")", "==", "\"__llvm_retpoline_r11\"", "&&", "\"Should only have an r11 thunk on 64-bit targets\"", ")", ";", "populateThunk", "(", "MF", ",", "X86", "::", "R11", ")", ";", "}", "else", "{", "if", "(", "MF", ".", "getName", "(", ")", "==", "EAXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EAX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "ECXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "ECX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDIThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDI", ")", ";", "else", "llvm_unreachable", "(", "\"Invalid thunk name on x86-32!\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"__llvm_retpoline_r11\"", "\"Should only have an r11 thunk on 64-bit targets\"", "X86::R11", "X86::EAX", "X86::ECX", "X86::EDX", "X86::EDI", "\"Invalid thunk name on x86-32!\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "NVPTXTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'c'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int8RegsRegClass", ")", ";", "case", "'h'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int16RegsRegClass", ")", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int32RegsRegClass", ")", ";", "case", "'l'", ":", "case", "'N'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int64RegsRegClass", ")", ";", "case", "'f'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Float32RegsRegClass", ")", ";", "case", "'d'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Float64RegsRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "1", "0", "0U", "NVPTX::Int8RegsRegClass", "0U", "NVPTX::Int16RegsRegClass", "0U", "NVPTX::Int32RegsRegClass", "0U", "NVPTX::Int64RegsRegClass", "0U", "NVPTX::Float32RegsRegClass", "0U", "NVPTX::Float64RegsRegClass" ]

[]

[ "<s>", "inline", "bool", "isShiftedMask", "(", "uint64_t", "I", ",", "uint64_t", "&", "Width", ",", "uint64_t", "&", "Offset", ")", "{", "if", "(", "!", "isShiftedMask_64", "(", "I", ")", ")", "return", "false", ";", "Width", "=", "countPopulation", "(", "I", ")", ";", "Offset", "=", "countTrailingZeros", "(", "I", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "APInt", "value", "contains", "a", "non-empty", "sequence", "of", "ones", "with", "the", "remainder", "zero", "." ]

[ "M88k" ]

[]

[ "<s>", "bool", "nds32_long_call_p", "(", "rtx", "symbol", ")", "{", "return", "TARGET_CMODEL_LARGE", ";", "}", "</s>" ]

[ "Return", "true", "X", "is", "need", "use", "long", "call", "." ]

[ "nds32" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "AArch64MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "AArch64MachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "2", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "0", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "2", "0" ]

[]

[ "<s>", "static", "bool", "hasReassociableOperands", "(", "const", "MachineInstr", "&", "Inst", ",", "const", "MachineBasicBlock", "*", "MBB", ")", "{", "assert", "(", "(", "Inst", ".", "getNumOperands", "(", ")", "==", "3", "||", "Inst", ".", "getNumOperands", "(", ")", "==", "4", ")", "&&", "\"Reassociation needs binary operators\"", ")", ";", "const", "MachineOperand", "&", "Op1", "=", "Inst", ".", "getOperand", "(", "1", ")", ";", "const", "MachineOperand", "&", "Op2", "=", "Inst", ".", "getOperand", "(", "2", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "Inst", ".", "getNumOperands", "(", ")", "==", "4", ")", "{", "assert", "(", "Inst", ".", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "Inst", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", "&&", "\"Unexpected operand in reassociable instruction\"", ")", ";", "if", "(", "!", "Inst", ".", "getOperand", "(", "3", ")", ".", "isDead", "(", ")", ")", "return", "false", ";", "}", "MachineInstr", "*", "MI1", "=", "nullptr", ";", "MachineInstr", "*", "MI2", "=", "nullptr", ";", "if", "(", "Op1", ".", "isReg", "(", ")", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Op1", ".", "getReg", "(", ")", ")", ")", "MI1", "=", "MRI", ".", "getUniqueVRegDef", "(", "Op1", ".", "getReg", "(", ")", ")", ";", "if", "(", "Op2", ".", "isReg", "(", ")", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Op2", ".", "getReg", "(", ")", ")", ")", "MI2", "=", "MRI", ".", "getUniqueVRegDef", "(", "Op2", ".", "getReg", "(", ")", ")", ";", "if", "(", "MI1", "&&", "MI2", "&&", "MI1", "->", "getParent", "(", ")", "==", "MBB", "&&", "MI2", "->", "getParent", "(", ")", "==", "MBB", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "\\P", "Inst", "has", "reassociable", "operands", "in", "the", "same", "\\P", "MBB", "." ]

[ "X86", "3", "4", "\"Reassociation needs binary operators\"", "1", "2", "4", "3", "3", "X86::EFLAGS", "\"Unexpected operand in reassociable instruction\"", "3" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "-", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "2", "0", "0" ]

[]

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

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "const", "char", "*", "nds32_output_stack_pop", "(", "rtx", "par_rtx", "ATTRIBUTE_UNUSED", ")", "{", "char", "pattern", "[", "100", "]", ";", "rtx", "operands", "[", "3", "]", ";", "int", "rb_callee_saved", "=", "cfun", "->", "machine", "->", "callee_saved_first_gpr_regno", ";", "int", "re_callee_saved", "=", "cfun", "->", "machine", "->", "callee_saved_last_gpr_regno", ";", "if", "(", "TARGET_V3PUSH", "&&", "!", "nds32_isr_function_p", "(", "current_function_decl", ")", "&&", "(", "cfun", "->", "machine", "->", "va_args_size", "==", "0", ")", ")", "{", "int", "sp_adjust", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_callee_saved", ")", ";", "sp_adjust", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", ";", "if", "(", "satisfies_constraint_Iu08", "(", "GEN_INT", "(", "sp_adjust", ")", ")", "&&", "NDS32_DOUBLE_WORD_ALIGN_P", "(", "sp_adjust", ")", "&&", "!", "cfun", "->", "calls_alloca", ")", "operands", "[", "1", "]", "=", "GEN_INT", "(", "sp_adjust", ")", ";", "else", "operands", "[", "1", "]", "=", "GEN_INT", "(", "0", ")", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop25\\t%%0, %%1\"", ")", ";", "}", "else", "{", "int", "pop_en4_only_p", "=", "0", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "rb_callee_saved", ")", ";", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_callee_saved", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "fp_size", "&&", "!", "cfun", "->", "machine", "->", "gp_size", "&&", "!", "cfun", "->", "machine", "->", "lp_size", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "SP_REGNUM", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "SP_REGNUM", ")", "{", "return", "\"\"", ";", "}", "else", "{", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "SP_REGNUM", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "SP_REGNUM", ")", "pop_en4_only_p", "=", "1", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop.s\\t%s{%s%s%s }\"", ",", "pop_en4_only_p", "?", "\"\"", ":", "\"%0, %1, \"", ",", "cfun", "->", "machine", "->", "fp_size", "?", "\" $fp\"", ":", "\"\"", ",", "cfun", "->", "machine", "->", "gp_size", "?", "\" $gp\"", ":", "\"\"", ",", "cfun", "->", "machine", "->", "lp_size", "?", "\" $lp\"", ":", "\"\"", ")", ";", "}", "}", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Function", "to", "output", "stack", "pop", "operation", ".", "We", "need", "to", "deal", "with", "normal", "stack", "pop", "multiple", "or", "stack", "v3pop", "." ]

[ "nds32", "100", "3", "0", "0", "1", "1", "0", "\"pop25\\t%%0, %%1\"", "0", "0", "1", "0", "1", "\"\"", "0", "1", "1", "\"pop.s\\t%s{%s%s%s }\"", "\"\"", "\"%0, %1, \"", "\" $fp\"", "\"\"", "\" $gp\"", "\"\"", "\" $lp\"", "\"\"", "\"\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "ix86_GOT_alias_set", "(", "void", ")", "{", "static", "HOST_WIDE_INT", "set", "=", "-", "1", ";", "if", "(", "set", "==", "-", "1", ")", "set", "=", "new_alias_set", "(", ")", ";", "return", "set", ";", "}", "</s>" ]

[ "Return", "an", "unique", "alias", "set", "for", "the", "GOT", "." ]

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

[]

[ "<s>", "PreservedAnalyses", "NVVMReflectPass", "::", "run", "(", "Function", "&", "F", ",", "FunctionAnalysisManager", "&", "AM", ")", "{", "return", "runNVVMReflect", "(", "F", ",", "SmVersion", ")", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "NVPTX" ]

[]

[ "<s>", "static", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "MCRegisterInfo", "&", ",", "const", "Triple", "&", "TT", ")", "{", "return", "new", "JVMMCAsmInfo", "(", "TT", ")", ";", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "static", "void", "rs6000_darwin_file_start", "(", "void", ")", "{", "static", "const", "struct", "{", "const", "char", "*", "arg", ";", "const", "char", "*", "name", ";", "HOST_WIDE_INT", "if_set", ";", "}", "mapping", "[", "]", "=", "{", "{", "\"ppc64\"", ",", "\"ppc64\"", ",", "MASK_64BIT", "}", ",", "{", "\"970\"", ",", "\"ppc970\"", ",", "OPTION_MASK_PPC_GPOPT", "|", "OPTION_MASK_MFCRF", "\\", "|", "MASK_POWERPC64", "}", ",", "{", "\"power4\"", ",", "\"ppc970\"", ",", "0", "}", ",", "{", "\"G5\"", ",", "\"ppc970\"", ",", "0", "}", ",", "{", "\"7450\"", ",", "\"ppc7450\"", ",", "0", "}", ",", "{", "\"7400\"", ",", "\"ppc7400\"", ",", "OPTION_MASK_ALTIVEC", "}", ",", "{", "\"G4\"", ",", "\"ppc7400\"", ",", "0", "}", ",", "{", "\"750\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"740\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"G3\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"604e\"", ",", "\"ppc604e\"", ",", "0", "}", ",", "{", "\"604\"", ",", "\"ppc604\"", ",", "0", "}", ",", "{", "\"603e\"", ",", "\"ppc603\"", ",", "0", "}", ",", "{", "\"603\"", ",", "\"ppc603\"", ",", "0", "}", ",", "{", "\"601\"", ",", "\"ppc601\"", ",", "0", "}", ",", "{", "NULL", ",", "\"ppc\"", ",", "0", "}", "}", ";", "const", "char", "*", "cpu_id", "=", "\"\"", ";", "size_t", "i", ";", "rs6000_file_start", "(", ")", ";", "darwin_file_start", "(", ")", ";", "if", "(", "rs6000_default_cpu", "!=", "0", "&&", "rs6000_default_cpu", "[", "0", "]", "!=", "'\\0'", ")", "cpu_id", "=", "rs6000_default_cpu", ";", "if", "(", "OPTION_SET_P", "(", "rs6000_cpu_index", ")", ")", "cpu_id", "=", "processor_target_table", "[", "rs6000_cpu_index", "]", ".", "name", ";", "i", "=", "0", ";", "while", "(", "mapping", "[", "i", "]", ".", "arg", "!=", "NULL", "&&", "strcmp", "(", "mapping", "[", "i", "]", ".", "arg", ",", "cpu_id", ")", "!=", "0", "&&", "(", "mapping", "[", "i", "]", ".", "if_set", "&", "rs6000_isa_flags", ")", "==", "0", ")", "i", "++", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.machine %s\\n\"", ",", "mapping", "[", "i", "]", ".", "name", ")", ";", "}", "</s>" ]

[ "Output", "a", ".machine", "directive", "for", "the", "Darwin", "assembler", ",", "and", "call", "the", "generic", "start_file", "routine", "." ]

[ "rs6000", "\"ppc64\"", "\"ppc64\"", "\"970\"", "\"ppc970\"", "\"power4\"", "\"ppc970\"", "0", "\"G5\"", "\"ppc970\"", "0", "\"7450\"", "\"ppc7450\"", "0", "\"7400\"", "\"ppc7400\"", "\"G4\"", "\"ppc7400\"", "0", "\"750\"", "\"ppc750\"", "0", "\"740\"", "\"ppc750\"", "0", "\"G3\"", "\"ppc750\"", "0", "\"604e\"", "\"ppc604e\"", "0", "\"604\"", "\"ppc604\"", "0", "\"603e\"", "\"ppc603\"", "0", "\"603\"", "\"ppc603\"", "0", "\"601\"", "\"ppc601\"", "0", "\"ppc\"", "0", "\"\"", "0", "0", "0", "0", "0", "\"\\t.machine %s\\n\"" ]

[]

[ "<s>", "static", "double", "calc_defect", "(", "double", "x", ",", "int", "constant", ",", "int", "factor", ")", "{", "double", "y0", "=", "(", "constant", "-", "(", "int", ")", "floor", "(", "(", "x", "*", "factor", "*", "64.", ")", ")", ")", "/", "16384.", ";", "double", "y1", "=", "2", "*", "y0", "-", "y0", "*", "y0", "*", "(", "x", "+", "BIAS", "/", "(", "1.", "*", "(", "1LL", "<<", "30", ")", ")", ")", ";", "double", "y2d0", ",", "y2d", ";", "int", "y2d1", ";", "double", "d", ",", "d2", ";", "y1", "=", "floor", "(", "y1", "*", "(", "1024", "*", "1024", "*", "1024", ")", ")", "/", "(", "1024", "*", "1024", "*", "1024", ")", ";", "d", "=", "y1", "-", "1", "/", "x", ";", "if", "(", "d", ">", "max_defect", ")", "{", "max_defect", "=", "d", ";", "max_defect_x", "=", "x", ";", "}", "if", "(", "d", "<", "min_defect", ")", "{", "min_defect", "=", "d", ";", "min_defect_x", "=", "x", ";", "}", "y2d0", "=", "floor", "(", "y1", "*", "x", "*", "(", "1LL", "<<", "60", "-", "16", ")", ")", ";", "y2d1", "=", "(", "int", ")", "(", "long", "long", ")", "y2d0", ";", "y2d", "=", "-", "floor", "(", "(", "y1", "-", "y0", "/", "(", "1", "<<", "30", "-", "14", ")", ")", "*", "y2d1", ")", "/", "(", "1LL", "<<", "44", ")", ";", "d2", "=", "y1", "+", "y2d", "-", "1", "/", "x", ";", "if", "(", "d2", ">", "max_defect2", ")", "{", "max_defect2", "=", "d2", ";", "max_defect2_x", "=", "x", ";", "}", "if", "(", "d2", "<", "min_defect2", ")", "{", "min_defect2", "=", "d2", ";", "min_defect2_x", "=", "x", ";", "}", "note_defect3", "(", "(", "1", "<<", "CUTOFF_BITS", ")", "-", "1", ",", "d2", ",", "y2d", ",", "x", ")", ";", "note_defect3", "(", "1", "<<", "CUTOFF_BITS", ",", "d2", ",", "y2d", ",", "x", ")", ";", "note_defect3", "(", "(", "1U", "<<", "31", ")", "-", "(", "1", "<<", "CUTOFF_BITS", ")", ",", "d2", ",", "y2d", ",", "x", ")", ";", "note_defect3", "(", "(", "1U", "<<", "31", ")", "-", "1", ",", "d2", ",", "y2d", ",", "x", ")", ";", "note_defect3", "(", "-", "1", ",", "d2", ",", "y2d", ",", "x", ")", ";", "note_defect3", "(", "-", "(", "1", "<<", "CUTOFF_BITS", ")", ",", "d2", ",", "y2d", ",", "x", ")", ";", "note_defect3", "(", "(", "1U", "<<", "31", ")", "-", "(", "1", "<<", "CUTOFF_BITS", ")", "+", "1", ",", "d2", ",", "y2d", ",", "x", ")", ";", "note_defect3", "(", "-", "(", "1U", "<<", "31", ")", ",", "d2", ",", "y2d", ",", "x", ")", ";", "return", "d", ";", "}", "</s>" ]

[ "This", "function", "assumes", "32", "bit", "integers", "." ]

[ "sh", "64.", "16384.", "2", "1.", "1LL", "30", "1024", "1024", "1024", "1024", "1024", "1024", "1", "1LL", "60", "16", "1", "30", "14", "1LL", "44", "1", "1", "1", "1", "1U", "31", "1", "1U", "31", "1", "1", "1", "1U", "31", "1", "1", "1U", "31" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isFNegFree", "(", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "f16", ":", "return", "Subtarget", "->", "hasFullFP16", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fneg", "operation", "is", "free", "to", "the", "point", "where", "it", "is", "never", "worthwhile", "to", "replace", "it", "with", "a", "bitwise", "operation", "." ]

[ "ARM", "ARM", "MVT::f16" ]

[]

[ "<s>", "static", "void", "gcn_goacc_reduction_teardown", "(", "gcall", "*", "call", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "tree", "var", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "gimple_seq", "seq", "=", "NULL", ";", "push_gimplify_context", "(", "true", ")", ";", "if", "(", "level", "==", "GOMP_DIM_WORKER", ")", "{", "tree", "var_type", "=", "TREE_TYPE", "(", "var", ")", ";", "tree", "offset", "=", "gimple_call_arg", "(", "call", ",", "5", ")", ";", "tree", "decl", "=", "gcn_goacc_get_worker_red_decl", "(", "var_type", ",", "TREE_INT_CST_LOW", "(", "offset", ")", ")", ";", "var", "=", "decl", ";", "}", "if", "(", "level", "!=", "GOMP_DIM_GANG", ")", "{", "tree", "ref_to_res", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "if", "(", "!", "integer_zerop", "(", "ref_to_res", ")", ")", "gimplify_assign", "(", "build_simple_mem_ref", "(", "ref_to_res", ")", ",", "var", ",", "&", "seq", ")", ";", "}", "if", "(", "lhs", ")", "gimplify_assign", "(", "lhs", ",", "unshare_expr", "(", "var", ")", ",", "&", "seq", ")", ";", "pop_gimplify_context", "(", "NULL", ")", ";", "gsi_replace_with_seq", "(", "&", "gsi", ",", "seq", ",", "true", ")", ";", "}", "</s>" ]

[ "Expand", "IFN_GOACC_REDUCTION_TEARDOWN", "." ]

[ "gcn", "2", "3", "5", "1" ]

[]

[ "<s>", "static", "bool", "xstormy16_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "UNITS_PER_WORD", "*", "NUM_ARGUMENT_REGISTERS", ")", ";", "}", "</s>" ]

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

[ "stormy16", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "MINA32FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32" ]

[]

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

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "CMPPDrri", ":", "case", "X86", "::", "CMPPSrri", ":", "case", "X86", "::", "VCMPPDrri", ":", "case", "X86", "::", "VCMPPSrri", ":", "case", "X86", "::", "VCMPPDYrri", ":", "case", "X86", "::", "VCMPPSYrri", ":", "{", "unsigned", "Imm", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "&", "0x7", ";", "switch", "(", "Imm", ")", "{", "case", "0x00", ":", "case", "0x03", ":", "case", "0x04", ":", "case", "0x07", ":", "return", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "1", ",", "2", ")", ";", "}", "return", "false", ";", "}", "case", "X86", "::", "VFMADDPDr231r", ":", "case", "X86", "::", "VFMADDPSr231r", ":", "case", "X86", "::", "VFMADDSDr231r", ":", "case", "X86", "::", "VFMADDSSr231r", ":", "case", "X86", "::", "VFMSUBPDr231r", ":", "case", "X86", "::", "VFMSUBPSr231r", ":", "case", "X86", "::", "VFMSUBSDr231r", ":", "case", "X86", "::", "VFMSUBSSr231r", ":", "case", "X86", "::", "VFNMADDPDr231r", ":", "case", "X86", "::", "VFNMADDPSr231r", ":", "case", "X86", "::", "VFNMADDSDr231r", ":", "case", "X86", "::", "VFNMADDSSr231r", ":", "case", "X86", "::", "VFNMSUBPDr231r", ":", "case", "X86", "::", "VFNMSUBPSr231r", ":", "case", "X86", "::", "VFNMSUBSDr231r", ":", "case", "X86", "::", "VFNMSUBSSr231r", ":", "case", "X86", "::", "VFMADDPDr231rY", ":", "case", "X86", "::", "VFMADDPSr231rY", ":", "case", "X86", "::", "VFMSUBPDr231rY", ":", "case", "X86", "::", "VFMSUBPSr231rY", ":", "case", "X86", "::", "VFNMADDPDr231rY", ":", "case", "X86", "::", "VFNMADDPSr231rY", ":", "case", "X86", "::", "VFNMSUBPDr231rY", ":", "case", "X86", "::", "VFNMSUBPSr231rY", ":", "return", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "2", ",", "3", ")", ";", "default", ":", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "X86", "X86", "X86::CMPPDrri", "X86::CMPPSrri", "X86::VCMPPDrri", "X86::VCMPPSrri", "X86::VCMPPDYrri", "X86::VCMPPSYrri", "3", "0x7", "0x00", "0x03", "0x04", "0x07", "1", "2", "X86::VFMADDPDr231r", "X86::VFMADDPSr231r", "X86::VFMADDSDr231r", "X86::VFMADDSSr231r", "X86::VFMSUBPDr231r", "X86::VFMSUBPSr231r", "X86::VFMSUBSDr231r", "X86::VFMSUBSSr231r", "X86::VFNMADDPDr231r", "X86::VFNMADDPSr231r", "X86::VFNMADDSDr231r", "X86::VFNMADDSSr231r", "X86::VFNMSUBPDr231r", "X86::VFNMSUBPSr231r", "X86::VFNMSUBSDr231r", "X86::VFNMSUBSSr231r", "X86::VFMADDPDr231rY", "X86::VFMADDPSr231rY", "X86::VFMSUBPDr231rY", "X86::VFMSUBPSr231rY", "X86::VFNMADDPDr231rY", "X86::VFNMADDPSr231rY", "X86::VFNMSUBPDr231rY", "X86::VFNMSUBPSr231rY", "2", "3" ]

[]

[ "<s>", "bool", "SIMachineFunctionInfo", "::", "removeDeadFrameIndices", "(", "MachineFrameInfo", "&", "MFI", ",", "bool", "ResetSGPRSpillStackIDs", ")", "{", "for", "(", "auto", "&", "R", ":", "make_early_inc_range", "(", "SGPRToVGPRSpills", ")", ")", "{", "if", "(", "R", ".", "first", "!=", "FramePointerSaveIndex", "&&", "R", ".", "first", "!=", "BasePointerSaveIndex", ")", "{", "MFI", ".", "RemoveStackObject", "(", "R", ".", "first", ")", ";", "SGPRToVGPRSpills", ".", "erase", "(", "R", ".", "first", ")", ";", "}", "}", "bool", "HaveSGPRToMemory", "=", "false", ";", "if", "(", "ResetSGPRSpillStackIDs", ")", "{", "for", "(", "int", "i", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ",", "e", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "!=", "FramePointerSaveIndex", "&&", "i", "!=", "BasePointerSaveIndex", ")", "{", "if", "(", "MFI", ".", "getStackID", "(", "i", ")", "==", "TargetStackID", "::", "SGPRSpill", ")", "{", "MFI", ".", "setStackID", "(", "i", ",", "TargetStackID", "::", "Default", ")", ";", "HaveSGPRToMemory", "=", "true", ";", "}", "}", "}", "}", "for", "(", "auto", "&", "R", ":", "VGPRToAGPRSpills", ")", "{", "if", "(", "R", ".", "second", ".", "IsDead", ")", "MFI", ".", "RemoveStackObject", "(", "R", ".", "first", ")", ";", "}", "return", "HaveSGPRToMemory", ";", "}", "</s>" ]

[ "If", "ResetSGPRSpillStackIDs", "is", "true", ",", "reset", "the", "stack", "ID", "from", "sgpr-spill", "to", "the", "default", "stack", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "M68kRegisterInfo", "*", "TRI", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", "->", "callsEHReturn", "(", ")", ")", "return", "0", ";", "const", "TargetRegisterClass", "&", "AvailableRegs", "=", "*", "TRI", "->", "getRegsForTailCall", "(", "*", "MF", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "switch", "(", "MBBI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "PATCHABLE_RET", ":", "case", "M68k", "::", "RET", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "for", "(", "auto", "CS", ":", "AvailableRegs", ")", "if", "(", "!", "Uses", ".", "count", "(", "CS", ")", ")", "return", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "M68k", "M68k", "0", "0", "0", "M68k::RET", "8", "0", "0" ]

[]

[ "<s>", "bool", "csky_inlinable_constant", "(", "HOST_WIDE_INT", "value", ")", "{", "HOST_WIDE_INT", "x", ",", "y", ";", "return", "(", "!", "(", "CSKY_TARGET_ARCH", "(", "CK802", ")", "||", "CSKY_TARGET_ARCH", "(", "CK801", ")", ")", "&&", "try_csky_constant_tricks", "(", "value", ",", "&", "x", ",", "&", "y", ")", ")", ";", "}", "</s>" ]

[ "This", "is", "a", "helper", "function", "for", "the", "Uo", "constraint", "for", "movsi", "patterns", "." ]

[ "csky" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "{", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "*", "Fast", "=", "true", ";", "break", ";", "case", "128", ":", "*", "Fast", "=", "!", "Subtarget", ".", "isUnalignedMem16Slow", "(", ")", ";", "break", ";", "case", "256", ":", "*", "Fast", "=", "!", "Subtarget", ".", "isUnalignedMem32Slow", "(", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "X86", "X86", "128", "256" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ",", "unsigned", "&", "MemBytes", ")", "const", "{", "if", "(", "isFrameStoreOpcode", "(", "MI", ".", "getOpcode", "(", ")", ",", "MemBytes", ")", ")", "if", "(", "MI", ".", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "isFrameOperand", "(", "MI", ",", "0", ",", "FrameIndex", ")", ")", "return", "MI", ".", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getReg", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "X86", "X86", "X86::AddrNumOperands", "0", "0", "X86::AddrNumOperands", "0" ]

[]

[ "<s>", "static", "void", "add_to_dispatch_window", "(", "rtx_insn", "*", "insn", ")", "{", "int", "byte_len", ";", "dispatch_windows", "*", "window_list", ";", "dispatch_windows", "*", "next_list", ";", "dispatch_windows", "*", "window0_list", ";", "enum", "insn_path", "path", ";", "enum", "dispatch_group", "insn_group", ";", "bool", "insn_fits", ";", "int", "num_insn", ";", "int", "num_uops", ";", "int", "window_num", ";", "int", "insn_num_uops", ";", "int", "sum", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "<", "0", ")", "return", ";", "byte_len", "=", "ix86_min_insn_size", "(", "insn", ")", ";", "window_list", "=", "dispatch_window_list", ";", "next_list", "=", "window_list", "->", "next", ";", "path", "=", "get_insn_path", "(", "insn", ")", ";", "insn_group", "=", "get_insn_group", "(", "insn", ")", ";", "if", "(", "next_list", ")", "window_list", "=", "dispatch_window_list", "->", "next", ";", "if", "(", "path", "==", "path_single", ")", "insn_num_uops", "=", "1", ";", "else", "if", "(", "path", "==", "path_double", ")", "insn_num_uops", "=", "2", ";", "else", "insn_num_uops", "=", "(", "int", ")", "path", ";", "num_insn", "=", "window_list", "->", "num_insn", ";", "num_uops", "=", "window_list", "->", "num_uops", ";", "window_num", "=", "window_list", "->", "window_num", ";", "insn_fits", "=", "fits_dispatch_window", "(", "insn", ")", ";", "if", "(", "num_insn", ">=", "MAX_INSN", "||", "num_uops", "+", "insn_num_uops", ">", "MAX_INSN", "||", "!", "(", "insn_fits", ")", ")", "{", "window_num", "=", "~", "window_num", "&", "1", ";", "window_list", "=", "allocate_next_window", "(", "window_num", ")", ";", "}", "if", "(", "window_num", "==", "0", ")", "{", "add_insn_window", "(", "insn", ",", "window_list", ",", "insn_num_uops", ")", ";", "if", "(", "window_list", "->", "num_insn", ">=", "MAX_INSN", "&&", "insn_group", "==", "disp_branch", ")", "{", "process_end_window", "(", ")", ";", "return", ";", "}", "}", "else", "if", "(", "window_num", "==", "1", ")", "{", "window0_list", "=", "window_list", "->", "prev", ";", "sum", "=", "window0_list", "->", "window_size", "+", "window_list", "->", "window_size", ";", "if", "(", "sum", "==", "32", "||", "(", "byte_len", "+", "sum", ")", ">=", "48", ")", "{", "process_end_window", "(", ")", ";", "window_list", "=", "dispatch_window_list", ";", "}", "add_insn_window", "(", "insn", ",", "window_list", ",", "insn_num_uops", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "is_end_basic_block", "(", "insn_group", ")", ")", "{", "process_end_window", "(", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Adds", "a", "scheduled", "instruction", ",", "INSN", ",", "to", "the", "current", "dispatch", "window", ".", "If", "the", "total", "bytes", "of", "instructions", "or", "the", "number", "of", "instructions", "in", "the", "window", "exceed", "allowable", ",", "it", "allocates", "a", "new", "window", "." ]

[ "i386", "0", "1", "2", "1", "0", "1", "32", "48" ]

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "OS", ".", "write_zeros", "(", "Count", "%", "4", ")", ";", "Count", "/=", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "Count", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "0xd503201f", ",", "Endian", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "4", "4", "0", "support::endian", "0xd503201f" ]

[]

[ "<s>", "static", "void", "aarch64_validate_sls_mitigation", "(", "const", "char", "*", "const_str", ")", "{", "char", "*", "token_save", "=", "NULL", ";", "char", "*", "str", "=", "NULL", ";", "if", "(", "strcmp", "(", "const_str", ",", "\"none\"", ")", "==", "0", ")", "{", "aarch64_sls_hardening", "=", "SLS_NONE", ";", "return", ";", "}", "if", "(", "strcmp", "(", "const_str", ",", "\"all\"", ")", "==", "0", ")", "{", "aarch64_sls_hardening", "=", "SLS_ALL", ";", "return", ";", "}", "char", "*", "str_root", "=", "xstrdup", "(", "const_str", ")", ";", "str", "=", "strtok_r", "(", "str_root", ",", "\",\"", ",", "&", "token_save", ")", ";", "if", "(", "!", "str", ")", "error", "(", "\"invalid argument given to %<-mharden-sls=%>\"", ")", ";", "int", "temp", "=", "SLS_NONE", ";", "while", "(", "str", ")", "{", "if", "(", "strcmp", "(", "str", ",", "\"blr\"", ")", "==", "0", ")", "temp", "|=", "SLS_BLR", ";", "else", "if", "(", "strcmp", "(", "str", ",", "\"retbr\"", ")", "==", "0", ")", "temp", "|=", "SLS_RETBR", ";", "else", "if", "(", "strcmp", "(", "str", ",", "\"none\"", ")", "==", "0", "||", "strcmp", "(", "str", ",", "\"all\"", ")", "==", "0", ")", "{", "error", "(", "\"%<%s%> must be by itself for %<-mharden-sls=%>\"", ",", "str", ")", ";", "break", ";", "}", "else", "{", "error", "(", "\"invalid argument %<%s%> for %<-mharden-sls=%>\"", ",", "str", ")", ";", "break", ";", "}", "str", "=", "strtok_r", "(", "NULL", ",", "\",\"", ",", "&", "token_save", ")", ";", "}", "aarch64_sls_hardening", "=", "(", "aarch64_sls_hardening_type", ")", "temp", ";", "free", "(", "str_root", ")", ";", "}", "</s>" ]

[ "As", "of", "yet", "we", "only", "allow", "setting", "these", "options", "globally", ",", "in", "the", "future", "we", "may", "allow", "setting", "them", "per", "function", "." ]

[ "aarch64", "\"none\"", "0", "\"all\"", "0", "\",\"", "\"invalid argument given to %<-mharden-sls=%>\"", "\"blr\"", "0", "\"retbr\"", "0", "\"none\"", "0", "\"all\"", "0", "\"%<%s%> must be by itself for %<-mharden-sls=%>\"", "\"invalid argument %<%s%> for %<-mharden-sls=%>\"", "\",\"" ]

[]

[ "<s>", "MSP430Subtarget", "&", "MSP430Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "ParseSubtargetFeatures", "(", "\"generic\"", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "\"generic\"" ]

[]

[ "<s>", "static", "char", "*", "vms_construct_include_filename", "(", "const", "char", "*", "fname", ",", "cpp_dir", "*", "dir", ")", "{", "size_t", "dlen", ",", "flen", ";", "char", "*", "path", ";", "const", "char", "*", "fbasename", "=", "lbasename", "(", "fname", ")", ";", "size_t", "i", ";", "dlen", "=", "dir", "->", "len", ";", "flen", "=", "strlen", "(", "fbasename", ")", "+", "2", ";", "path", "=", "XNEWVEC", "(", "char", ",", "dlen", "+", "1", "+", "flen", "+", "1", ")", ";", "memcpy", "(", "path", ",", "dir", "->", "name", ",", "dlen", ")", ";", "if", "(", "dlen", "&&", "!", "IS_DIR_SEPARATOR", "(", "path", "[", "dlen", "-", "1", "]", ")", ")", "path", "[", "dlen", "++", "]", "=", "'/'", ";", "for", "(", "i", "=", "0", ";", "i", "<", "flen", ";", "i", "++", ")", "if", "(", "fbasename", "[", "i", "]", "==", "'.'", ")", "break", ";", "else", "path", "[", "dlen", "+", "i", "]", "=", "TOLOWER", "(", "fbasename", "[", "i", "]", ")", ";", "path", "[", "dlen", "+", "i", "+", "0", "]", "=", "'.'", ";", "path", "[", "dlen", "+", "i", "+", "1", "]", "=", "'h'", ";", "path", "[", "dlen", "+", "i", "+", "2", "]", "=", "0", ";", "return", "path", ";", "}", "</s>" ]

[ "Canonicalize", "the", "filename", "(", "remove", "directory", "prefix", ",", "force", "the", ".h", "extension", ")", ",", "and", "append", "it", "to", "the", "directory", "to", "create", "the", "path", ",", "but", "do", "n't", "turn", "/", "into", "//", "or", "//", "into", "///", ";", "//", "may", "be", "a", "namespace", "escape", "." ]

[ "vms", "2", "1", "1", "1", "0", "0", "1", "2", "0" ]

[]

[ "<s>", "const", "char", "*", "NVPTXTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "NVPTXISD", "::", "CALL", ":", "return", "\"NVPTXISD::CALL\"", ";", "case", "NVPTXISD", "::", "RET_FLAG", ":", "return", "\"NVPTXISD::RET_FLAG\"", ";", "case", "NVPTXISD", "::", "Wrapper", ":", "return", "\"NVPTXISD::Wrapper\"", ";", "case", "NVPTXISD", "::", "NVBuiltin", ":", "return", "\"NVPTXISD::NVBuiltin\"", ";", "case", "NVPTXISD", "::", "DeclareParam", ":", "return", "\"NVPTXISD::DeclareParam\"", ";", "case", "NVPTXISD", "::", "DeclareScalarParam", ":", "return", "\"NVPTXISD::DeclareScalarParam\"", ";", "case", "NVPTXISD", "::", "DeclareRet", ":", "return", "\"NVPTXISD::DeclareRet\"", ";", "case", "NVPTXISD", "::", "DeclareRetParam", ":", "return", "\"NVPTXISD::DeclareRetParam\"", ";", "case", "NVPTXISD", "::", "PrintCall", ":", "return", "\"NVPTXISD::PrintCall\"", ";", "case", "NVPTXISD", "::", "LoadParam", ":", "return", "\"NVPTXISD::LoadParam\"", ";", "case", "NVPTXISD", "::", "StoreParam", ":", "return", "\"NVPTXISD::StoreParam\"", ";", "case", "NVPTXISD", "::", "StoreParamS32", ":", "return", "\"NVPTXISD::StoreParamS32\"", ";", "case", "NVPTXISD", "::", "StoreParamU32", ":", "return", "\"NVPTXISD::StoreParamU32\"", ";", "case", "NVPTXISD", "::", "MoveToParam", ":", "return", "\"NVPTXISD::MoveToParam\"", ";", "case", "NVPTXISD", "::", "CallArgBegin", ":", "return", "\"NVPTXISD::CallArgBegin\"", ";", "case", "NVPTXISD", "::", "CallArg", ":", "return", "\"NVPTXISD::CallArg\"", ";", "case", "NVPTXISD", "::", "LastCallArg", ":", "return", "\"NVPTXISD::LastCallArg\"", ";", "case", "NVPTXISD", "::", "CallArgEnd", ":", "return", "\"NVPTXISD::CallArgEnd\"", ";", "case", "NVPTXISD", "::", "CallVoid", ":", "return", "\"NVPTXISD::CallVoid\"", ";", "case", "NVPTXISD", "::", "CallVal", ":", "return", "\"NVPTXISD::CallVal\"", ";", "case", "NVPTXISD", "::", "CallSymbol", ":", "return", "\"NVPTXISD::CallSymbol\"", ";", "case", "NVPTXISD", "::", "Prototype", ":", "return", "\"NVPTXISD::Prototype\"", ";", "case", "NVPTXISD", "::", "MoveParam", ":", "return", "\"NVPTXISD::MoveParam\"", ";", "case", "NVPTXISD", "::", "MoveRetval", ":", "return", "\"NVPTXISD::MoveRetval\"", ";", "case", "NVPTXISD", "::", "MoveToRetval", ":", "return", "\"NVPTXISD::MoveToRetval\"", ";", "case", "NVPTXISD", "::", "StoreRetval", ":", "return", "\"NVPTXISD::StoreRetval\"", ";", "case", "NVPTXISD", "::", "PseudoUseParam", ":", "return", "\"NVPTXISD::PseudoUseParam\"", ";", "case", "NVPTXISD", "::", "RETURN", ":", "return", "\"NVPTXISD::RETURN\"", ";", "case", "NVPTXISD", "::", "CallSeqBegin", ":", "return", "\"NVPTXISD::CallSeqBegin\"", ";", "case", "NVPTXISD", "::", "CallSeqEnd", ":", "return", "\"NVPTXISD::CallSeqEnd\"", ";", "case", "NVPTXISD", "::", "LoadV2", ":", "return", "\"NVPTXISD::LoadV2\"", ";", "case", "NVPTXISD", "::", "LoadV4", ":", "return", "\"NVPTXISD::LoadV4\"", ";", "case", "NVPTXISD", "::", "LDGV2", ":", "return", "\"NVPTXISD::LDGV2\"", ";", "case", "NVPTXISD", "::", "LDGV4", ":", "return", "\"NVPTXISD::LDGV4\"", ";", "case", "NVPTXISD", "::", "LDUV2", ":", "return", "\"NVPTXISD::LDUV2\"", ";", "case", "NVPTXISD", "::", "LDUV4", ":", "return", "\"NVPTXISD::LDUV4\"", ";", "case", "NVPTXISD", "::", "StoreV2", ":", "return", "\"NVPTXISD::StoreV2\"", ";", "case", "NVPTXISD", "::", "StoreV4", ":", "return", "\"NVPTXISD::StoreV4\"", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "NVPTXISD::CALL", "\"NVPTXISD::CALL\"", "NVPTXISD::RET_FLAG", "\"NVPTXISD::RET_FLAG\"", "NVPTXISD::Wrapper", "\"NVPTXISD::Wrapper\"", "NVPTXISD::NVBuiltin", "\"NVPTXISD::NVBuiltin\"", "NVPTXISD::DeclareParam", "\"NVPTXISD::DeclareParam\"", "NVPTXISD::DeclareScalarParam", "\"NVPTXISD::DeclareScalarParam\"", "NVPTXISD::DeclareRet", "\"NVPTXISD::DeclareRet\"", "NVPTXISD::DeclareRetParam", "\"NVPTXISD::DeclareRetParam\"", "NVPTXISD::PrintCall", "\"NVPTXISD::PrintCall\"", "NVPTXISD::LoadParam", "\"NVPTXISD::LoadParam\"", "NVPTXISD::StoreParam", "\"NVPTXISD::StoreParam\"", "NVPTXISD::StoreParamS32", "\"NVPTXISD::StoreParamS32\"", "NVPTXISD::StoreParamU32", "\"NVPTXISD::StoreParamU32\"", "NVPTXISD::MoveToParam", "\"NVPTXISD::MoveToParam\"", "NVPTXISD::CallArgBegin", "\"NVPTXISD::CallArgBegin\"", "NVPTXISD::CallArg", "\"NVPTXISD::CallArg\"", "NVPTXISD::LastCallArg", "\"NVPTXISD::LastCallArg\"", "NVPTXISD::CallArgEnd", "\"NVPTXISD::CallArgEnd\"", "NVPTXISD::CallVoid", "\"NVPTXISD::CallVoid\"", "NVPTXISD::CallVal", "\"NVPTXISD::CallVal\"", "NVPTXISD::CallSymbol", "\"NVPTXISD::CallSymbol\"", "NVPTXISD::Prototype", "\"NVPTXISD::Prototype\"", "NVPTXISD::MoveParam", "\"NVPTXISD::MoveParam\"", "NVPTXISD::MoveRetval", "\"NVPTXISD::MoveRetval\"", "NVPTXISD::MoveToRetval", "\"NVPTXISD::MoveToRetval\"", "NVPTXISD::StoreRetval", "\"NVPTXISD::StoreRetval\"", "NVPTXISD::PseudoUseParam", "\"NVPTXISD::PseudoUseParam\"", "NVPTXISD::RETURN", "\"NVPTXISD::RETURN\"", "NVPTXISD::CallSeqBegin", "\"NVPTXISD::CallSeqBegin\"", "NVPTXISD::CallSeqEnd", "\"NVPTXISD::CallSeqEnd\"", "NVPTXISD::LoadV2", "\"NVPTXISD::LoadV2\"", "NVPTXISD::LoadV4", "\"NVPTXISD::LoadV4\"", "NVPTXISD::LDGV2", "\"NVPTXISD::LDGV2\"", "NVPTXISD::LDGV4", "\"NVPTXISD::LDGV4\"", "NVPTXISD::LDUV2", "\"NVPTXISD::LDUV2\"", "NVPTXISD::LDUV4", "\"NVPTXISD::LDUV4\"", "NVPTXISD::StoreV2", "\"NVPTXISD::StoreV2\"", "NVPTXISD::StoreV4", "\"NVPTXISD::StoreV4\"" ]

[]

[ "<s>", "bool", "RISCVGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "RISCVTargetMachine", ">", "(", ")", ";", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasVInstructions", "(", ")", "||", "!", "ST", "->", "useRVVForFixedLengthVectors", "(", ")", ")", "return", "false", ";", "TLI", "=", "ST", "->", "getTargetLowering", "(", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Gathers", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Scatters", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", "&&", "isa", "<", "FixedVectorType", ">", "(", "II", "->", "getType", "(", ")", ")", ")", "{", "Gathers", ".", "push_back", "(", "II", ")", ";", "}", "else", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_scatter", "&&", "isa", "<", "FixedVectorType", ">", "(", "II", "->", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ")", "{", "Scatters", ".", "push_back", "(", "II", ")", ";", "}", "}", "}", "for", "(", "auto", "*", "II", ":", "Gathers", ")", "Changed", "|=", "tryCreateStridedLoadStore", "(", "II", ",", "II", "->", "getType", "(", ")", ",", "II", "->", "getArgOperand", "(", "0", ")", ",", "II", "->", "getArgOperand", "(", "1", ")", ")", ";", "for", "(", "auto", "*", "II", ":", "Scatters", ")", "Changed", "|=", "tryCreateStridedLoadStore", "(", "II", ",", "II", "->", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ",", "II", "->", "getArgOperand", "(", "1", ")", ",", "II", "->", "getArgOperand", "(", "2", ")", ")", ";", "while", "(", "!", "MaybeDeadPHIs", ".", "empty", "(", ")", ")", "{", "if", "(", "auto", "*", "Phi", "=", "dyn_cast_or_null", "<", "PHINode", ">", "(", "MaybeDeadPHIs", ".", "pop_back_val", "(", ")", ")", ")", "RecursivelyDeleteDeadPHINode", "(", "Phi", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "4", "4", "Intrinsic::masked_gather", "Intrinsic::masked_scatter", "0", "0", "1", "0", "1", "2" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "rbegin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "rend", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "StrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPXi", ":", "AArch64", "::", "STRXui", ";", "else", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPDi", ":", "AArch64", "::", "STRDui", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR spill: (\"", "<<", "printReg", "(", "Reg1", ",", "TRI", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "printReg", "(", "Reg2", ",", "TRI", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg1", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg2", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg2", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "AArch64::STPXi", "AArch64::STRXui", "AArch64::STPDi", "AArch64::STRDui", "\"CSR spill: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8" ]

[]

[ "<s>", "int", "ARMTTIImpl", "::", "getIntImmCodeSizeCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "if", "(", "Imm", ".", "isNonNegative", "(", ")", "&&", "Imm", ".", "getLimitedValue", "(", ")", "<", "256", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "for", "the", "given", "integer", "when", "optimising", "for", "size", "." ]

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

[]

[ "<s>", "void", "rs6000_secondary_reload_gpr", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "int", "regno", "=", "true_regnum", "(", "reg", ")", ";", "enum", "reg_class", "rclass", ";", "rtx", "addr", ";", "rtx", "scratch_or_premodify", "=", "scratch", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nrs6000_secondary_reload_gpr, type = %s\\n\"", ",", "store_p", "?", "\"store\"", ":", "\"load\"", ")", ";", "fprintf", "(", "stderr", ",", "\"reg:\\n\"", ")", ";", "debug_rtx", "(", "reg", ")", ";", "fprintf", "(", "stderr", ",", "\"mem:\\n\"", ")", ";", "debug_rtx", "(", "mem", ")", ";", "fprintf", "(", "stderr", ",", "\"scratch:\\n\"", ")", ";", "debug_rtx", "(", "scratch", ")", ";", "}", "gcc_assert", "(", "regno", ">=", "0", "&&", "regno", "<", "FIRST_PSEUDO_REGISTER", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "mem", ")", "==", "MEM", ")", ";", "rclass", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "gcc_assert", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", ")", "{", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "PLUS", "&&", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", "==", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "scratch_or_premodify", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "!", "HARD_REGISTER_P", "(", "scratch_or_premodify", ")", ")", "scratch_or_premodify", "=", "find_replacement", "(", "&", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", ";", "rs6000_emit_move", "(", "scratch_or_premodify", ",", "addr", ",", "Pmode", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "scratch_or_premodify", ")", ";", "if", "(", "store_p", ")", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "return", ";", "}", "</s>" ]

[ "Convert", "reloads", "involving", "64-bit", "gprs", "and", "misaligned", "offset", "addressing", ",", "or", "multiple", "32-bit", "gprs", "and", "offsets", "that", "are", "too", "large", ",", "to", "use", "indirect", "addressing", "." ]

[ "powerpcspe", "\"\\nrs6000_secondary_reload_gpr, type = %s\\n\"", "\"store\"", "\"load\"", "\"reg:\\n\"", "\"mem:\\n\"", "\"scratch:\\n\"", "0", "0", "0", "1", "1", "0", "0", "0", "0", "1" ]

[]

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

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "WebAssemblyInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "auto", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", "?", "MRI", ".", "getRegClass", "(", "DestReg", ")", ":", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getMinimalPhysRegClass", "(", "DestReg", ")", ";", "unsigned", "CopyOpcode", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "V128RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_V128", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "EXNREFRegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_EXNREF", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CopyOpcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillSrc", "?", "RegState", "::", "Kill", ":", "0", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::COPY_I32", "WebAssembly::I64RegClass", "WebAssembly::COPY_I64", "WebAssembly::F32RegClass", "WebAssembly::COPY_F32", "WebAssembly::F64RegClass", "WebAssembly::COPY_F64", "WebAssembly::V128RegClass", "WebAssembly::COPY_V128", "WebAssembly::EXNREFRegClass", "WebAssembly::COPY_EXNREF", "\"Unexpected register class\"", "0" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "if", "(", "!", "mnemonicIsValid", "(", "Name", ",", "0", ")", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "NameLoc", ",", "\"unknown instruction\"", ")", ";", "}", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LParen", ")", "&&", "parseParenSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "\"unknown instruction\"", "RISCV", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "static", "void", "aarch64_add_cfa_expression", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ",", "rtx", "base", ",", "poly_int64", "offset", ")", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "GET_MODE", "(", "reg", ")", ",", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_EXPRESSION", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "REG_CFA_EXPRESSION", "note", "to", "INSN", "to", "say", "that", "register", "REG", "is", "saved", "at", "BASE", "+", "OFFSET", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "c6x_can_output_mi_thunk", "(", "const_tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "vcall_offset", "ATTRIBUTE_UNUSED", ",", "const_tree", "function", "ATTRIBUTE_UNUSED", ")", "{", "return", "!", "TARGET_LONG_CALLS", ";", "}", "</s>" ]

[ "Determine", "whether", "c6x_output_mi_thunk", "can", "succeed", "." ]

[ "c6x" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "unsigned", "ValVReg", ",", "unsigned", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "MIB", ".", "addUse", "(", "PhysReg", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ValVReg", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "int", "MipsAsmParser", "::", "tryParseRegister", "(", "StringRef", "Mnemonic", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "int", "RegNum", "=", "-", "1", ";", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "RegNum", "=", "matchRegisterName", "(", "lowerCase", ")", ";", "}", "else", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Integer", ")", ")", "RegNum", "=", "matchRegisterByNumber", "(", "static_cast", "<", "unsigned", ">", "(", "Tok", ".", "getIntVal", "(", ")", ")", ",", "Mnemonic", ".", "lower", "(", ")", ")", ";", "else", "return", "RegNum", ";", "if", "(", "isMips64", "(", ")", "&&", "RegNum", "==", "Mips", "::", "ZERO_64", ")", "{", "if", "(", "Mnemonic", ".", "find", "(", "\"ddiv\"", ")", "!=", "StringRef", "::", "npos", ")", "RegNum", "=", "Mips", "::", "ZERO", ";", "}", "return", "RegNum", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "Mips", "Mips::ZERO_64", "\"ddiv\"", "Mips::ZERO" ]

[]

[ "<s>", "bool", "AMDGPUInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "const", "{", "if", "(", "!", "isPreISelGenericOpcode", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCOPY", "(", "I", ")", ";", "return", "true", ";", "}", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "return", "selectG_ADD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTTOPTR", ":", "case", "TargetOpcode", "::", "G_BITCAST", ":", "return", "selectCOPY", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "return", "selectG_CONSTANT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT", ":", "return", "selectG_EXTRACT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "selectG_GEP", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "return", "selectG_IMPLICIT_DEF", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INSERT", ":", "return", "selectG_INSERT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC", ":", "return", "selectG_INTRINSIC", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", ":", "return", "selectG_INTRINSIC_W_SIDE_EFFECTS", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "if", "(", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ")", "return", "true", ";", "return", "selectG_LOAD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "selectG_STORE", "(", "I", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

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

[]

[ "<s>", "bool", "Thumb1RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVtgpr2gpr", ")", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "bool", "done", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "I", ";", "!", "done", "&&", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugValue", "(", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "II", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isUndef", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "R12", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "}", "}", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVgpr2tgpr", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "ARM", "ARM::tMOVtgpr2gpr", "ARM::R12", "0", "ARM::R12", "ARM::tMOVgpr2tgpr", "ARM::R12" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCFrameLowering", "*", "PPCFI", "=", "static_cast", "<", "const", "PPCFrameLowering", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "ZERO", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "ZERO8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "FP8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "CTR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "CTR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "RM", ")", ";", "if", "(", "!", "Subtarget", ".", "isDarwinABI", "(", ")", "||", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X13", ")", ";", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "X31", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "X2", ")", ";", "}", "}", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "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", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::ZERO8", "PPC::FP", "PPC::FP8", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC::R2", "PPC::R13", "PPC", "PPC::R13", "PPC::X1", "PPC::X13", "PPC", "PPC::X31", "PPC::X2", "PPC", "PPC::R31", "PPC::VRRCRegClass", "PPC::VRRCRegClass" ]

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "C", ")", "{", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "C", ")", ")", "return", "0", ";", "assert", "(", "C", "->", "isStaticAlloca", "(", ")", "&&", "\"dynamic alloca in the static alloca map?\"", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "C", ",", "AM", ")", ")", "return", "0", ";", "unsigned", "Opc", "=", "TLI", ".", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", "?", "(", "Subtarget", "->", "isTarget64BitILP32", "(", ")", "?", "X86", "::", "LEA64_32r", ":", "X86", "::", "LEA32r", ")", ":", "X86", "::", "LEA64r", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "TLI", ".", "getPointerTy", "(", ")", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "addFullAddress", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ",", "AM", ")", ";", "return", "ResultReg", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"dynamic alloca in the static alloca map?\"", "X86", "X86", "0", "MVT::i32", "X86::LEA64_32r", "X86::LEA32r", "X86::LEA64r" ]

[]

[ "<s>", "unsigned", "size", "(", ")", "const", "{", "return", "List", ".", "size", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ",", "MaybeAlign", "Alignment", ")", "{", "if", "(", "!", "EnableMaskedLoadStores", "||", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "VecTy", "=", "dyn_cast", "<", "FixedVectorType", ">", "(", "DataTy", ")", ")", "{", "if", "(", "VecTy", "->", "getNumElements", "(", ")", "==", "2", ")", "return", "false", ";", "unsigned", "VecWidth", "=", "DataTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "VecWidth", "!=", "128", "&&", "VecTy", "->", "getElementType", "(", ")", "->", "isFloatingPointTy", "(", ")", ")", "return", "false", ";", "}", "unsigned", "EltWidth", "=", "DataTy", "->", "getScalarSizeInBits", "(", ")", ";", "return", "(", "EltWidth", "==", "32", "&&", "(", "!", "Alignment", "||", "*", "Alignment", ">=", "4", ")", ")", "||", "(", "EltWidth", "==", "16", "&&", "(", "!", "Alignment", "||", "*", "Alignment", ">=", "2", ")", ")", "||", "(", "EltWidth", "==", "8", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "2", "128", "32", "4", "16", "2", "8" ]

[]

[ "<s>", "static", "void", "avr_asm_final_postscan_insn", "(", "FILE", "*", "stream", ",", "rtx_insn", "*", "insn", ",", "rtx", "*", ",", "int", ")", "{", "if", "(", "cfun", "->", "machine", "->", "gasisr", ".", "yes", "&&", "!", "next_real_insn", "(", "insn", ")", ")", "{", "app_disable", "(", ")", ";", "fprintf", "(", "stream", ",", "\"\\t__gcc_isr %d,r%d\\n\"", ",", "GASISR_Done", ",", "cfun", "->", "machine", "->", "gasisr", ".", "regno", ")", ";", "}", "}", "</s>" ]

[ "When", "GAS", "generates", "(", "parts", "of", ")", "ISR", "prologue", "/", "epilogue", "for", "us", ",", "we", "must", "hint", "GAS", "about", "the", "end", "of", "the", "code", "to", "scan", ".", "There", "migh", "be", "code", "located", "after", "the", "last", "epilogue", "." ]

[ "avr", "\"\\t__gcc_isr %d,r%d\\n\"" ]

[]

[ "<s>", "bool", "AArch64PromoteConstant", "::", "runOnFunction", "(", "Function", "&", "F", ",", "PromotionCacheTy", "&", "PromotionCache", ")", "{", "SmallVector", "<", "UpdateRecord", ",", "64", ">", "Updates", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "&", "F", ")", ")", "{", "for", "(", "Use", "&", "U", ":", "I", ".", "operands", "(", ")", ")", "{", "Constant", "*", "Cst", "=", "dyn_cast", "<", "Constant", ">", "(", "U", ")", ";", "if", "(", "!", "Cst", "||", "isa", "<", "GlobalValue", ">", "(", "Cst", ")", "||", "isa", "<", "ConstantExpr", ">", "(", "Cst", ")", ")", "continue", ";", "if", "(", "!", "shouldConvert", "(", "*", "Cst", ",", "PromotionCache", ")", ")", "continue", ";", "unsigned", "OpNo", "=", "&", "U", "-", "I", ".", "op_begin", "(", ")", ";", "if", "(", "!", "shouldConvertUse", "(", "Cst", ",", "&", "I", ",", "OpNo", ")", ")", "continue", ";", "Updates", ".", "emplace_back", "(", "Cst", ",", "&", "I", ",", "OpNo", ")", ";", "}", "}", "if", "(", "Updates", ".", "empty", "(", ")", ")", "return", "false", ";", "promoteConstants", "(", "F", ",", "Updates", ",", "PromotionCache", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

[]

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

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

[ "M680x0", "M680x0" ]

[]

[ "<s>", "void", "AMDGPUUnifyDivergentExitNodes", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "BreakCriticalEdgesID", ")", ";", "AU", ".", "addPreservedID", "(", "LowerSwitchID", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "PTXInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "unsigned", "RegSpace", "=", "RegNo", "&", "0x7", ";", "unsigned", "RegType", "=", "(", "RegNo", ">>", "3", ")", "&", "0x7", ";", "unsigned", "RegOffset", "=", "RegNo", ">>", "6", ";", "OS", "<<", "\"%\"", ";", "switch", "(", "RegSpace", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown register space!\"", ")", ";", "case", "PTXRegisterSpace", "::", "Reg", ":", "switch", "(", "RegType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown register type!\"", ")", ";", "case", "PTXRegisterType", "::", "Pred", ":", "OS", "<<", "\"p\"", ";", "break", ";", "case", "PTXRegisterType", "::", "B16", ":", "OS", "<<", "\"rh\"", ";", "break", ";", "case", "PTXRegisterType", "::", "B32", ":", "OS", "<<", "\"r\"", ";", "break", ";", "case", "PTXRegisterType", "::", "B64", ":", "OS", "<<", "\"rd\"", ";", "break", ";", "case", "PTXRegisterType", "::", "F32", ":", "OS", "<<", "\"f\"", ";", "break", ";", "case", "PTXRegisterType", "::", "F64", ":", "OS", "<<", "\"fd\"", ";", "break", ";", "}", "break", ";", "case", "PTXRegisterSpace", "::", "Return", ":", "OS", "<<", "\"ret\"", ";", "break", ";", "case", "PTXRegisterSpace", "::", "Argument", ":", "OS", "<<", "\"arg\"", ";", "break", ";", "}", "OS", "<<", "RegOffset", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "0x7", "3", "0x7", "6", "\"%\"", "\"Unknown register space!\"", "PTXRegisterSpace::Reg", "\"Unknown register type!\"", "PTXRegisterType::Pred", "\"p\"", "PTXRegisterType::B16", "\"rh\"", "PTXRegisterType::B32", "\"r\"", "PTXRegisterType::B64", "\"rd\"", "PTXRegisterType::F32", "\"f\"", "PTXRegisterType::F64", "\"fd\"", "PTXRegisterSpace::Return", "\"ret\"", "PTXRegisterSpace::Argument", "\"arg\"" ]

[]

[ "<s>", "bool", "VideocoreAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "unsigned", "Mask", "=", "1", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "sizeof", "(", "ErrorInfo", ")", "*", "8", "-", "1", ";", "++", "I", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "1", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "VideocoreOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_ImmediateTooLarge", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "VideocoreOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate is too large for this instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_CondCode", ":", "return", "Error", "(", "IDLoc", ",", "\"expected a condition code\"", ")", ";", "}", "llvm_unreachable", "(", "\"Unexpected match type\"", ")", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "\"Unknown missing feature!\"", "\"instruction requires:\"", "1", "0", "8", "1", "\" \"", "1", "0U", "\"too few operands for instruction\"", "Videocore", "\"invalid operand for instruction\"", "Videocore", "\"immediate is too large for this instruction\"", "\"invalid instruction\"", "\"expected a condition code\"", "\"Unexpected match type\"" ]

[]

[ "<s>", "unsigned", "WebAssemblyInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "TBB", ")", "return", "0", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a successor block\"", ")", ";", "if", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_IF", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_UNLESS", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "WebAssembly", "WebAssembly", "\"code size not handled\"", "0", "WebAssembly::BR", "1", "2", "\"Expected a flag and a successor block\"", "0", "WebAssembly::BR_IF", "1", "WebAssembly::BR_UNLESS", "1", "1", "WebAssembly::BR", "2" ]

[]

[ "<s>", "static", "rtx_insn", "*", "emit_sp_adjust", "(", "int", "offset", ",", "int", "*", "next_scratch_regno", ",", "bool", "frame_related", ",", "rtx", "reg_notes", ")", "{", "rtx", "to_add", ";", "rtx", "imm_rtx", "=", "GEN_INT", "(", "offset", ")", ";", "rtx", "pat", ";", "rtx_insn", "*", "insn", ";", "if", "(", "satisfies_constraint_J", "(", "imm_rtx", ")", ")", "{", "to_add", "=", "imm_rtx", ";", "}", "else", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "(", "*", "next_scratch_regno", ")", "--", ")", ";", "tilegx_expand_set_const64", "(", "tmp", ",", "imm_rtx", ")", ";", "to_add", "=", "tmp", ";", "}", "if", "(", "TARGET_32BIT", ")", "pat", "=", "gen_sp_adjust_32bit", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "to_add", ")", ";", "else", "pat", "=", "gen_sp_adjust", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "to_add", ")", ";", "insn", "=", "emit_insn", "(", "pat", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "reg_notes", ";", "if", "(", "frame_related", ")", "{", "rtx", "real", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "imm_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "real", ")", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "This", "emits", "code", "for", "'sp", "+=", "offset", "'", ".", "The", "ABI", "only", "allows", "us", "to", "modify", "'sp", "'", "in", "a", "single", "'addi", "'", "or", "'addli", "'", ",", "so", "the", "backtracer", "understands", "it", ".", "Larger", "amounts", "can", "not", "use", "those", "instructions", ",", "so", "are", "added", "by", "placing", "the", "offset", "into", "a", "large", "register", "and", "using", "'add", "'", ".", "This", "happens", "after", "reload", ",", "so", "we", "need", "to", "expand", "it", "ourselves", "." ]

[ "tilegx", "1" ]

[]

[ "<s>", "Instruction", "*", "ARMTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicOrdering", "Ord", ",", "bool", "IsStore", ",", "bool", "IsLoad", ")", "const", "{", "switch", "(", "Ord", ")", "{", "case", "AtomicOrdering", "::", "NotAtomic", ":", "case", "AtomicOrdering", "::", "Unordered", ":", "llvm_unreachable", "(", "\"Invalid fence: unordered/non-atomic\"", ")", ";", "case", "AtomicOrdering", "::", "Monotonic", ":", "case", "AtomicOrdering", "::", "Acquire", ":", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "SequentiallyConsistent", ":", "if", "(", "!", "IsStore", ")", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "Release", ":", "case", "AtomicOrdering", "::", "AcquireRelease", ":", "if", "(", "Subtarget", "->", "preferISHSTBarriers", "(", ")", ")", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISHST", ")", ";", "else", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISH", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown fence ordering in emitLeadingFence\"", ")", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "ARM", "ARM", "\"Invalid fence: unordered/non-atomic\"", "ARM_MB::ISHST", "ARM_MB::ISH", "\"Unknown fence ordering in emitLeadingFence\"" ]

[]

[ "<s>", "void", "RISCVAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "RISCVMCInstLower", "Lower", "(", "MF", "->", "getContext", "(", ")", ",", "*", "this", ")", ";", "MCInst", "LoweredMI", ";", "Lower", ".", "lower", "(", "MI", ",", "LoweredMI", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "LoweredMI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MCSection", "*", "XCoreTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ")", "const", "{", "if", "(", "Kind", ".", "isMergeableConst4", "(", ")", ")", "return", "MergeableConst4Section", ";", "if", "(", "Kind", ".", "isMergeableConst8", "(", ")", ")", "return", "MergeableConst8Section", ";", "if", "(", "Kind", ".", "isMergeableConst16", "(", ")", ")", "return", "MergeableConst16Section", ";", "assert", "(", "(", "Kind", ".", "isReadOnly", "(", ")", "||", "Kind", ".", "isReadOnlyWithRel", "(", ")", ")", "&&", "\"Unknown section kind\"", ")", ";", "return", "ReadOnlySection", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "XCore", "XCore", "\"Unknown section kind\"" ]

[]

[ "<s>", "rtx", "mmix_eh_return_stackadj_rtx", "(", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "MMIX_EH_RETURN_STACKADJ_REGNUM", ")", ";", "}", "</s>" ]

[ "EH_RETURN_STACKADJ_RTX", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "void", "aarch64_emit_inverted_unspec_cond", "(", "rtx", "target", ",", "rtx_code", "code", ",", "machine_mode", "pred_mode", ",", "rtx", "ptrue", ",", "rtx", "pred", ",", "rtx", "op0", ",", "rtx", "op1", ",", "bool", "can_invert_p", ")", "{", "if", "(", "can_invert_p", ")", "aarch64_emit_unspec_cond", "(", "target", ",", "code", ",", "pred_mode", ",", "pred", ",", "op0", ",", "op1", ")", ";", "else", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_unspec_cond", "(", "tmp", ",", "code", ",", "pred_mode", ",", "pred", ",", "op0", ",", "op1", ")", ";", "emit_set_insn", "(", "target", ",", "gen_rtx_AND", "(", "pred_mode", ",", "gen_rtx_NOT", "(", "pred_mode", ",", "tmp", ")", ",", "ptrue", ")", ")", ";", "}", "}", "</s>" ]

[ "If", "CAN_INVERT_P", ",", "emit", "an", "instruction", ":", "(", "set", "TARGET", "(", "unspec", ":", "PRED_MODE", "[", "PRED", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X", ">", ")", ")", "where", "<", "X", ">", "is", "the", "operation", "associated", "with", "comparison", "CODE", ".", "Otherwise", "emit", ":", "(", "set", "TMP", "(", "unspec", ":", "PRED_MODE", "[", "PRED", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X", ">", ")", ")", "(", "set", "TARGET", "(", "and", ":", "PRED_MODE", "(", "not", ":", "PRED_MODE", "TMP", ")", "PTRUE", ")", ")", "where", "the", "second", "instructions", "sets", "TARGET", "to", "the", "inverse", "of", "TMP", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "SelectionDAG", "&", ",", "unsigned", "Depth", ")", "const", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "X86ISD", "::", "SETCC_CARRY", ")", "return", "Op", ".", "getValueType", "(", ")", ".", "getScalarSizeInBits", "(", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "X86", "X86", "X86ISD::SETCC_CARRY", "1" ]

[]

[ "<s>", "WebAssemblySubtarget", "::", "WebAssemblySubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "WebAssemblyGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "HasSIMD128", "(", "false", ")", ",", "HasAtomics", "(", "false", ")", ",", "HasNontrappingFPToInt", "(", "false", ")", ",", "HasSignExt", "(", "false", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "mips_keep_interrupts_masked_p", "(", "tree", "type", ")", "{", "return", "lookup_attribute", "(", "\"keep_interrupts_masked\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", "!=", "NULL", ";", "}", "</s>" ]

[ "Check", "if", "the", "attribute", "to", "keep", "interrupts", "masked", "is", "set", "for", "a", "function", "." ]

[ "mips", "\"keep_interrupts_masked\"" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "CSEConfigBase", ">", "AMDGPUPassConfig", "::", "getCSEConfig", "(", ")", "const", "{", "return", "getStandardCSEConfigForOpt", "(", "TM", "->", "getOptLevel", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "CSEConfig", "object", "to", "use", "for", "the", "current", "optimization", "level", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "const", "char", "*", "standard_sse_constant_opcode", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "machine_mode", "mode", ";", "rtx", "x", "=", "operands", "[", "1", "]", ";", "gcc_assert", "(", "TARGET_SSE", ")", ";", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "x", "==", "const0_rtx", "||", "const0_operand", "(", "x", ",", "mode", ")", ")", "{", "switch", "(", "get_attr_mode", "(", "insn", ")", ")", "{", "case", "MODE_TI", ":", "if", "(", "!", "EXT_REX_SSE_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"%vpxor\\t%0, %d0\"", ";", "case", "MODE_XI", ":", "case", "MODE_OI", ":", "if", "(", "EXT_REX_SSE_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "(", "TARGET_AVX512VL", "?", "\"vpxord\\t%x0, %x0, %x0\"", ":", "\"vpxord\\t%g0, %g0, %g0\"", ")", ";", "return", "\"vpxor\\t%x0, %x0, %x0\"", ";", "case", "MODE_V2DF", ":", "if", "(", "!", "EXT_REX_SSE_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"%vxorpd\\t%0, %d0\"", ";", "case", "MODE_V8DF", ":", "case", "MODE_V4DF", ":", "if", "(", "!", "EXT_REX_SSE_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"vxorpd\\t%x0, %x0, %x0\"", ";", "else", "if", "(", "TARGET_AVX512DQ", ")", "return", "(", "TARGET_AVX512VL", "?", "\"vxorpd\\t%x0, %x0, %x0\"", ":", "\"vxorpd\\t%g0, %g0, %g0\"", ")", ";", "else", "return", "(", "TARGET_AVX512VL", "?", "\"vpxorq\\t%x0, %x0, %x0\"", ":", "\"vpxorq\\t%g0, %g0, %g0\"", ")", ";", "case", "MODE_V4SF", ":", "if", "(", "!", "EXT_REX_SSE_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"%vxorps\\t%0, %d0\"", ";", "case", "MODE_V16SF", ":", "case", "MODE_V8SF", ":", "if", "(", "!", "EXT_REX_SSE_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"vxorps\\t%x0, %x0, %x0\"", ";", "else", "if", "(", "TARGET_AVX512DQ", ")", "return", "(", "TARGET_AVX512VL", "?", "\"vxorps\\t%x0, %x0, %x0\"", ":", "\"vxorps\\t%g0, %g0, %g0\"", ")", ";", "else", "return", "(", "TARGET_AVX512VL", "?", "\"vpxord\\t%x0, %x0, %x0\"", ":", "\"vpxord\\t%g0, %g0, %g0\"", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "x", "==", "constm1_rtx", "||", "vector_all_ones_operand", "(", "x", ",", "mode", ")", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", "&&", "float_vector_all_ones_operand", "(", "x", ",", "mode", ")", ")", ")", "{", "enum", "attr_mode", "insn_mode", "=", "get_attr_mode", "(", "insn", ")", ";", "switch", "(", "insn_mode", ")", "{", "case", "MODE_XI", ":", "case", "MODE_V8DF", ":", "case", "MODE_V16SF", ":", "gcc_assert", "(", "TARGET_AVX512F", ")", ";", "return", "\"vpternlogd\\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}\"", ";", "case", "MODE_OI", ":", "case", "MODE_V4DF", ":", "case", "MODE_V8SF", ":", "gcc_assert", "(", "TARGET_AVX2", ")", ";", "case", "MODE_TI", ":", "case", "MODE_V2DF", ":", "case", "MODE_V4SF", ":", "gcc_assert", "(", "TARGET_SSE2", ")", ";", "if", "(", "!", "EXT_REX_SSE_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "(", "TARGET_AVX", "?", "\"vpcmpeqd\\t%0, %0, %0\"", ":", "\"pcmpeqd\\t%0, %0\"", ")", ";", "else", "if", "(", "TARGET_AVX512VL", ")", "return", "\"vpternlogd\\t{$0xFF, %0, %0, %0|%0, %0, %0, 0xFF}\"", ";", "else", "return", "\"vpternlogd\\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "vector_all_ones_zero_extend_half_operand", "(", "x", ",", "mode", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "{", "gcc_assert", "(", "TARGET_AVX512F", ")", ";", "return", "\"vpcmpeqd \\t %t0, %t0, %t0\"", ";", "}", "else", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "32", ")", "{", "gcc_assert", "(", "TARGET_AVX", ")", ";", "return", "\"vpcmpeqd \\t %x0, %x0, %x0\"", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "vector_all_ones_zero_extend_quarter_operand", "(", "x", ",", "mode", ")", ")", "{", "gcc_assert", "(", "TARGET_AVX512F", ")", ";", "return", "\"vpcmpeqd \\t %x0, %x0, %x0\"", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

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

[ "i386", "1", "0", "\"%vpxor\\t%0, %d0\"", "0", "\"vpxord\\t%x0, %x0, %x0\"", "\"vpxord\\t%g0, %g0, %g0\"", "\"vpxor\\t%x0, %x0, %x0\"", "0", "\"%vxorpd\\t%0, %d0\"", "0", "\"vxorpd\\t%x0, %x0, %x0\"", "\"vxorpd\\t%x0, %x0, %x0\"", "\"vxorpd\\t%g0, %g0, %g0\"", "\"vpxorq\\t%x0, %x0, %x0\"", "\"vpxorq\\t%g0, %g0, %g0\"", "0", "\"%vxorps\\t%0, %d0\"", "0", "\"vxorps\\t%x0, %x0, %x0\"", "\"vxorps\\t%x0, %x0, %x0\"", "\"vxorps\\t%g0, %g0, %g0\"", "\"vpxord\\t%x0, %x0, %x0\"", "\"vpxord\\t%g0, %g0, %g0\"", "\"vpternlogd\\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}\"", "0", "\"vpcmpeqd\\t%0, %0, %0\"", "\"pcmpeqd\\t%0, %0\"", "\"vpternlogd\\t{$0xFF, %0, %0, %0|%0, %0, %0, 0xFF}\"", "\"vpternlogd\\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}\"", "64", "\"vpcmpeqd \\t %t0, %t0, %t0\"", "32", "\"vpcmpeqd \\t %x0, %x0, %x0\"", "\"vpcmpeqd \\t %x0, %x0, %x0\"" ]

[]

[ "<s>", "int", "m32c_special_page_vector_p", "(", "tree", "func", ")", "{", "tree", "list", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "list", "=", "M32C_ATTRIBUTES", "(", "func", ")", ";", "while", "(", "list", ")", "{", "if", "(", "is_attribute_p", "(", "\"function_vector\"", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "return", "1", ";", "list", "=", "TREE_CHAIN", "(", "list", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "given", "tree", "has", "the", "``", "function_vector", "''", "attribute", "." ]

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

[]

[ "<s>", "static", "rtx", "ix86_expand_vec_set_builtin", "(", "tree", "exp", ")", "{", "machine_mode", "tmode", ",", "mode1", ";", "tree", "arg0", ",", "arg1", ",", "arg2", ";", "int", "elt", ";", "rtx", "op0", ",", "op1", ",", "target", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "arg2", "=", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ";", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "mode1", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "tmode", ")", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "tmode", ",", "EXPAND_NORMAL", ")", ";", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "mode1", ",", "EXPAND_NORMAL", ")", ";", "elt", "=", "get_element_number", "(", "TREE_TYPE", "(", "arg0", ")", ",", "arg2", ")", ";", "if", "(", "GET_MODE", "(", "op1", ")", "!=", "mode1", "&&", "GET_MODE", "(", "op1", ")", "!=", "VOIDmode", ")", "op1", "=", "convert_modes", "(", "mode1", ",", "GET_MODE", "(", "op1", ")", ",", "op1", ",", "true", ")", ";", "op0", "=", "force_reg", "(", "tmode", ",", "op0", ")", ";", "op1", "=", "force_reg", "(", "mode1", ",", "op1", ")", ";", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "emit_move_insn", "(", "target", ",", "op0", ")", ";", "ix86_expand_vector_set", "(", "true", ",", "target", ",", "op1", ",", "elt", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_builtin", ".", "These", "builtins", "are", "a", "wrapper", "around", "ix86_expand_vector_set", ".", "They", "would", "be", "redundant", "(", "for", "non-MMX", ")", "if", "we", "had", "a", "language-level", "syntax", "for", "referencing", "vector", "elements", "." ]

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

[]

[ "<s>", "unsigned", "AArch64FrameLowering", "::", "getWinEHFuncletFrameSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "CSSize", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "getCalleeSavedStackSize", "(", ")", ";", "return", "alignTo", "(", "CSSize", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getMaxCallFrameSize", "(", ")", ",", "getStackAlign", "(", ")", ")", ";", "}", "</s>" ]

[ "Funclets", "only", "need", "to", "account", "for", "space", "for", "the", "callee", "saved", "registers", ",", "as", "the", "locals", "are", "accounted", "for", "in", "the", "parent", "'s", "stack", "frame", "." ]

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

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"PPC branch conditions have two components!\"", ")", ";", "assert", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "hasISEL", "(", ")", "&&", "\"Cannot insert select on target without ISEL support\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "assert", "(", "RC", "&&", "\"TrueReg and FalseReg must have overlapping register classes\"", ")", ";", "assert", "(", "(", "PPC", "::", "GPRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "PPC", "::", "G8RCRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "&&", "\"isel is for regular integer GPRs only\"", ")", ";", "unsigned", "OpCode", "=", "PPC", "::", "GPRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "?", "PPC", "::", "ISEL", ":", "PPC", "::", "ISEL8", ";", "unsigned", "SelectPred", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "SubIdx", ";", "bool", "SwapOps", ";", "switch", "(", "SelectPred", ")", "{", "default", ":", "llvm_unreachable", "(", "\"invalid predicate for isel\"", ")", ";", "case", "PPC", "::", "PRED_EQ", ":", "SubIdx", "=", "PPC", "::", "sub_eq", ";", "SwapOps", "=", "false", ";", "break", ";", "case", "PPC", "::", "PRED_NE", ":", "SubIdx", "=", "PPC", "::", "sub_eq", ";", "SwapOps", "=", "true", ";", "break", ";", "case", "PPC", "::", "PRED_LT", ":", "SubIdx", "=", "PPC", "::", "sub_lt", ";", "SwapOps", "=", "false", ";", "break", ";", "case", "PPC", "::", "PRED_GE", ":", "SubIdx", "=", "PPC", "::", "sub_lt", ";", "SwapOps", "=", "true", ";", "break", ";", "case", "PPC", "::", "PRED_GT", ":", "SubIdx", "=", "PPC", "::", "sub_gt", ";", "SwapOps", "=", "false", ";", "break", ";", "case", "PPC", "::", "PRED_LE", ":", "SubIdx", "=", "PPC", "::", "sub_gt", ";", "SwapOps", "=", "true", ";", "break", ";", "case", "PPC", "::", "PRED_UN", ":", "SubIdx", "=", "PPC", "::", "sub_un", ";", "SwapOps", "=", "false", ";", "break", ";", "case", "PPC", "::", "PRED_NU", ":", "SubIdx", "=", "PPC", "::", "sub_un", ";", "SwapOps", "=", "true", ";", "break", ";", "}", "unsigned", "FirstReg", "=", "SwapOps", "?", "FalseReg", ":", "TrueReg", ",", "SecondReg", "=", "SwapOps", "?", "TrueReg", ":", "FalseReg", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FirstReg", ")", "->", "contains", "(", "PPC", "::", "R0", ")", "||", "MRI", ".", "getRegClass", "(", "FirstReg", ")", "->", "contains", "(", "PPC", "::", "X0", ")", ")", "{", "const", "TargetRegisterClass", "*", "FirstRC", "=", "MRI", ".", "getRegClass", "(", "FirstReg", ")", "->", "contains", "(", "PPC", "::", "X0", ")", "?", "&", "PPC", "::", "G8RC_NOX0RegClass", ":", "&", "PPC", "::", "GPRC_NOR0RegClass", ";", "unsigned", "OldFirstReg", "=", "FirstReg", ";", "FirstReg", "=", "MRI", ".", "createVirtualRegister", "(", "FirstRC", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "FirstReg", ")", ".", "addReg", "(", "OldFirstReg", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "OpCode", ")", ",", "DestReg", ")", ".", "addReg", "(", "FirstReg", ")", ".", "addReg", "(", "SecondReg", ")", ".", "addReg", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ",", "0", ",", "SubIdx", ")", ";", "}", "</s>" ]

[ "Insert", "a", "select", "instruction", "into", "MBB", "before", "I", "that", "will", "copy", "TrueReg", "to", "DstReg", "when", "Cond", "is", "true", ",", "and", "FalseReg", "to", "DstReg", "when", "Cond", "is", "false", "." ]

[ "PowerPC", "PPC", "2", "\"PPC branch conditions have two components!\"", "\"Cannot insert select on target without ISEL support\"", "\"TrueReg and FalseReg must have overlapping register classes\"", "PPC::GPRCRegClass", "PPC::G8RCRegClass", "\"isel is for regular integer GPRs only\"", "PPC::GPRCRegClass", "PPC::ISEL", "PPC::ISEL8", "0", "\"invalid predicate for isel\"", "PPC::PRED_EQ", "PPC::sub_eq", "PPC::PRED_NE", "PPC::sub_eq", "PPC::PRED_LT", "PPC::sub_lt", "PPC::PRED_GE", "PPC::sub_lt", "PPC::PRED_GT", "PPC::sub_gt", "PPC::PRED_LE", "PPC::sub_gt", "PPC::PRED_UN", "PPC::sub_un", "PPC::PRED_NU", "PPC::sub_un", "PPC::R0", "PPC::X0", "PPC::X0", "PPC::G8RC_NOX0RegClass", "PPC::GPRC_NOR0RegClass", "1", "0" ]

[]

[ "<s>", "int", "m32c_preferred_reload_class", "(", "rtx", "x", ",", "int", "rclass", ")", "{", "int", "newclass", "=", "rclass", ";", "fprintf", "(", "stderr", ",", "\"\\npreferred_reload_class for %s is \"", ",", "class_names", "[", "rclass", "]", ")", ";", "if", "(", "rclass", "==", "NO_REGS", ")", "rclass", "=", "GET_MODE", "(", "x", ")", "==", "QImode", "?", "HL_REGS", ":", "R03_REGS", ";", "if", "(", "classes_intersect", "(", "rclass", ",", "CR_REGS", ")", ")", "{", "switch", "(", "GET_MODE", "(", "x", ")", ")", "{", "case", "QImode", ":", "newclass", "=", "HL_REGS", ";", "break", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "newclass", "==", "QI_REGS", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "2", ")", "newclass", "=", "SI_REGS", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "4", "&&", "~", "class_contents", "[", "rclass", "]", "[", "0", "]", "&", "0x000f", ")", "newclass", "=", "DI_REGS", ";", "rclass", "=", "reduce_class", "(", "rclass", ",", "newclass", ",", "rclass", ")", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", ")", "rclass", "=", "reduce_class", "(", "rclass", ",", "HL_REGS", ",", "rclass", ")", ";", "fprintf", "(", "stderr", ",", "\"%s\\n\"", ",", "class_names", "[", "rclass", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "PLUS", ")", "fprintf", "(", "stderr", ",", "\"Glorm!\\n\"", ")", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Implements", "PREFERRED_RELOAD_CLASS", ".", "In", "general", ",", "prefer", "general", "registers", "of", "the", "appropriate", "size", "." ]

[ "m32c", "\"\\npreferred_reload_class for %s is \"", "2", "4", "0", "0x000f", "\"%s\\n\"", "0", "0", "0", "\"Glorm!\\n\"" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableARMLoadStoreOpt", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "ARM", "::", "DPRRegClass", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ".", "restrictIT", "(", ")", ";", "}", ")", ")", ";", "addPass", "(", "createIfConverter", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "!", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "}", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "lowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "lowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "cast", "<", "JumpTableSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "lowerBITCAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "lowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "lowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "lowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "lowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "lowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "lowerOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_SWAPW", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_ADD", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_SUB", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_AND", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_OR", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_XOR", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_NAND", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_MIN", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_MAX", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_UMIN", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "SystemZISD", "::", "ATOMIC_LOADW_UMAX", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "lowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STACKSAVE", ":", "return", "lowerSTACKSAVE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "lowerSTACKRESTORE", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected node to lower\"", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::BlockAddress", "ISD::JumpTable", "ISD::ConstantPool", "ISD::BITCAST", "ISD::VASTART", "ISD::VACOPY", "ISD::DYNAMIC_STACKALLOC", "ISD::UMUL_LOHI", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::OR", "ISD::ATOMIC_SWAP", "SystemZISD::ATOMIC_SWAPW", "ISD::ATOMIC_LOAD_ADD", "SystemZISD::ATOMIC_LOADW_ADD", "ISD::ATOMIC_LOAD_SUB", "SystemZISD::ATOMIC_LOADW_SUB", "ISD::ATOMIC_LOAD_AND", "SystemZISD::ATOMIC_LOADW_AND", "ISD::ATOMIC_LOAD_OR", "SystemZISD::ATOMIC_LOADW_OR", "ISD::ATOMIC_LOAD_XOR", "SystemZISD::ATOMIC_LOADW_XOR", "ISD::ATOMIC_LOAD_NAND", "SystemZISD::ATOMIC_LOADW_NAND", "ISD::ATOMIC_LOAD_MIN", "SystemZISD::ATOMIC_LOADW_MIN", "ISD::ATOMIC_LOAD_MAX", "SystemZISD::ATOMIC_LOADW_MAX", "ISD::ATOMIC_LOAD_UMIN", "SystemZISD::ATOMIC_LOADW_UMIN", "ISD::ATOMIC_LOAD_UMAX", "SystemZISD::ATOMIC_LOADW_UMAX", "ISD::ATOMIC_CMP_SWAP", "ISD::STACKSAVE", "ISD::STACKRESTORE", "\"Unexpected node to lower\"" ]

[]

[ "<s>", "virtual", "const", "MipsInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "InstrInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "m68k_adjust_decorated_operand", "(", "rtx", "op", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "op", ",", "ALL", ")", "{", "rtx", "x", "=", "*", "iter", ";", "if", "(", "m68k_unwrap_symbol", "(", "x", ",", "true", ")", "!=", "x", ")", "{", "rtx", "plus", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", ";", "plus", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "plus", ")", "==", "PLUS", "||", "GET_CODE", "(", "plus", ")", "==", "MINUS", ")", "{", "rtx", "unspec", ";", "rtx", "addend", ";", "unspec", "=", "XEXP", "(", "plus", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", ")", ";", "addend", "=", "XEXP", "(", "plus", ",", "1", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "addend", ")", ")", ";", "XEXP", "(", "plus", ",", "0", ")", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", "=", "plus", ";", "XEXP", "(", "x", ",", "0", ")", "=", "unspec", ";", "}", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Adjust", "decorated", "address", "operand", "before", "outputing", "assembler", "for", "it", "." ]

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

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "addPass", "(", "createAMDGPUPromoteAlloca", "(", "ST", ")", ")", ";", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

[ "R600" ]

[]

[ "<s>", "static", "rtx", "frv_expand_mdpackh_builtin", "(", "tree", "call", ",", "rtx", "target", ")", "{", "enum", "insn_code", "icode", "=", "CODE_FOR_mdpackh", ";", "rtx", "pat", ",", "op0", ",", "op1", ";", "rtx", "arg1", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "rtx", "arg2", "=", "frv_read_argument", "(", "call", ",", "1", ")", ";", "rtx", "arg3", "=", "frv_read_argument", "(", "call", ",", "2", ")", ";", "rtx", "arg4", "=", "frv_read_argument", "(", "call", ",", "3", ")", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "op1", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_clobber", "(", "op0", ")", ";", "emit_clobber", "(", "op1", ")", ";", "emit_move_insn", "(", "simplify_gen_subreg", "(", "HImode", ",", "op0", ",", "DImode", ",", "2", ")", ",", "arg1", ")", ";", "emit_move_insn", "(", "simplify_gen_subreg", "(", "HImode", ",", "op0", ",", "DImode", ",", "6", ")", ",", "arg2", ")", ";", "emit_move_insn", "(", "simplify_gen_subreg", "(", "HImode", ",", "op1", ",", "DImode", ",", "2", ")", ",", "arg3", ")", ";", "emit_move_insn", "(", "simplify_gen_subreg", "(", "HImode", ",", "op1", ",", "DImode", ",", "6", ")", ",", "arg4", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "the", "MDPACKH", "builtin", ".", "It", "takes", "four", "unsigned", "short", "arguments", "and", "each", "argument", "forms", "one", "word", "of", "the", "two", "double-word", "input", "registers", ".", "ARGLIST", "is", "a", "TREE_LIST", "of", "the", "arguments", "and", "TARGET", ",", "if", "nonnull", ",", "suggests", "a", "good", "place", "to", "put", "the", "return", "value", "." ]

[ "frv", "0", "1", "2", "3", "2", "6", "2", "6" ]

[]

[ "<s>", "static", "const", "char", "*", "aarch64_mangle_type", "(", "const_tree", "type", ")", "{", "if", "(", "lang_hooks", ".", "types_compatible_p", "(", "CONST_CAST_TREE", "(", "type", ")", ",", "va_list_type", ")", ")", "return", "\"St9__va_list\"", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "&&", "TYPE_PRECISION", "(", "type", ")", "==", "16", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "BFmode", ")", "return", "\"u6__bf16\"", ";", "else", "return", "\"Dh\"", ";", "}", "if", "(", "TYPE_NAME", "(", "type", ")", "!=", "NULL", ")", "{", "const", "char", "*", "res", ";", "if", "(", "(", "res", "=", "aarch64_general_mangle_builtin_type", "(", "type", ")", ")", "||", "(", "res", "=", "aarch64_sve", "::", "mangle_builtin_type", "(", "type", ")", ")", ")", "return", "res", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_MANGLE_TYPE", "." ]

[ "aarch64", "\"St9__va_list\"", "16", "\"u6__bf16\"", "\"Dh\"", "aarch64_sve::mangle_builtin_type" ]

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "isDead", "(", "const", "MachineInstr", "*", "MI", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "DeadPhis", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "MRI", "->", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "using", "use_nodbg_iterator", "=", "MachineRegisterInfo", "::", "use_nodbg_iterator", ";", "use_nodbg_iterator", "I", "=", "MRI", "->", "use_nodbg_begin", "(", "Reg", ")", ";", "use_nodbg_iterator", "End", "=", "MRI", "->", "use_nodbg_end", "(", ")", ";", "if", "(", "std", "::", "next", "(", "I", ")", "!=", "End", "||", "!", "I", "->", "getParent", "(", ")", "->", "isPHI", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "OnePhi", "=", "I", "->", "getParent", "(", ")", ";", "for", "(", "unsigned", "j", "=", "0", ",", "f", "=", "OnePhi", "->", "getNumOperands", "(", ")", ";", "j", "!=", "f", ";", "++", "j", ")", "{", "const", "MachineOperand", "&", "OPO", "=", "OnePhi", "->", "getOperand", "(", "j", ")", ";", "if", "(", "!", "OPO", ".", "isReg", "(", ")", "||", "!", "OPO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "OPReg", "=", "OPO", ".", "getReg", "(", ")", ";", "use_nodbg_iterator", "nextJ", ";", "for", "(", "use_nodbg_iterator", "J", "=", "MRI", "->", "use_nodbg_begin", "(", "OPReg", ")", ";", "J", "!=", "End", ";", "J", "=", "nextJ", ")", "{", "nextJ", "=", "std", "::", "next", "(", "J", ")", ";", "MachineOperand", "&", "Use", "=", "*", "J", ";", "MachineInstr", "*", "UseMI", "=", "Use", ".", "getParent", "(", ")", ";", "if", "(", "MI", "!=", "UseMI", ")", "return", "false", ";", "}", "}", "DeadPhis", ".", "push_back", "(", "OnePhi", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isDead", "-", "Returns", "true", "if", "this", "is", "a", "dead", "def", "kill", "slot", "." ]

[ "Hexagon", "Hexagon", "0", "0" ]

[]

[ "<s>", "bool", "legitimate_reload_constant_p", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "DISP_IN_RANGE", "(", "INTVAL", "(", "op", ")", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "(", "CONST_OK_FOR_K", "(", "INTVAL", "(", "op", ")", ")", "||", "CONST_OK_FOR_Os", "(", "INTVAL", "(", "op", ")", ")", ")", ")", "return", "true", ";", "if", "(", "TARGET_ZARCH", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "==", "INTVAL", "(", "op", ")", "&&", "s390_single_part", "(", "op", ",", "word_mode", ",", "HImode", ",", "0", ")", ">=", "0", ")", "return", "true", ";", "if", "(", "TARGET_EXTIMM", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "==", "INTVAL", "(", "op", ")", "&&", "s390_single_part", "(", "op", ",", "word_mode", ",", "SImode", ",", "0", ")", ">=", "0", ")", "return", "true", ";", "if", "(", "TARGET_CPU_ZARCH", "&&", "larl_operand", "(", "op", ",", "VOIDmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "s390_float_const_zero_p", "(", "op", ")", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", "<=", "UNITS_PER_WORD", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "!=", "INTVAL", "(", "op", ")", ")", "{", "machine_mode", "dword_mode", "=", "word_mode", "==", "SImode", "?", "DImode", ":", "TImode", ";", "rtx", "hi", "=", "operand_subword", "(", "op", ",", "0", ",", "0", ",", "dword_mode", ")", ";", "rtx", "lo", "=", "operand_subword", "(", "op", ",", "1", ",", "0", ",", "dword_mode", ")", ";", "return", "legitimate_reload_constant_p", "(", "hi", ")", "&&", "legitimate_reload_constant_p", "(", "lo", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "constant", "value", "OP", "is", "a", "legitimate", "general", "operand", "during", "and", "after", "reload", ".", "The", "difference", "to", "legitimate_constant_p", "is", "that", "this", "function", "will", "not", "accept", "a", "constant", "that", "would", "need", "to", "be", "forced", "to", "the", "literal", "pool", "before", "it", "can", "be", "used", "as", "operand", "." ]

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

[]

[ "<s>", "rtx", "or1k_return_addr", "(", "int", ",", "rtx", "frame", ")", "{", "return", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "frame", ",", "-", "UNITS_PER_WORD", ")", ")", ";", "}", "</s>" ]

[ "Worker", "for", "RETURN_ADDR_RTX", ".", "Returns", "the", "RTX", "representing", "the", "address", "of", "where", "the", "link", "register", "may", "be", "stored", "on", "the", "stack", "." ]

[ "or1k" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AVRFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "AVR", "::", "R29R28", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "getStackAlign", "(", ")", "==", "Align", "(", "1", ")", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SUBIWRdK", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ")", ";", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "AVR", "::", "R31R30", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "AVR", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "AVR", "AVR::R29R28", "0", "1", "\"Unsupported stack alignment\"", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::SUBIWRdK", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tLDRspi", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "VLDR_P0_off", ":", "case", "ARM", "::", "MVE_VLDRWU32", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLD1q64", ":", "case", "ARM", "::", "VLD1d8TPseudo", ":", "case", "ARM", "::", "VLD1d16TPseudo", ":", "case", "ARM", "::", "VLD1d32TPseudo", ":", "case", "ARM", "::", "VLD1d64TPseudo", ":", "case", "ARM", "::", "VLD1d8QPseudo", ":", "case", "ARM", "::", "VLD1d16QPseudo", ":", "case", "ARM", "::", "VLD1d32QPseudo", ":", "case", "ARM", "::", "VLD1d64QPseudo", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "MQQPRLoad", ":", "case", "ARM", "::", "MQQQQPRLoad", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "ARM", "ARM", "ARM::LDRrs", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::LDRi12", "ARM::t2LDRi12", "ARM::tLDRspi", "ARM::VLDRD", "ARM::VLDRS", "ARM::VLDR_P0_off", "ARM::MVE_VLDRWU32", "1", "2", "2", "0", "1", "0", "ARM::VLD1q64", "ARM::VLD1d8TPseudo", "ARM::VLD1d16TPseudo", "ARM::VLD1d32TPseudo", "ARM::VLD1d64TPseudo", "ARM::VLD1d8QPseudo", "ARM::VLD1d16QPseudo", "ARM::VLD1d32QPseudo", "ARM::VLD1d64QPseudo", "1", "0", "0", "1", "0", "ARM::VLDMQIA", "1", "0", "0", "1", "0", "ARM::MQQPRLoad", "ARM::MQQQQPRLoad", "1", "1", "0", "0" ]

[]

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

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

[ "Videocore", "Videocore" ]

[]

[ "<s>", "TTI", "::", "PopcntSupportKind", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "return", "ST", "->", "hasBCNT", "(", "TyWidth", ")", "?", "TTI", "::", "PSK_FastHardware", ":", "TTI", "::", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "R600", "\"Ty width must be power of 2\"" ]

[]

[ "<s>", "static", "void", "mips_emit_move_or_split", "(", "rtx", "dest", ",", "rtx", "src", ",", "enum", "mips_split_type", "split_type", ")", "{", "if", "(", "mips_split_move_p", "(", "dest", ",", "src", ",", "split_type", ")", ")", "mips_split_move", "(", "dest", ",", "src", ",", "split_type", ",", "NULL", ")", ";", "else", "mips_emit_move", "(", "dest", ",", "src", ")", ";", "}", "</s>" ]

[ "Emit", "a", "move", "from", "SRC", "to", "DEST", ",", "splitting", "compound", "moves", "into", "individual", "instructions", ".", "SPLIT_TYPE", "is", "the", "type", "of", "split", "to", "perform", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "return", "(", "ScalarVT", "==", "MVT", "::", "f32", "||", "ScalarVT", "==", "MVT", "::", "f64", ")", ";", "}", "</s>" ]

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

[ "R600", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "static", "void", "bfin_option_override", "(", "void", ")", "{", "if", "(", "bfin_cpu_type", "==", "BFIN_CPU_UNKNOWN", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "bfin_cpus", "[", "i", "]", ".", "name", "!=", "NULL", ";", "i", "++", ")", "bfin_workarounds", "|=", "bfin_cpus", "[", "i", "]", ".", "workarounds", ";", "bfin_si_revision", "=", "0xffff", ";", "}", "if", "(", "bfin_csync_anomaly", "==", "1", ")", "bfin_workarounds", "|=", "WA_SPECULATIVE_SYNCS", ";", "else", "if", "(", "bfin_csync_anomaly", "==", "0", ")", "bfin_workarounds", "&=", "~", "WA_SPECULATIVE_SYNCS", ";", "if", "(", "bfin_specld_anomaly", "==", "1", ")", "bfin_workarounds", "|=", "WA_SPECULATIVE_LOADS", ";", "else", "if", "(", "bfin_specld_anomaly", "==", "0", ")", "bfin_workarounds", "&=", "~", "WA_SPECULATIVE_LOADS", ";", "if", "(", "TARGET_OMIT_LEAF_FRAME_POINTER", ")", "flag_omit_frame_pointer", "=", "1", ";", "if", "(", "TARGET_FDPIC", ")", "error", "(", "\"%<-mfdpic%> is not supported, please use a bfin-linux-uclibc \"", "\"target\"", ")", ";", "if", "(", "OPTION_SET_P", "(", "bfin_library_id", ")", "&&", "!", "TARGET_ID_SHARED_LIBRARY", ")", "error", "(", "\"%<-mshared-library-id=%> specified without \"", "\"%<-mid-shared-library%>\"", ")", ";", "if", "(", "stack_limit_rtx", "&&", "TARGET_FDPIC", ")", "{", "warning", "(", "0", ",", "\"%<-fstack-limit-%> options are ignored with %<-mfdpic%>; \"", "\"use %<-mstack-check-l1%>\"", ")", ";", "stack_limit_rtx", "=", "NULL_RTX", ";", "}", "if", "(", "stack_limit_rtx", "&&", "TARGET_STACK_CHECK_L1", ")", "error", "(", "\"cannot use multiple stack checking methods together\"", ")", ";", "if", "(", "TARGET_ID_SHARED_LIBRARY", "&&", "TARGET_FDPIC", ")", "error", "(", "\"ID shared libraries and FD-PIC mode cannot be used together\"", ")", ";", "if", "(", "TARGET_SEP_DATA", "&&", "TARGET_ID_SHARED_LIBRARY", ")", "error", "(", "\"cannot specify both %<-msep-data%> and %<-mid-shared-library%>\"", ")", ";", "if", "(", "TARGET_SEP_DATA", ")", "target_flags", "|=", "MASK_ID_SHARED_LIBRARY", "|", "MASK_LEAF_ID_SHARED_LIBRARY", ";", "if", "(", "TARGET_ID_SHARED_LIBRARY", "&&", "flag_pic", "==", "0", ")", "flag_pic", "=", "1", ";", "if", "(", "TARGET_FDPIC", ")", "targetm", ".", "asm_out", ".", "unaligned_op", ".", "si", "=", "0", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_FDPIC", "&&", "!", "TARGET_ID_SHARED_LIBRARY", ")", "flag_pic", "=", "0", ";", "if", "(", "TARGET_MULTICORE", "&&", "bfin_cpu_type", "!=", "BFIN_CPU_BF561", ")", "error", "(", "\"%<-mmulticore%> can only be used with BF561\"", ")", ";", "if", "(", "TARGET_COREA", "&&", "!", "TARGET_MULTICORE", ")", "error", "(", "\"%<-mcorea%> should be used with %<-mmulticore%>\"", ")", ";", "if", "(", "TARGET_COREB", "&&", "!", "TARGET_MULTICORE", ")", "error", "(", "\"%<-mcoreb%> should be used with %<-mmulticore%>\"", ")", ";", "if", "(", "TARGET_COREA", "&&", "TARGET_COREB", ")", "error", "(", "\"%<-mcorea%> and %<-mcoreb%> cannot be used together\"", ")", ";", "flag_schedule_insns", "=", "0", ";", "init_machine_status", "=", "bfin_init_machine_status", ";", "}", "</s>" ]

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

[ "bfin", "0", "0xffff", "1", "0", "1", "0", "1", "\"%<-mfdpic%> is not supported, please use a bfin-linux-uclibc \"", "\"target\"", "\"%<-mshared-library-id=%> specified without \"", "\"%<-mid-shared-library%>\"", "0", "\"%<-fstack-limit-%> options are ignored with %<-mfdpic%>; \"", "\"use %<-mstack-check-l1%>\"", "\"cannot use multiple stack checking methods together\"", "\"ID shared libraries and FD-PIC mode cannot be used together\"", "\"cannot specify both %<-msep-data%> and %<-mid-shared-library%>\"", "0", "1", "0", "0", "\"%<-mmulticore%> can only be used with BF561\"", "\"%<-mcorea%> should be used with %<-mmulticore%>\"", "\"%<-mcoreb%> should be used with %<-mmulticore%>\"", "\"%<-mcorea%> and %<-mcoreb%> cannot be used together\"", "0" ]

[]