Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "csky_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "cumulative_args_t", "local_cum_v", "=", "pack_cumulative_args", "(", "&", "local_cum", ")", ";", "int", "regs_to_push", ";", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "local_cum", "=", "*", "pcum", ";", "csky_function_arg_advance", "(", "local_cum_v", ",", "arg", ")", ";", "regs_to_push", "=", "CSKY_NPARM_REGS", "-", "local_cum", ".", "reg", ";", "if", "(", "regs_to_push", ")", "*", "pretend_size", "=", "regs_to_push", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", ".", "On", "C-Sky", "the", "copy", "from", "the", "argument", "registers", "to", "the", "stack", "is", "emitted", "by", "the", "prologue", "hooks", ",", "so", "here", "we", "just", "have", "to", "note", "how", "much", "stack", "space", "to", "save", "." ]

[ "csky", "1" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "getSubtargetImpl", "(", ")", "->", "getInstrItineraryData", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getThisReturnPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_AArch64_AAPCS_ThisReturn_RegMask", ";", "}", "</s>" ]

[ "getThisReturnPreservedMask", "-", "Returns", "a", "call", "preserved", "mask", "specific", "to", "the", "case", "that", "'returned", "'", "is", "on", "an", "i32", "first", "argument", "if", "the", "calling", "convention", "is", "one", "that", "can", "(", "partially", ")", "model", "this", "attribute", "with", "a", "preserved", "mask", "(", "i.e", "." ]

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

[]

[ "<s>", "bool", "LC3RegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "LC3", "LC3" ]

[]

[ "<s>", "bool", "X86DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_v", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_X", ":", "case", "InlineAsm", "::", "Constraint_p", ":", "if", "(", "!", "selectAddr", "(", "nullptr", ",", "Op", ",", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "OutOps", ".", "push_back", "(", "Op2", ")", ";", "OutOps", ".", "push_back", "(", "Op3", ")", ";", "OutOps", ".", "push_back", "(", "Op4", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM MLA / MLS expansion pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM MLA / MLS expansion pass\"" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "1", ",", "false", ",", "false", ",", "true", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "bool", "X86FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "X86::GR64RegClass", "X86::GR32RegClass", "X86::POP64r", "X86::POP32r", "0", "X86::GR64RegClass", "X86::GR32RegClass" ]

[]

[ "<s>", "static", "void", "aarch64_emit_unspec_cond", "(", "rtx", "target", ",", "rtx_code", "code", ",", "machine_mode", "pred_mode", ",", "rtx", "pred", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "unspec", "=", "aarch64_gen_unspec_cond", "(", "code", ",", "pred_mode", ",", "pred", ",", "op0", ",", "op1", ")", ";", "emit_set_insn", "(", "target", ",", "unspec", ")", ";", "}", "</s>" ]

[ "Emit", "an", "instruction", ":", "(", "set", "TARGET", "(", "unspec", ":", "PRED_MODE", "[", "PRED", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X", ">", ")", ")", "where", "<", "X", ">", "is", "the", "operation", "associated", "with", "comparison", "CODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "const", "AMDGPUSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ",", "STI", ")", ";", "StringRef", "Err", ";", "if", "(", "!", "STI", ".", "getInstrInfo", "(", ")", "->", "verifyInstruction", "(", "MI", ",", "Err", ")", ")", "{", "errs", "(", ")", "<<", "\"Warning: Illegal instruction detected: \"", "<<", "Err", "<<", "\"\\n\"", ";", "MI", "->", "dump", "(", ")", ";", "}", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "++", "I", ";", "while", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "EmitInstruction", "(", "I", ")", ";", "++", "I", ";", "}", "}", "else", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "if", "(", "STI", ".", "dumpCode", "(", ")", ")", "{", "DisasmLines", ".", "resize", "(", "DisasmLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "DisasmLine", "=", "DisasmLines", ".", "back", "(", ")", ";", "raw_string_ostream", "DisasmStream", "(", "DisasmLine", ")", ";", "AMDGPUInstPrinter", "InstPrinter", "(", "*", "TM", ".", "getMCAsmInfo", "(", ")", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "InstPrinter", ".", "printInst", "(", "&", "TmpInst", ",", "DisasmStream", ",", "StringRef", "(", ")", ",", "MF", "->", "getSubtarget", "(", ")", ")", ";", "SmallVector", "<", "MCFixup", ",", "4", ">", "Fixups", ";", "SmallVector", "<", "char", ",", "16", ">", "CodeBytes", ";", "raw_svector_ostream", "CodeStream", "(", "CodeBytes", ")", ";", "MCObjectStreamer", "&", "ObjStreamer", "=", "(", "MCObjectStreamer", "&", ")", "OutStreamer", ";", "MCCodeEmitter", "&", "InstEmitter", "=", "ObjStreamer", ".", "getAssembler", "(", ")", ".", "getEmitter", "(", ")", ";", "InstEmitter", ".", "EncodeInstruction", "(", "TmpInst", ",", "CodeStream", ",", "Fixups", ",", "MF", "->", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ")", ";", "CodeStream", ".", "flush", "(", ")", ";", "HexLines", ".", "resize", "(", "HexLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "HexLine", "=", "HexLines", ".", "back", "(", ")", ";", "raw_string_ostream", "HexStream", "(", "HexLine", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CodeBytes", ".", "size", "(", ")", ";", "i", "+=", "4", ")", "{", "unsigned", "int", "CodeDWord", "=", "*", "(", "unsigned", "int", "*", ")", "&", "CodeBytes", "[", "i", "]", ";", "HexStream", "<<", "format", "(", "\"%s%08X\"", ",", "(", "i", ">", "0", "?", "\" \"", ":", "\"\"", ")", ",", "CodeDWord", ")", ";", "}", "DisasmStream", ".", "flush", "(", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLine", ".", "size", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "R600", "\"Warning: Illegal instruction detected: \"", "\"\\n\"", "1", "4", "16", "1", "0", "4", "\"%s%08X\"", "0", "\" \"", "\"\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_SaveList", ":", "CSR_Darwin64_SaveList", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_SaveList", ":", "CSR_Darwin32_SaveList", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", "&&", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", ")", "return", "CSR_SRV464_TLS_PE_SaveList", ";", "bool", "SaveR2", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isAllocatable", "(", "PPC", "::", "X2", ")", ";", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "(", "SaveR2", "?", "CSR_SVR464_R2_Altivec_SaveList", ":", "CSR_SVR464_Altivec_SaveList", ")", ":", "(", "SaveR2", "?", "CSR_SVR464_R2_SaveList", ":", "CSR_SVR464_SaveList", ")", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_SaveList", ":", "CSR_SVR432_SaveList", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC::X2", "PPC" ]

[]

[ "<s>", "static", "void", "microblaze_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "fprintf", "(", "f", ",", "\"\\tmfs r18, rpc\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tlwi r3, r18, 16\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tlwi r18, r18, 20\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tbra r18\\n\"", ")", ";", "}", "</s>" ]

[ "Generate", "assembler", "code", "for", "constant", "parts", "of", "a", "trampoline", "." ]

[ "microblaze", "\"\\tmfs r18, rpc\\n\"", "\"\\tlwi r3, r18, 16\\n\"", "\"\\tlwi r18, r18, 20\\n\"", "\"\\tbra r18\\n\"" ]

[]

[ "<s>", "SDValue", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "IsVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "if", "(", "IsVolatile", ")", "return", "SDValue", "(", ")", ";", "if", "(", "auto", "*", "CSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "return", "emitMemMem", "(", "DAG", ",", "DL", ",", "SystemZISD", "::", "MVC", ",", "SystemZISD", "::", "MVC_LOOP", ",", "Chain", ",", "Dst", ",", "Src", ",", "CSize", "->", "getZExtValue", "(", ")", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZISD::MVC", "SystemZISD::MVC_LOOP" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "int", "AltOpc", "=", "PPC", "::", "getAltVSXFMAOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "AltOpc", "==", "-", "1", ")", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "return", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "2", ",", "3", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::getAltVSXFMAOpcode", "1", "2", "3" ]

[]

[ "<s>", "static", "inline", "int", "avr_popcount", "(", "unsigned", "int", "val", ")", "{", "int", "pop", "=", "0", ";", "while", "(", "val", ")", "{", "val", "&=", "val", "-", "1", ";", "pop", "++", ";", "}", "return", "pop", ";", "}", "</s>" ]

[ "Custom", "function", "to", "count", "number", "of", "set", "bits", "." ]

[ "avr", "0", "1" ]

[]

[ "<s>", "bool", "NVPTXPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createLowerAggrCopies", "(", ")", ")", ";", "addPass", "(", "createSplitBBatBarPass", "(", ")", ")", ";", "addPass", "(", "createAllocaHoisting", "(", ")", ")", ";", "addPass", "(", "createNVPTXISelDag", "(", "getNVPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createVectorElementizePass", "(", "getNVPTXTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "visium_legitimate_constant_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "legitimate", "constant", "for", "a", "MODE", "immediate", "operand", ".", "X", "is", "guaranteed", "to", "satisfy", "the", "CONSTANT_P", "predicate", "." ]

[ "visium" ]

[]

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

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

[ "MBlaze", "MBlaze", "MBlaze", "1", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineBlockFrequencyInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineBlockFrequencyInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "SlotIndexes", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "SlotIndexes", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LiveStacks", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveStacks", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "VirtRegMap", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "VirtRegMap", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LiveRegMatrix", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveRegMatrix", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "EdgeBundles", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "SpillPlacement", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Z80old" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createLEGELFObjectWriter", "(", "OS", ",", "OSABI", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "LEG", "LEG" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon CFG Optimizer\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon CFG Optimizer\"" ]

[]

[ "<s>", "void", "ARMCallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "MachineFunction", "&", "MF", ",", "const", "SplitArgTy", "&", "PerformArgSplit", ")", "const", "{", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "4", ">", "Offsets", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "0", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "auto", "Flags", "=", "OrigArg", ".", "Flags", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "OrigArg", ".", "Ty", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Reg", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "unsigned", "FirstRegIdx", "=", "SplitArgs", ".", "size", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "EVT", "SplitVT", "=", "SplitVTs", "[", "i", "]", ";", "Type", "*", "SplitTy", "=", "SplitVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "auto", "Flags", "=", "OrigArg", ".", "Flags", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "SplitTy", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "bool", "NeedsConsecutiveRegisters", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "SplitTy", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "if", "(", "NeedsConsecutiveRegisters", ")", "{", "Flags", ".", "setInConsecutiveRegs", "(", ")", ";", "if", "(", "i", "==", "e", "-", "1", ")", "Flags", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}", "SplitArgs", ".", "push_back", "(", "ArgInfo", "{", "MRI", ".", "createGenericVirtualRegister", "(", "getLLTForType", "(", "*", "SplitTy", ",", "DL", ")", ")", ",", "SplitTy", ",", "Flags", ",", "OrigArg", ".", "IsFixed", "}", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Offsets", ".", "size", "(", ")", ";", "++", "i", ")", "PerformArgSplit", "(", "SplitArgs", "[", "FirstRegIdx", "+", "i", "]", ".", "Reg", ",", "Offsets", "[", "i", "]", "*", "8", ")", ";", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "ARM", "ARM", "ARM", "ARM", "4", "4", "0", "1", "0", "0", "1", "0", "8" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 CondBr Folding\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 CondBr Folding\"" ]

[]

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

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

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

[]

[ "<s>", "static", "HOST_WIDE_INT", "arg_area_size", "(", "void", ")", "{", "if", "(", "crtl", "->", "outgoing_args_size", ")", "{", "if", "(", "crtl", "->", "outgoing_args_size", ">=", "FIXED_STACK_AREA", ")", "return", "crtl", "->", "outgoing_args_size", ";", "else", "return", "FIXED_STACK_AREA", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "we", "must", "reserve", "for", "outgoing", "arguments", "in", "the", "current", "function", "'s", "stack", "frame", "." ]

[ "bfin", "0" ]

[]

[ "<s>", "static", "unsigned", "getOpcode_EXTEND_VECTOR_INREG", "(", "unsigned", "Opcode", ")", "{", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND_VECTOR_INREG", ":", "return", "ISD", "::", "ANY_EXTEND_VECTOR_INREG", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", ":", "return", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "SIGN_EXTEND_VECTOR_INREG", ":", "return", "ISD", "::", "SIGN_EXTEND_VECTOR_INREG", ";", "}", "llvm_unreachable", "(", "\"Unknown opcode\"", ")", ";", "}", "</s>" ]

[ "Convert", "*", "_EXTEND", "to", "*", "_EXTEND_VECTOR_INREG", "opcode", "." ]

[ "X86", "ISD::ANY_EXTEND", "ISD::ANY_EXTEND_VECTOR_INREG", "ISD::ANY_EXTEND_VECTOR_INREG", "ISD::ZERO_EXTEND", "ISD::ZERO_EXTEND_VECTOR_INREG", "ISD::ZERO_EXTEND_VECTOR_INREG", "ISD::SIGN_EXTEND", "ISD::SIGN_EXTEND_VECTOR_INREG", "ISD::SIGN_EXTEND_VECTOR_INREG", "\"Unknown opcode\"" ]

[]

[ "<s>", "int", "ia64_function_arg_boundary", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "mode", "==", "TFmode", "&&", "TARGET_HPUX", "&&", "TARGET_ILP32", ")", "return", "PARM_BOUNDARY", "*", "2", ";", "if", "(", "type", ")", "{", "if", "(", "TYPE_ALIGN", "(", "type", ")", ">", "PARM_BOUNDARY", ")", "return", "PARM_BOUNDARY", "*", "2", ";", "else", "return", "PARM_BOUNDARY", ";", "}", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "PARM_BOUNDARY", ")", "return", "PARM_BOUNDARY", "*", "2", ";", "else", "return", "PARM_BOUNDARY", ";", "}", "</s>" ]

[ "Arguments", "with", "alignment", "larger", "than", "8", "bytes", "start", "at", "the", "next", "even", "boundary", ".", "On", "ILP32", "HPUX", ",", "TFmode", "arguments", "start", "on", "next", "even", "boundary", "even", "though", "their", "normal", "alignment", "is", "8", "bytes", ".", "See", "ia64_function_arg", "." ]

[ "ia64", "2", "2", "2" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "immediateExtend", "(", "MachineInstr", "*", "MI", ")", "const", "{", "assert", "(", "(", "isExtendable", "(", "MI", ")", "||", "isConstExtended", "(", "MI", ")", ")", "&&", "\"Instruction must be extendable\"", ")", ";", "short", "ExtOpNum", "=", "getCExtOpNum", "(", "MI", ")", ";", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "ExtOpNum", ")", ";", "assert", "(", "(", "MO", ".", "isMBB", "(", ")", "||", "MO", ".", "isImm", "(", ")", ")", "&&", "\"Branch with unknown extendable field type\"", ")", ";", "MO", ".", "addTargetFlag", "(", "HexagonII", "::", "HMOTF_ConstExtended", ")", ";", "}", "</s>" ]

[ "immediateExtend", "-", "Changes", "the", "instruction", "in", "place", "to", "one", "using", "an", "immediate", "extender", "." ]

[ "Hexagon", "Hexagon", "\"Instruction must be extendable\"", "\"Branch with unknown extendable field type\"", "HexagonII::HMOTF_ConstExtended" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "WebAssemblyAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "WebAssembly", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_sleb128_i32\"", ",", "0", ",", "5", "*", "8", ",", "0", "}", ",", "{", "\"fixup_sleb128_i64\"", ",", "0", ",", "10", "*", "8", ",", "0", "}", ",", "{", "\"fixup_uleb128_i32\"", ",", "0", ",", "5", "*", "8", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::NumTargetFixupKinds", "\"fixup_sleb128_i32\"", "0", "5", "8", "0", "\"fixup_sleb128_i64\"", "0", "10", "8", "0", "\"fixup_uleb128_i32\"", "0", "5", "8", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "M88kCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "I", "=", "0", ";", "for", "(", "const", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArg", "{", "VRegs", "[", "I", "]", ",", "Arg", ".", "getType", "(", ")", ",", "I", "}", ";", "setArgFlags", "(", "OrigArg", ",", "I", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "++", "I", ";", "}", "IncomingValueAssigner", "ArgAssigner", "(", "CC_M88k", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ")", ";", "return", "determineAndHandleAssignments", "(", "ArgHandler", ",", "ArgAssigner", ",", "SplitArgs", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "8", "0", "M88k" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isKnownNeverNaNForTargetNode", "(", "SDValue", "Op", ",", "const", "SelectionDAG", "&", "DAG", ",", "bool", "SNaN", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "Opcode", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FMIN_LEGACY", ":", "case", "AMDGPUISD", "::", "FMAX_LEGACY", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUISD", "::", "FMUL_LEGACY", ":", "case", "AMDGPUISD", "::", "CVT_PKRTZ_F16_F32", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", "&&", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "case", "AMDGPUISD", "::", "FMED3", ":", "case", "AMDGPUISD", "::", "FMIN3", ":", "case", "AMDGPUISD", "::", "FMAX3", ":", "case", "AMDGPUISD", "::", "FMAD_FTZ", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", "&&", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", "&&", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "2", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE0", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE1", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE2", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE3", ":", "return", "true", ";", "case", "AMDGPUISD", "::", "RCP", ":", "case", "AMDGPUISD", "::", "RSQ", ":", "case", "AMDGPUISD", "::", "RCP_LEGACY", ":", "case", "AMDGPUISD", "::", "RSQ_LEGACY", ":", "case", "AMDGPUISD", "::", "RSQ_CLAMP", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUISD", "::", "LDEXP", ":", "case", "AMDGPUISD", "::", "FRACT", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "case", "AMDGPUISD", "::", "DIV_SCALE", ":", "case", "AMDGPUISD", "::", "DIV_FMAS", ":", "case", "AMDGPUISD", "::", "DIV_FIXUP", ":", "case", "AMDGPUISD", "::", "TRIG_PREOP", ":", "return", "SNaN", ";", "case", "AMDGPUISD", "::", "SIN_HW", ":", "case", "AMDGPUISD", "::", "COS_HW", ":", "{", "return", "SNaN", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IntrinsicID", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntrinsicID", ")", "{", "case", "Intrinsic", "::", "amdgcn_cubeid", ":", "return", "true", ";", "case", "Intrinsic", "::", "amdgcn_frexp_mant", ":", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "default", ":", "return", "false", ";", "}", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "If", "SNaN", "is", "false", ",", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPUISD::FMIN_LEGACY", "AMDGPUISD::FMAX_LEGACY", "AMDGPUISD::FMUL_LEGACY", "AMDGPUISD::CVT_PKRTZ_F16_F32", "0", "1", "1", "1", "AMDGPUISD::FMED3", "AMDGPUISD::FMIN3", "AMDGPUISD::FMAX3", "AMDGPUISD::FMAD_FTZ", "0", "1", "1", "1", "2", "1", "AMDGPUISD::CVT_F32_UBYTE0", "AMDGPUISD::CVT_F32_UBYTE1", "AMDGPUISD::CVT_F32_UBYTE2", "AMDGPUISD::CVT_F32_UBYTE3", "AMDGPUISD::RCP", "AMDGPUISD::RSQ", "AMDGPUISD::RCP_LEGACY", "AMDGPUISD::RSQ_LEGACY", "AMDGPUISD::RSQ_CLAMP", "AMDGPUISD::LDEXP", "AMDGPUISD::FRACT", "0", "1", "AMDGPUISD::DIV_SCALE", "AMDGPUISD::DIV_FMAS", "AMDGPUISD::DIV_FIXUP", "AMDGPUISD::TRIG_PREOP", "AMDGPUISD::SIN_HW", "AMDGPUISD::COS_HW", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::amdgcn_cubeid", "Intrinsic::amdgcn_frexp_mant", "1", "1" ]

[]

[ "<s>", "rtx", "loongarch_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "RETURN_ADDR_RTX", ".", "We", "do", "not", "support", "moving", "back", "to", "a", "previous", "frame", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "isTerminator", "(", ")", "||", "MI", "->", "isLabel", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MI", ";", "while", "(", "++", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isDebugValue", "(", ")", ")", ";", "if", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "return", "true", ";", "if", "(", "!", "MI", "->", "isCall", "(", ")", "&&", "MI", "->", "definesRegister", "(", "ARM", "::", "SP", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::t2IT", "ARM::SP" ]

[]

[ "<s>", "const", "char", "*", "X86TargetLowering", "::", "LowerXConstraint", "(", "EVT", "ConstraintVT", ")", "const", "{", "if", "(", "ConstraintVT", ".", "isFloatingPoint", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasSSE1", "(", ")", ")", "return", "\"x\"", ";", "}", "return", "TargetLowering", "::", "LowerXConstraint", "(", "ConstraintVT", ")", ";", "}", "</s>" ]

[ "Try", "to", "replace", "an", "X", "constraint", ",", "which", "matches", "anything", ",", "with", "another", "that", "has", "more", "specific", "requirements", "based", "on", "the", "type", "of", "the", "corresponding", "operand", "." ]

[ "X86", "X86", "\"x\"" ]

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "const", "LanaiMCExpr", "*", "LanaiMCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "LanaiMCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "ARMConstantPoolMBB", "*", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "ia64_dfa_pre_cycle_insn", "(", "void", ")", "{", "return", "dfa_pre_cycle_insn", ";", "}", "</s>" ]

[ "The", "following", "function", "returns", "the", "pseudo", "insn", "DFA_PRE_CYCLE_INSN", "used", "by", "the", "DFA", "insn", "scheduler", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "StackAlign", "=", "getStackAlign", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "Align", "MaxStackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MFI", ".", "getMaxAlign", "(", ")", ")", ";", "FrameSize", "+=", "(", "MaxStackAlign", ".", "value", "(", ")", "-", "StackAlign", ".", "value", "(", ")", ")", ";", "StackAlign", "=", "MaxStackAlign", ";", "}", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

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

[]

[ "<s>", "void", "WebAssemblyInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "TailDuplicateID", ")", ";", "addPass", "(", "createNVVMReflectPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createNVPTXImageOptimizerPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXAssignValidGlobalNamesPass", "(", ")", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addMemorySpaceInferencePasses", "(", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

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

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

[ "Kudeyar" ]

[]

[ "<s>", "bool", "Mips16HardFloat", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Run on Module Mips16HardFloat\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "Module", "::", "iterator", "F", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "F", "!=", "E", ";", "++", "F", ")", "{", "if", "(", "F", "->", "isDeclaration", "(", ")", "||", "F", "->", "hasFnAttribute", "(", "\"mips16_fp_stub\"", ")", "||", "F", "->", "hasFnAttribute", "(", "\"nomips16\"", ")", ")", "continue", ";", "Modified", "|=", "fixupFPReturnAndCall", "(", "*", "F", ",", "&", "M", ",", "Subtarget", ")", ";", "FPParamVariant", "V", "=", "whichFPParamVariantNeeded", "(", "*", "F", ")", ";", "if", "(", "V", "!=", "NoSig", ")", "{", "Modified", "=", "true", ";", "createFPFnStub", "(", "F", ",", "&", "M", ",", "V", ",", "Subtarget", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "Mips", "Mips", "\"Run on Module Mips16HardFloat\\n\"", "\"mips16_fp_stub\"", "\"nomips16\"" ]

[]

[ "<s>", "int", "shmedia_cleanup_truncate", "(", "rtx", "x", ")", "{", "int", "n_changes", "=", "0", ";", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "x", ",", "NONCONST", ")", "{", "rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "TRUNCATE", ")", "{", "rtx", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "machine_mode", "reg_mode", "=", "GET_MODE", "(", "reg", ")", ";", "if", "(", "REG_P", "(", "reg", ")", "&&", "GET_MODE_SIZE", "(", "reg_mode", ")", ">", "8", ")", "{", "int", "offset", "=", "subreg_lowpart_offset", "(", "DImode", ",", "reg_mode", ")", ";", "XEXP", "(", "x", ",", "0", ")", "=", "simplify_subreg", "(", "DImode", ",", "reg", ",", "reg_mode", ",", "offset", ")", ";", "n_changes", "+=", "1", ";", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "}", "}", "return", "n_changes", ";", "}", "</s>" ]

[ "Look", "through", "X", "cleaning", "up", "truncates", "of", "registers", "that", "span", "multiple", "actual", "hard", "registers", ".", "Return", "the", "number", "of", "changes", "made", "." ]

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

[]

[ "<s>", "bool", "XNCMInstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "MI", "->", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "isBranch", "(", ")", "&&", "!", "MI", "->", "isBarrier", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MI", "->", "isPredicable", "(", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "XNCM", "XNCM" ]

[]

[ "<s>", "void", "TLCS900InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", ";", "if", "(", "TLCS900", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "TLCS900", "::", "MOV16rr", ";", "else", "if", "(", "TLCS900", "::", "GR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "TLCS900", "::", "MOV8rr", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "TLCS900", "TLCS900", "TLCS900::GR16RegClass", "TLCS900::MOV16rr", "TLCS900::GR8RegClass", "TLCS900::MOV8rr", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "inline", "machine_mode", "function_instance", "::", "vector_mode", "(", "unsigned", "int", "i", ")", "const", "{", "return", "type_suffix", "(", "i", ")", ".", "vector_mode", ";", "}", "</s>" ]

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

[ "aarch64" ]

[]

[ "<s>", "static", "rtx", "function_arg_record_value", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "int", "slotno", ",", "int", "named", ",", "int", "regbase", ")", "{", "HOST_WIDE_INT", "typesize", "=", "int_size_in_bytes", "(", "type", ")", ";", "struct", "function_arg_record_value_parms", "parms", ";", "unsigned", "int", "nregs", ";", "parms", ".", "ret", "=", "NULL_RTX", ";", "parms", ".", "slotno", "=", "slotno", ";", "parms", ".", "named", "=", "named", ";", "parms", ".", "regbase", "=", "regbase", ";", "parms", ".", "stack", "=", "0", ";", "parms", ".", "nregs", "=", "0", ";", "parms", ".", "intoffset", "=", "0", ";", "function_arg_record_value_1", "(", "type", ",", "0", ",", "&", "parms", ",", "false", ")", ";", "if", "(", "parms", ".", "intoffset", "!=", "-", "1", ")", "{", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "intslots", ",", "this_slotno", ";", "startbit", "=", "parms", ".", "intoffset", "&", "-", "BITS_PER_WORD", ";", "endbit", "=", "(", "typesize", "*", "BITS_PER_UNIT", "+", "BITS_PER_WORD", "-", "1", ")", "&", "-", "BITS_PER_WORD", ";", "intslots", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "this_slotno", "=", "slotno", "+", "parms", ".", "intoffset", "/", "BITS_PER_WORD", ";", "if", "(", "intslots", ">", "0", "&&", "intslots", ">", "SPARC_INT_ARG_MAX", "-", "this_slotno", ")", "{", "intslots", "=", "MAX", "(", "0", ",", "SPARC_INT_ARG_MAX", "-", "this_slotno", ")", ";", "parms", ".", "stack", "=", "1", ";", "}", "parms", ".", "nregs", "+=", "intslots", ";", "}", "nregs", "=", "parms", ".", "nregs", ";", "if", "(", "nregs", "==", "0", ")", "{", "if", "(", "typesize", "<=", "0", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "regbase", ")", ";", "}", "else", "{", "nregs", "=", "(", "typesize", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "if", "(", "nregs", "+", "slotno", ">", "SPARC_INT_ARG_MAX", ")", "nregs", "=", "SPARC_INT_ARG_MAX", "-", "slotno", ";", "}", "gcc_assert", "(", "nregs", "!=", "0", ")", ";", "parms", ".", "ret", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "parms", ".", "stack", "+", "nregs", ")", ")", ";", "if", "(", "parms", ".", "stack", ")", "XVECEXP", "(", "parms", ".", "ret", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "parms", ".", "nregs", "=", "0", ";", "parms", ".", "intoffset", "=", "0", ";", "function_arg_record_value_2", "(", "type", ",", "0", ",", "&", "parms", ",", "false", ")", ";", "function_arg_record_value_3", "(", "typesize", "*", "BITS_PER_UNIT", ",", "&", "parms", ")", ";", "gcc_assert", "(", "parms", ".", "nregs", "==", "nregs", ")", ";", "return", "parms", ".", "ret", ";", "}", "</s>" ]

[ "Used", "by", "function_arg", "and", "sparc_function_value_1", "to", "implement", "the", "complex", "conventions", "of", "the", "64-bit", "ABI", "for", "passing", "and", "returning", "structures", ".", "Return", "an", "expression", "valid", "as", "a", "return", "value", "for", "the", "FUNCTION_ARG", "and", "TARGET_FUNCTION_VALUE", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "SLOTNO", "is", "the", "index", "number", "of", "the", "argument", "'s", "slot", "in", "the", "parameter", "array", ".", "NAMED", "is", "true", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "REGBASE", "is", "the", "regno", "of", "the", "base", "register", "for", "the", "parameter", "array", "." ]

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

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "CodeGenOpt", "::", "Level", "OptLevel", "=", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "FADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ",", "nvptxSubtarget", ",", "OptLevel", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "PerformSHLCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::FADD", "ISD::MUL", "ISD::SHL", "ISD::AND" ]

[]

[ "<s>", "int", "tilepro_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "insn", ")", ";", "if", "(", "mode", "==", "SImode", ")", "return", "0", ";", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "INSN", ".", "LENGTH", "is", "the", "initial", "length", "computed", "by", "attributes", "in", "the", "machine-description", "file", ".", "This", "is", "where", "we", "account", "for", "bundles", "." ]

[ "tilepro", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "buildOutlinedFrame", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "TargetCostInfo", "&", "TCI", ")", "const", "{", "if", "(", "TCI", ".", "FrameConstructionID", "==", "MachineOutlinerTailCall", ")", "return", ";", "MachineInstr", "*", "retq", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "X86", "::", "RETQ", ")", ")", ";", "MBB", ".", "insert", "(", "MBB", ".", "end", "(", ")", ",", "retq", ")", ";", "}", "</s>" ]

[ "Insert", "a", "custom", "frame", "for", "outlined", "functions", "." ]

[ "X86", "X86", "X86::RETQ" ]

[]

[ "<s>", "void", "GCNSubtarget", "::", "adjustSchedDependency", "(", "SUnit", "*", "Src", ",", "SUnit", "*", "Dst", ",", "SDep", "&", "Dep", ")", "const", "{", "if", "(", "Dep", ".", "getKind", "(", ")", "!=", "SDep", "::", "Kind", "::", "Data", "||", "!", "Dep", ".", "getReg", "(", ")", "||", "!", "Src", "->", "isInstr", "(", ")", "||", "!", "Dst", "->", "isInstr", "(", ")", ")", "return", ";", "MachineInstr", "*", "SrcI", "=", "Src", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "DstI", "=", "Dst", "->", "getInstr", "(", ")", ";", "if", "(", "SrcI", "->", "isBundle", "(", ")", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "getRegisterInfo", "(", ")", ";", "auto", "Reg", "=", "Dep", ".", "getReg", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "(", "SrcI", "->", "getIterator", "(", ")", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "(", "SrcI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ")", ";", "unsigned", "Lat", "=", "0", ";", "for", "(", "++", "I", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", ";", "++", "I", ")", "{", "if", "(", "I", "->", "modifiesRegister", "(", "Reg", ",", "TRI", ")", ")", "Lat", "=", "InstrInfo", ".", "getInstrLatency", "(", "getInstrItineraryData", "(", ")", ",", "*", "I", ")", ";", "else", "if", "(", "Lat", ")", "--", "Lat", ";", "}", "Dep", ".", "setLatency", "(", "Lat", ")", ";", "}", "else", "if", "(", "DstI", "->", "isBundle", "(", ")", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "getRegisterInfo", "(", ")", ";", "auto", "Reg", "=", "Dep", ".", "getReg", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "(", "DstI", "->", "getIterator", "(", ")", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "(", "DstI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ")", ";", "unsigned", "Lat", "=", "InstrInfo", ".", "getInstrLatency", "(", "getInstrItineraryData", "(", ")", ",", "*", "SrcI", ")", ";", "for", "(", "++", "I", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", "&&", "Lat", ";", "++", "I", ")", "{", "if", "(", "I", "->", "readsRegister", "(", "Reg", ",", "TRI", ")", ")", "break", ";", "--", "Lat", ";", "}", "Dep", ".", "setLatency", "(", "Lat", ")", ";", "}", "}", "</s>" ]

[ "Perform", "target", "specific", "adjustments", "to", "the", "latency", "of", "a", "schedule", "dependency", "." ]

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

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "StringRef", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "StringRef", "CPU", "=", "TM", ".", "getTargetCPU", "(", ")", ";", "StringRef", "FS", "=", "TM", ".", "getTargetFeatureString", "(", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "const", "NVPTXSubtarget", "STI", "(", "TT", ",", "CPU", ",", "FS", ",", "NTM", ")", ";", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "MMI", "->", "AnalyzeModule", "(", "M", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "Mang", "=", "new", "Mangler", "(", "TM", ".", "getDataLayout", "(", ")", ")", ";", "emitHeader", "(", "M", ",", "OS1", ",", "STI", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS1", ".", "str", "(", ")", ")", ";", "if", "(", "!", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "AddComment", "(", "\"Start of file scope inline assembly\"", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "M", ".", "getModuleInlineAsm", "(", ")", ")", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "OutStreamer", ".", "AddComment", "(", "\"End of file scope inline assembly\"", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "if", "(", "Triple", "(", "TM", ".", "getTargetTriple", "(", ")", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "NVCL", ")", "recordAndEmitFilenames", "(", "M", ")", ";", "GlobalsEmitted", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "128", "\"Start of file scope inline assembly\"", "\"End of file scope inline assembly\"" ]

[]

[ "<s>", "void", "end", "(", ")", "{", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "AMDGPU" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "internalKnownBits", "(", ")", "const", "{", "unsigned", "Bits", "=", "Unalign", "?", "Unalign", ":", "KnownBits", ";", "if", "(", "Size", "&", "(", "(", "1u", "<<", "Bits", ")", "-", "1", ")", ")", "Bits", "=", "CountTrailingZeros_32", "(", "Size", ")", ";", "return", "Bits", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "known", "offset", "bits", "internally", "to", "this", "block", "." ]

[ "ARM", "1u", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'d'", ":", "case", "'y'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR32RegClass", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", "->", "isSingleFloat", "(", ")", ")", ")", "{", "if", "(", "Subtarget", "->", "isFP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "AFGR64RegClass", ")", ";", "}", "break", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Unexpected type.\"", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9_64", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "case", "'l'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO", ",", "&", "Mips", "::", "HILORegClass", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO64", ",", "&", "Mips", "::", "HILO64RegClass", ")", ";", "case", "'x'", ":", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "0", "MVT::i32", "MVT::i16", "MVT::i8", "0U", "Mips::CPURegsRegClass", "MVT::i64", "Mips", "0U", "Mips::CPURegsRegClass", "MVT::i64", "Mips", "0U", "Mips::CPU64RegsRegClass", "0u", "0", "MVT::f32", "0U", "Mips::FGR32RegClass", "MVT::f64", "0U", "Mips::FGR64RegClass", "0U", "Mips::AFGR64RegClass", "MVT::i32", "Mips::T9", "Mips::CPURegsRegClass", "MVT::i64", "\"Unexpected type.\"", "Mips::T9_64", "Mips::CPU64RegsRegClass", "MVT::i32", "Mips::LO", "Mips::HILORegClass", "Mips::LO64", "Mips::HILO64RegClass", "0u", "0" ]

[]

[ "<s>", "const", "char", "*", "mcore_output_andn", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "operands", "[", "]", ")", "{", "HOST_WIDE_INT", "x", ",", "y", ";", "rtx", "out_operands", "[", "3", "]", ";", "const", "char", "*", "load_op", ";", "char", "buf", "[", "256", "]", ";", "int", "trick_no", ";", "trick_no", "=", "try_constant_tricks", "(", "INTVAL", "(", "operands", "[", "1", "]", ")", ",", "&", "x", ",", "&", "y", ")", ";", "gcc_assert", "(", "trick_no", "==", "2", ")", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "x", ")", ";", "out_operands", "[", "2", "]", "=", "operands", "[", "2", "]", ";", "if", "(", "x", ">=", "0", "&&", "x", "<=", "127", ")", "load_op", "=", "\"movi\\t%0,%1\"", ";", "else", "if", "(", "CONST_OK_FOR_M", "(", "x", ")", ")", "load_op", "=", "\"bgeni\\t%0,%P1\"", ";", "else", "if", "(", "CONST_OK_FOR_N", "(", "x", ")", ")", "load_op", "=", "\"bmaski\\t%0,%N1\"", ";", "else", "{", "load_op", "=", "\"BADMOVI-andn\\t%0, %1\"", ";", "gcc_unreachable", "(", ")", ";", "}", "sprintf", "(", "buf", ",", "\"%s\\n\\tandn\\t%%2,%%0\"", ",", "load_op", ")", ";", "output_asm_insn", "(", "buf", ",", "out_operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Outputs", "the", "peephole", "for", "moving", "a", "constant", "that", "gets", "not'ed", "followed", "by", "an", "and", "(", "i.e", ".", "combine", "the", "not", "and", "the", "and", "into", "andn", ")", ".", "BRC" ]

[ "mcore", "3", "256", "1", "2", "0", "0", "1", "2", "2", "0", "127", "\"movi\\t%0,%1\"", "\"bgeni\\t%0,%P1\"", "\"bmaski\\t%0,%N1\"", "\"BADMOVI-andn\\t%0, %1\"", "\"%s\\n\\tandn\\t%%2,%%0\"", "\"\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "PatmosMachineFunctionInfo", "*", "PMFI", "=", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "MinSubfunctionAlignment", ">", "MF", ".", "getAlignment", "(", ")", ".", "value", "(", ")", ")", "{", "MF", ".", "ensureAlignment", "(", "Align", "(", "MinSubfunctionAlignment", ")", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "MachineFunction", "::", "iterator", "i", "=", "MF", ".", "begin", "(", ")", ",", "ie", "=", "MF", ".", "end", "(", ")", ";", "i", "!=", "ie", ";", "++", "i", ")", "{", "unsigned", "align", ";", "if", "(", "PMFI", "->", "isMethodCacheRegionEntry", "(", "&", "*", "i", ")", ")", "{", "align", "=", "MinSubfunctionAlignment", ";", "}", "else", "{", "align", "=", "i", "->", "getAlignment", "(", ")", ".", "value", "(", ")", ";", "}", "if", "(", "align", ">", "i", "->", "getAlignment", "(", ")", ".", "value", "(", ")", ")", "{", "i", "->", "setAlignment", "(", "Align", "(", "align", ")", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Videocore", "Videocore" ]

[]

[ "<s>", "static", "inline", "bool", "has_func_attr", "(", "const_tree", "decl", ",", "const", "char", "*", "func_attr", ")", "{", "if", "(", "decl", "==", "NULL_TREE", ")", "decl", "=", "current_function_decl", ";", "return", "lookup_attribute", "(", "func_attr", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "specified", "attribute", "." ]

[ "rl78" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "MachineRegisterInfo", "&", "MRI", ",", "SplitArgTy", "PerformArgSplit", ")", "const", "{", "const", "X86TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "X86TargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Context", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "4", ">", "Offsets", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "0", ")", ";", "if", "(", "OrigArg", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "return", "true", ";", "EVT", "VT", "=", "SplitVTs", "[", "0", "]", ";", "unsigned", "NumParts", "=", "TLI", ".", "getNumRegisters", "(", "Context", ",", "VT", ")", ";", "if", "(", "NumParts", "==", "1", ")", "{", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Reg", ",", "VT", ".", "getTypeForEVT", "(", "Context", ")", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", "true", ";", "}", "SmallVector", "<", "unsigned", ",", "8", ">", "SplitRegs", ";", "EVT", "PartVT", "=", "TLI", ".", "getRegisterType", "(", "Context", ",", "VT", ")", ";", "Type", "*", "PartTy", "=", "PartVT", ".", "getTypeForEVT", "(", "Context", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumParts", ";", "++", "i", ")", "{", "ArgInfo", "Info", "=", "ArgInfo", "{", "MRI", ".", "createGenericVirtualRegister", "(", "getLLTForType", "(", "*", "PartTy", ",", "DL", ")", ")", ",", "PartTy", ",", "OrigArg", ".", "Flags", "}", ";", "SplitArgs", ".", "push_back", "(", "Info", ")", ";", "SplitRegs", ".", "push_back", "(", "Info", ".", "Reg", ")", ";", "}", "PerformArgSplit", "(", "SplitRegs", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

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

[]

[ "<s>", "int", "mcore_byte_offset", "(", "unsigned", "int", "mask", ")", "{", "if", "(", "mask", "==", "0x00ffffffL", ")", "return", "0", ";", "else", "if", "(", "mask", "==", "0xff00ffffL", ")", "return", "1", ";", "else", "if", "(", "mask", "==", "0xffff00ffL", ")", "return", "2", ";", "else", "if", "(", "mask", "==", "0xffffff00L", ")", "return", "3", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Determine", "byte", "being", "masked", "." ]

[ "mcore", "0x00ffffffL", "0", "0xff00ffffL", "1", "0xffff00ffL", "2", "0xffffff00L", "3", "1" ]

[]

[ "<s>", "static", "void", "addInst", "(", "MachineInstr", "*", "MI", ")", "{", "Blocks", ".", "back", "(", ")", ".", "insert", "(", "MI", ")", ";", "PredicatedInsts", ".", "emplace", "(", "MI", ",", "std", "::", "make_unique", "<", "PredicatedMI", ">", "(", "MI", ",", "CurrentPredicates", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCInst", "operand", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_storewb_pair", "(", "machine_mode", "mode", ",", "rtx", "base", ",", "rtx", "reg", ",", "rtx", "reg2", ",", "HOST_WIDE_INT", "adjustment", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "return", "gen_storewb_pairdi_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "-", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", "-", "adjustment", ")", ")", ";", "case", "E_DFmode", ":", "return", "gen_storewb_pairdf_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "-", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", "-", "adjustment", ")", ")", ";", "case", "E_TFmode", ":", "return", "gen_storewb_pairtf_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "-", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_VREG", "-", "adjustment", ")", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "and", "return", "an", "instruction", "to", "store", "the", "pair", "of", "registers", "REG", "and", "REG2", "of", "mode", "MODE", "to", "location", "BASE", "with", "write-back", "adjusting", "the", "stack", "location", "BASE", "by", "ADJUSTMENT", "." ]

[ "aarch64" ]

[]

[ "<s>", "MachineBasicBlock", "*", "XCoreTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "SELECT_CC", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "BRFT_lru6", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::SELECT_CC", "\"Unexpected instr type to insert\"", "XCore::BRFT_lru6", "1", "XCore::PHI", "0", "3", "2" ]

[]

[ "<s>", "void", "pru_function_profiler", "(", "FILE", "*", "file", ",", "int", "labelno", "ATTRIBUTE_UNUSED", ")", "{", "fprintf", "(", "file", ",", "\"\\tmov\\tr1, ra\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tcall\\t_mcount\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tmov\\tra, r1\\n\"", ")", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_PROFILER", "macro", "." ]

[ "pru", "\"\\tmov\\tr1, ra\\n\"", "\"\\tcall\\t_mcount\\n\"", "\"\\tmov\\tra, r1\\n\"" ]

[]

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

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

[ "LM32" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AVRMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "return", "(", "FuncInfo", "->", "getHasSpills", "(", ")", "||", "FuncInfo", "->", "getHasAllocas", "(", ")", "||", "FuncInfo", "->", "getHasStackArgs", "(", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR" ]

[]

[ "<s>", "void", "CAHPFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "CAHP", "::", "X0", ")", ";", "SavedRegs", ".", "set", "(", "CAHP", "::", "X2", ")", ";", "}", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP::X0", "CAHP::X2" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "std", "::", "vector", "<", "SDNode", "*", ">", "*", "Created", ")", "const", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "||", "!", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "(", "-", "Divisor", ")", ".", "isPowerOf2", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "bool", "IsNegPow2", "=", "(", "-", "Divisor", ")", ".", "isPowerOf2", "(", ")", ";", "unsigned", "Lg2", "=", "(", "IsNegPow2", "?", "-", "Divisor", ":", "Divisor", ")", ".", "countTrailingZeros", "(", ")", ";", "SDValue", "ShiftAmt", "=", "DAG", ".", "getConstant", "(", "Lg2", ",", "DL", ",", "VT", ")", ";", "SDValue", "Op", "=", "DAG", ".", "getNode", "(", "PPCISD", "::", "SRA_ADDZE", ",", "DL", ",", "VT", ",", "N0", ",", "ShiftAmt", ")", ";", "if", "(", "Created", ")", "Created", "->", "push_back", "(", "Op", ".", "getNode", "(", ")", ")", ";", "if", "(", "IsNegPow2", ")", "{", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ",", "Op", ")", ";", "if", "(", "Created", ")", "Created", "->", "push_back", "(", "Op", ".", "getNode", "(", ")", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "PowerPC", "PPC", "0", "MVT::i64", "PPC", "MVT::i32", "MVT::i64", "0", "PPCISD::SRA_ADDZE", "ISD::SUB", "0" ]

[]

[ "<s>", "void", "AMDGPUInstPrinter", "::", "printOffset", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "uint16_t", "Imm", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", ";", "if", "(", "Imm", "!=", "0", ")", "{", "O", "<<", "(", "(", "OpNo", "==", "0", ")", "?", "\"offset:\"", ":", "\" offset:\"", ")", ";", "printU16ImmDecOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "just", "convenient", "handler", "for", "printing", "offsets", "." ]

[ "AMDGPU", "AMDGPU", "0", "0", "\"offset:\"", "\" offset:\"" ]

[]

[ "<s>", "static", "int", "epiphany_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "?", "3", ":", "4", ";", "}", "</s>" ]

[ "Compute", "the", "cost", "of", "moving", "data", "between", "registers", "and", "memory", ".", "For", "integer", ",", "load", "latency", "is", "twice", "as", "long", "as", "register-register", "moves", ",", "but", "issue", "pich", "is", "the", "same", ".", "For", "floating", "point", ",", "load", "latency", "is", "three", "times", "as", "much", "as", "a", "reg-reg", "move", "." ]

[ "epiphany", "3", "4" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "ignore", ")", "{", "tree", "fndecl", ";", "unsigned", "int", "fcode", ",", "avail", ";", "const", "struct", "mips_builtin_description", "*", "d", ";", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "gcc_assert", "(", "fcode", "<", "ARRAY_SIZE", "(", "mips_builtins", ")", ")", ";", "d", "=", "&", "mips_builtins", "[", "fcode", "]", ";", "avail", "=", "d", "->", "avail", "(", ")", ";", "gcc_assert", "(", "avail", "!=", "0", ")", ";", "if", "(", "TARGET_MIPS16", "&&", "!", "(", "avail", "&", "BUILTIN_AVAIL_MIPS16", ")", ")", "{", "error", "(", "\"built-in function %qE not supported for MIPS16\"", ",", "DECL_NAME", "(", "fndecl", ")", ")", ";", "return", "ignore", "?", "const0_rtx", ":", "CONST0_RTX", "(", "mode", ")", ";", "}", "switch", "(", "d", "->", "builtin_type", ")", "{", "case", "MIPS_BUILTIN_DIRECT", ":", "return", "mips_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "true", ")", ";", "case", "MIPS_BUILTIN_DIRECT_NO_TARGET", ":", "return", "mips_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "false", ")", ";", "case", "MIPS_BUILTIN_MOVT", ":", "case", "MIPS_BUILTIN_MOVF", ":", "return", "mips_expand_builtin_movtf", "(", "d", "->", "builtin_type", ",", "d", "->", "icode", ",", "d", "->", "cond", ",", "target", ",", "exp", ")", ";", "case", "MIPS_BUILTIN_CMP_ANY", ":", "case", "MIPS_BUILTIN_CMP_ALL", ":", "case", "MIPS_BUILTIN_CMP_UPPER", ":", "case", "MIPS_BUILTIN_CMP_LOWER", ":", "case", "MIPS_BUILTIN_CMP_SINGLE", ":", "return", "mips_expand_builtin_compare", "(", "d", "->", "builtin_type", ",", "d", "->", "icode", ",", "d", "->", "cond", ",", "target", ",", "exp", ")", ";", "case", "MIPS_BUILTIN_BPOSGE32", ":", "return", "mips_expand_builtin_bposge", "(", "d", "->", "builtin_type", ",", "target", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Expand", "builtin", "functions", ".", "This", "is", "called", "from", "TARGET_EXPAND_BUILTIN", "." ]

[ "mips", "0", "0", "\"built-in function %qE not supported for MIPS16\"" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "if", "(", "MI", "->", "isCopy", "(", ")", "&&", "(", "(", "DstRC", "->", "getID", "(", ")", "==", "AArch64", "::", "GPR64RegClassID", ")", "||", "(", "DstRC", "->", "getID", "(", ")", "==", "AArch64", "::", "GPR64commonRegClassID", ")", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "AArch64", "AArch64", "AArch64::GPR64RegClassID", "AArch64::GPR64commonRegClassID", "0", "1" ]

[]

[ "<s>", "const", "Nios2RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "static", "tree", "make_var_decl", "(", "tree", "type", ",", "const", "char", "*", "name", ")", "{", "tree", "new_decl", ";", "new_decl", "=", "build_decl", "(", "UNKNOWN_LOCATION", ",", "VAR_DECL", ",", "get_identifier", "(", "name", ")", ",", "type", ")", ";", "DECL_EXTERNAL", "(", "new_decl", ")", "=", "1", ";", "TREE_STATIC", "(", "new_decl", ")", "=", "1", ";", "TREE_PUBLIC", "(", "new_decl", ")", "=", "1", ";", "DECL_INITIAL", "(", "new_decl", ")", "=", "0", ";", "DECL_ARTIFICIAL", "(", "new_decl", ")", "=", "0", ";", "DECL_PRESERVE_P", "(", "new_decl", ")", "=", "1", ";", "make_decl_one_only", "(", "new_decl", ",", "DECL_ASSEMBLER_NAME", "(", "new_decl", ")", ")", ";", "assemble_variable", "(", "new_decl", ",", "0", ",", "0", ",", "0", ")", ";", "return", "new_decl", ";", "}", "</s>" ]

[ "Returns", "a", "extern", ",", "comdat", "VAR_DECL", "of", "type", "TYPE", "and", "name", "NAME", "." ]

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

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "SystemZInstrInfo", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "RET", "&&", "\"Can only insert epilogue into returning blocks\"", ")", ";", "uint64_t", "StackSize", "=", "getAllocatedStackSize", "(", "MF", ")", ";", "if", "(", "ZFI", "->", "getLowSavedGPR", "(", ")", ")", "{", "--", "MBBI", ";", "unsigned", "Opcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "!=", "SystemZ", "::", "LMG", ")", "llvm_unreachable", "(", "\"Expected to see callee-save register restore code\"", ")", ";", "unsigned", "AddrOpNo", "=", "2", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Offset", "=", "StackSize", "+", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "if", "(", "!", "NewOpcode", ")", "{", "uint64_t", "NumBytes", "=", "Offset", "-", "0x7fff8", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MBBI", "->", "getOperand", "(", "AddrOpNo", ")", ".", "getReg", "(", ")", ",", "NumBytes", ",", "ZII", ")", ";", "Offset", "-=", "NumBytes", ";", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "assert", "(", "NewOpcode", "&&", "\"No restore instruction available\"", ")", ";", "}", "MBBI", "->", "setDesc", "(", "ZII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SystemZ", "::", "R15D", ",", "StackSize", ",", "ZII", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::RET", "\"Can only insert epilogue into returning blocks\"", "SystemZ::LMG", "\"Expected to see callee-save register restore code\"", "2", "1", "0x7fff8", "\"No restore instruction available\"", "1", "SystemZ::R15D" ]

[]

[ "<s>", "static", "scalar_int_mode", "aarch64_sve_container_int_mode", "(", "machine_mode", "mode", ")", "{", "return", "int_mode_for_size", "(", "aarch64_sve_container_bits", "(", "mode", ")", ",", "0", ")", ".", "require", "(", ")", ";", "}", "</s>" ]

[ "Return", "an", "integer", "element", "mode", "that", "contains", "exactly", "aarch64_sve_container_bits", "(", "MODE", ")", "bits", ".", "This", "is", "wider", "than", "aarch64_sve_element_int_mode", "if", "MODE", "is", "a", "partial", "vector", ",", "otherwise", "it", "'s", "the", "same", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "PerformTailCallOpt", "&&", "I", "->", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "{", "if", "(", "int", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "CalleeAmt", "*=", "-", "1", ";", "unsigned", "StackReg", "=", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "unsigned", "TmpReg", "=", "is64Bit", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ";", "unsigned", "ADDIInstr", "=", "is64Bit", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "unsigned", "ADDInstr", "=", "is64Bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ";", "unsigned", "LISInstr", "=", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ";", "unsigned", "ORIInstr", "=", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ";", "MachineInstr", "*", "MI", "=", "I", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isInt16", "(", "CalleeAmt", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDIInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LISInstr", ")", ",", "TmpReg", ")", ".", "addImm", "(", "CalleeAmt", ">>", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ORIInstr", ")", ",", "TmpReg", ")", ".", "addReg", "(", "TmpReg", ",", "false", ",", "false", ",", "true", ")", ".", "addImm", "(", "CalleeAmt", "&", "0xFFFF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDInstr", ")", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "TmpReg", ")", ";", "}", "}", "}", "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", ")", "." ]

[ "PowerPC", "PPC", "PPC::ADJCALLSTACKUP", "1", "PPC", "1", "PPC::X1", "PPC::R1", "PPC::X0", "PPC::R0", "PPC::ADDI8", "PPC::ADDI", "PPC::ADD8", "PPC::ADD4", "PPC::LIS8", "PPC::LIS", "PPC::ORI8", "PPC::ORI", "16", "0xFFFF" ]

[]

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

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

[ "SNES", "SNES" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "AMDGPUISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMPED", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "case", "AMDGPUISD", "::", "FIRST_MEM_OPCODE_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "case", "AMDGPUISD", "::", "LAST_AMDGPU_ISD_NUMBER", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPUISD::NodeType", "AMDGPUISD::FIRST_NUMBER", "SI", "AMDGPUISD::FIRST_MEM_OPCODE_NUMBER", "AMDGPUISD::LAST_AMDGPU_ISD_NUMBER" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SparcTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "BROpcode", ";", "unsigned", "CC", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Unknown SELECT_CC!\"", ")", ";", "case", "SP", "::", "SELECT_CC_Int_ICC", ":", "case", "SP", "::", "SELECT_CC_FP_ICC", ":", "case", "SP", "::", "SELECT_CC_DFP_ICC", ":", "BROpcode", "=", "SP", "::", "BCOND", ";", "break", ";", "case", "SP", "::", "SELECT_CC_Int_FCC", ":", "case", "SP", "::", "SELECT_CC_FP_FCC", ":", "case", "SP", "::", "SELECT_CC_DFP_FCC", ":", "BROpcode", "=", "SP", "::", "FBCOND", ";", "break", ";", "}", "CC", "=", "(", "SPCC", "::", "CondCodes", ")", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "BROpcode", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ".", "addImm", "(", "CC", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "transferSuccessors", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "F", "->", "DeleteMachineInstr", "(", "MI", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "0", "\"Unknown SELECT_CC!\"", "SP::SELECT_CC_Int_ICC", "SP::SELECT_CC_FP_ICC", "SP::SELECT_CC_DFP_ICC", "SP::BCOND", "SP::SELECT_CC_Int_FCC", "SP::SELECT_CC_FP_FCC", "SP::SELECT_CC_DFP_FCC", "SP::FBCOND", "SPCC::CondCodes", "3", "SP::PHI", "0", "2", "1" ]

[]

[ "<s>", "TargetPassConfig", "*", "VETargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "VEPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "VE", "VE", "VE" ]

[]

[ "<s>", "static", "machine_mode", "ix86_get_mask_mode", "(", "unsigned", "nunits", ",", "unsigned", "vector_size", ")", "{", "unsigned", "elem_size", "=", "vector_size", "/", "nunits", ";", "if", "(", "(", "TARGET_AVX512F", "&&", "vector_size", "==", "64", ")", "||", "(", "TARGET_AVX512VL", "&&", "(", "vector_size", "==", "32", "||", "vector_size", "==", "16", ")", ")", ")", "{", "if", "(", "elem_size", "==", "4", "||", "elem_size", "==", "8", "||", "TARGET_AVX512BW", ")", "return", "smallest_mode_for_size", "(", "nunits", ",", "MODE_INT", ")", ";", "}", "machine_mode", "elem_mode", "=", "smallest_mode_for_size", "(", "elem_size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ")", ";", "gcc_assert", "(", "elem_size", "*", "nunits", "==", "vector_size", ")", ";", "return", "mode_for_vector", "(", "elem_mode", ",", "nunits", ")", ";", "}", "</s>" ]

[ "Implemenation", "of", "targetm.vectorize.get_mask_mode", "." ]

[ "i386", "64", "32", "16", "4", "8" ]

[]

[ "<s>", "void", "XCoreTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "DataSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.data\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "BSSSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.bss\"", ",", "MCSectionELF", "::", "SHT_NOBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "MergeableConst4Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst4\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst4", "(", ")", ")", ";", "MergeableConst8Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst8\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst8", "(", ")", ")", ";", "MergeableConst16Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst16\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst16", "(", ")", ")", ";", "TLSDataSection", "=", "DataSection", ";", "TLSBSSSection", "=", "BSSSection", ";", "ReadOnlySection", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "DataRelSection", "=", "DataRelLocalSection", "=", "DataSection", ";", "DataRelROSection", "=", "DataRelROLocalSection", "=", "ReadOnlySection", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\".dp.data\"", "\".dp.bss\"", "\".cp.rodata.cst4\"", "\".cp.rodata.cst8\"", "\".cp.rodata.cst16\"", "\".cp.rodata\"" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "RISCVISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "RISCVISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "RISCVISD", "::", "RET_FLAG", ":", "return", "\"RISCVISD::RET_FLAG\"", ";", "case", "RISCVISD", "::", "URET_FLAG", ":", "return", "\"RISCVISD::URET_FLAG\"", ";", "case", "RISCVISD", "::", "SRET_FLAG", ":", "return", "\"RISCVISD::SRET_FLAG\"", ";", "case", "RISCVISD", "::", "MRET_FLAG", ":", "return", "\"RISCVISD::MRET_FLAG\"", ";", "case", "RISCVISD", "::", "CALL", ":", "return", "\"RISCVISD::CALL\"", ";", "case", "RISCVISD", "::", "SELECT_CC", ":", "return", "\"RISCVISD::SELECT_CC\"", ";", "case", "RISCVISD", "::", "BuildPairF64", ":", "return", "\"RISCVISD::BuildPairF64\"", ";", "case", "RISCVISD", "::", "SplitF64", ":", "return", "\"RISCVISD::SplitF64\"", ";", "case", "RISCVISD", "::", "TAIL", ":", "return", "\"RISCVISD::TAIL\"", ";", "case", "RISCVISD", "::", "SLLW", ":", "return", "\"RISCVISD::SLLW\"", ";", "case", "RISCVISD", "::", "SRAW", ":", "return", "\"RISCVISD::SRAW\"", ";", "case", "RISCVISD", "::", "SRLW", ":", "return", "\"RISCVISD::SRLW\"", ";", "case", "RISCVISD", "::", "DIVW", ":", "return", "\"RISCVISD::DIVW\"", ";", "case", "RISCVISD", "::", "DIVUW", ":", "return", "\"RISCVISD::DIVUW\"", ";", "case", "RISCVISD", "::", "REMUW", ":", "return", "\"RISCVISD::REMUW\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVISD::NodeType", "RISCVISD::FIRST_NUMBER", "RISCVISD::RET_FLAG", "\"RISCVISD::RET_FLAG\"", "RISCVISD::URET_FLAG", "\"RISCVISD::URET_FLAG\"", "RISCVISD::SRET_FLAG", "\"RISCVISD::SRET_FLAG\"", "RISCVISD::MRET_FLAG", "\"RISCVISD::MRET_FLAG\"", "RISCVISD::CALL", "\"RISCVISD::CALL\"", "RISCVISD::SELECT_CC", "\"RISCVISD::SELECT_CC\"", "RISCVISD::BuildPairF64", "\"RISCVISD::BuildPairF64\"", "RISCVISD::SplitF64", "\"RISCVISD::SplitF64\"", "RISCVISD::TAIL", "\"RISCVISD::TAIL\"", "RISCVISD::SLLW", "\"RISCVISD::SLLW\"", "RISCVISD::SRAW", "\"RISCVISD::SRAW\"", "RISCVISD::SRLW", "\"RISCVISD::SRLW\"", "RISCVISD::DIVW", "\"RISCVISD::DIVW\"", "RISCVISD::DIVUW", "\"RISCVISD::DIVUW\"", "RISCVISD::REMUW", "\"RISCVISD::REMUW\"" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerCall", "(", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "const", "Function", "&", "Fn", "=", "*", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "StringRef", "FuncName", "(", "\"<unknown>\"", ")", ";", "if", "(", "const", "ExternalSymbolSDNode", "*", "G", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "FuncName", "=", "G", "->", "getSymbol", "(", ")", ";", "else", "if", "(", "const", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "FuncName", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "DiagnosticInfoUnsupported", "NoCalls", "(", "Fn", ",", "\"unsupported call to function \"", "+", "FuncName", ",", "CLI", ".", "DL", ".", "getDebugLoc", "(", ")", ")", ";", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "NoCalls", ")", ";", "if", "(", "!", "CLI", ".", "IsTailCall", ")", "{", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CLI", ".", "Ins", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "InVals", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "CLI", ".", "Ins", "[", "I", "]", ".", "VT", ")", ")", ";", "}", "return", "DAG", ".", "getEntryNode", "(", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "AMDGPU", "AMDGPU", "\"<unknown>\"", "\"unsupported call to function \"", "0" ]

[]

[ "<s>", "SDValue", "TVMTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM doesn't support non-C calling conventions\"", ")", ";", "SDValue", "SetC0", "=", "RestoreC0", "(", "Chain", ",", "DL", ",", "DAG", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "SetC0", ")", ";", "RetOps", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "TVMISD", "::", "RETURN", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "for", "(", "const", "ISD", "::", "OutputArg", "&", "Out", ":", "Outs", ")", "{", "assert", "(", "!", "Out", ".", "Flags", ".", "isByVal", "(", ")", "&&", "\"byval is not valid for return values\"", ")", ";", "assert", "(", "!", "Out", ".", "Flags", ".", "isNest", "(", ")", "&&", "\"nest is not valid for return values\"", ")", ";", "assert", "(", "Out", ".", "IsFixed", "&&", "\"non-fixed return value is not valid\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM hasn't implemented inalloca results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM hasn't implemented cons regs results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM hasn't implemented cons regs last results\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "ISD::OutputArg", "\"TVM doesn't support non-C calling conventions\"", "4", "1", "TVMISD::RETURN", "MVT::Other", "ISD::OutputArg", "\"byval is not valid for return values\"", "\"nest is not valid for return values\"", "\"non-fixed return value is not valid\"", "\"TVM hasn't implemented inalloca results\"", "\"TVM hasn't implemented cons regs results\"", "\"TVM hasn't implemented cons regs last results\"" ]

[]

[ "<s>", "static", "int", "ia64_reloc_rw_mask", "(", "void", ")", "{", "return", "flag_pic", "?", "3", ":", "2", ";", "}", "</s>" ]

[ "For", "others", ",", "relax", "this", "so", "that", "relocations", "to", "local", "data", "goes", "in", "read-only", "segments", ",", "but", "we", "still", "can", "not", "allow", "global", "relocations", "in", "read-only", "segments", "." ]

[ "ia64", "3", "2" ]

[]

[ "<s>", "static", "rtx", "rs6000_emit_vector_compare_inner", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "mask", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "switch", "(", "code", ")", "{", "default", ":", "break", ";", "case", "GE", ":", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "return", "NULL_RTX", ";", "case", "EQ", ":", "case", "GT", ":", "case", "GTU", ":", "case", "ORDERED", ":", "case", "UNORDERED", ":", "case", "UNEQ", ":", "case", "LTGT", ":", "mask", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mask", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "mask", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "insn", "for", "VSX", "or", "Altivec", "comparisons", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeKernargMemParameter", "(", "MachineInstr", "&", "MI", ",", "MachineIRBuilder", "&", "B", ",", "uint64_t", "Offset", ",", "Align", "Alignment", ")", "const", "{", "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "B", ".", "getMRI", "(", ")", "->", "getType", "(", "DstReg", ")", "==", "LLT", "::", "scalar", "(", "32", ")", "&&", "\"unexpected kernarg parameter type\"", ")", ";", "Register", "Ptr", "=", "getKernargParameterPtr", "(", "B", ",", "Offset", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", ";", "B", ".", "buildLoad", "(", "DstReg", ",", "Ptr", ",", "PtrInfo", ",", "Align", "(", "4", ")", ",", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Legalize", "a", "value", "that", "'s", "loaded", "from", "kernel", "arguments", "." ]

[ "AMDGPU", "AMDGPU", "0", "32", "\"unexpected kernarg parameter type\"", "AMDGPU", "4" ]

[]

[ "<s>", "static", "const", "char", "*", "expand_lib", "(", "char", "*", "name", ")", "{", "char", "*", "lib", ",", "*", "lib_path", ";", "if", "(", "strcmp", "(", "name", ",", "\"c\"", ")", "==", "0", ")", "return", "\"sys$library:vaxcrtltx.olb\"", ";", "else", "if", "(", "strcmp", "(", "name", ",", "\"m\"", ")", "==", "0", ")", "return", "\"\"", ";", "else", "{", "lib", "=", "xmalloc", "(", "strlen", "(", "name", ")", "+", "14", ")", ";", "strcpy", "(", "lib", ",", "\"lib\"", ")", ";", "strcat", "(", "lib", ",", "name", ")", ";", "lib_path", "=", "locate_lib", "(", "lib", ",", "search_dirs", ")", ";", "if", "(", "lib_path", ")", "return", "lib_path", ";", "}", "fprintf", "(", "stderr", ",", "\"Couldn't locate library: lib%s.exe, lib%s.a or lib%s.olb\\n\"", ",", "name", ",", "name", ",", "name", ")", ";", "exit", "(", "1", ")", ";", "}", "</s>" ]

[ "Given", "a", "library", "name", "NAME", ",", "i.e", ".", "foo", ",", "Look", "for", "libfoo.lib", "and", "then", "libfoo.a", "in", "the", "set", "of", "directories", "we", "are", "allowed", "to", "search", "in", ".", "May", "return", "NULL", "if", "the", "library", "can", "be", "discarded", "." ]

[ "alpha", "\"c\"", "0", "\"sys$library:vaxcrtltx.olb\"", "\"m\"", "0", "\"\"", "14", "\"lib\"", "\"Couldn't locate library: lib%s.exe, lib%s.a or lib%s.olb\\n\"", "1" ]

[]

[ "<s>", "const", "ARMSubtarget", "*", "ARMBaseTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "std", "::", "string", "Key", "=", "CPU", "+", "FS", ";", "if", "(", "F", ".", "hasMinSize", "(", ")", ")", "Key", "+=", "\"+minsize\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ",", "F", ".", "hasMinSize", "(", ")", ")", ";", "if", "(", "!", "I", "->", "isThumb", "(", ")", "&&", "!", "I", "->", "hasARMOps", "(", ")", ")", "F", ".", "getContext", "(", ")", ".", "emitError", "(", "\"Function '\"", "+", "F", ".", "getName", "(", ")", "+", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "\"+minsize\"", "ARM", "ARM", "\"Function '\"", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "AArch64AsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "TheTriple", ".", "isOSBinFormatELF", "(", ")", "&&", "Name", "==", "\"R_AARCH64_NONE\"", ")", "return", "FK_NONE", ";", "return", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ")", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "AArch64", "AArch64", "\"R_AARCH64_NONE\"" ]

[]

[ "<s>", "static", "bool", "sh_legitimize_address_displacement", "(", "rtx", "*", "offset1", ",", "rtx", "*", "offset2", ",", "poly_int64", "orig_offset", ",", "machine_mode", "mode", ")", "{", "if", "(", "(", "TARGET_FPU_DOUBLE", "&&", "mode", "==", "DFmode", ")", "||", "(", "TARGET_SH2E", "&&", "mode", "==", "SFmode", ")", ")", "return", "false", ";", "struct", "disp_adjust", "adj", "=", "sh_find_mov_disp_adjust", "(", "mode", ",", "orig_offset", ")", ";", "if", "(", "adj", ".", "offset_adjust", "!=", "NULL_RTX", "&&", "adj", ".", "mov_disp", "!=", "NULL_RTX", ")", "{", "*", "offset1", "=", "adj", ".", "offset_adjust", ";", "*", "offset2", "=", "adj", ".", "mov_disp", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "DISP", "can", "be", "legitimized", "." ]

[ "sh" ]

[]

[ "<s>", "int", "SparcRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "llvm_unreachable", "(", "\"What is the dwarf register number\"", ")", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

[ "Sparc", "Sparc", "\"What is the dwarf register number\"", "1" ]

[]

[ "<s>", "char", "*", "neon_output_logic_immediate", "(", "const", "char", "*", "mnem", ",", "rtx", "*", "op2", ",", "machine_mode", "mode", ",", "int", "inverse", ",", "int", "quad", ")", "{", "int", "width", ",", "is_valid", ";", "static", "char", "templ", "[", "40", "]", ";", "is_valid", "=", "neon_immediate_valid_for_logic", "(", "*", "op2", ",", "mode", ",", "inverse", ",", "op2", ",", "&", "width", ")", ";", "gcc_assert", "(", "is_valid", "!=", "0", ")", ";", "if", "(", "quad", ")", "sprintf", "(", "templ", ",", "\"%s.i%d\\t%%q0, %%2\"", ",", "mnem", ",", "width", ")", ";", "else", "sprintf", "(", "templ", ",", "\"%s.i%d\\t%%P0, %%2\"", ",", "mnem", ",", "width", ")", ";", "return", "templ", ";", "}", "</s>" ]

[ "Return", "a", "string", "suitable", "for", "output", "of", "Neon", "immediate", "logic", "operation", "MNEM", "." ]

[ "arm", "40", "0", "\"%s.i%d\\t%%q0, %%2\"", "\"%s.i%d\\t%%P0, %%2\"" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nRemoving branches out of \"", "<<", "printMBBReference", "(", "MBB", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "Count", ";", "if", "(", "Count", "&&", "(", "I", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jump", ")", ")", "llvm_unreachable", "(", "\"Malformed basic block: unconditional branch not last\"", ")", ";", "MBB", ".", "erase", "(", "&", "MBB", ".", "back", "(", ")", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"code size not handled\"", "\"\\nRemoving branches out of \"", "0", "Hexagon::J2_jump", "\"Malformed basic block: unconditional branch not last\"" ]

[]

[ "<s>", "Register", "getRegister", "(", ")", "const", "{", "assert", "(", "!", "IsStack", ")", ";", "return", "Reg", ";", "}", "</s>" ]

[ "Return", "the", "specified", "register", "in", "the", "class", "." ]

[ "AMDGPU" ]

[]