Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SI Fix SGPR copies\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Fix SGPR copies\"" ]

[]

[ "<s>", "static", "void", "block_move_call", "(", "rtx", "dest_reg", ",", "rtx", "src_reg", ",", "rtx", "bytes_rtx", ")", "{", "if", "(", "GET_MODE", "(", "bytes_rtx", ")", "!=", "VOIDmode", "&&", "GET_MODE", "(", "bytes_rtx", ")", "!=", "Pmode", ")", "bytes_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "bytes_rtx", ",", "1", ")", ";", "emit_library_call", "(", "m32r_function_symbol", "(", "\"memcpy\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "dest_reg", ",", "Pmode", ",", "src_reg", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "bytes_rtx", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "}", "</s>" ]

[ "Use", "a", "library", "function", "to", "move", "some", "bytes", "." ]

[ "m32r", "1", "\"memcpy\"", "3" ]

[]

[ "<s>", "static", "void", "arm_option_params_internal", "(", "void", ")", "{", "if", "(", "TARGET_THUMB1", ")", "{", "targetm", ".", "min_anchor_offset", "=", "0", ";", "targetm", ".", "max_anchor_offset", "=", "127", ";", "}", "else", "if", "(", "TARGET_THUMB2", ")", "{", "targetm", ".", "min_anchor_offset", "=", "-", "248", ";", "targetm", ".", "max_anchor_offset", "=", "4095", ";", "}", "else", "{", "targetm", ".", "min_anchor_offset", "=", "TARGET_MIN_ANCHOR_OFFSET", ";", "targetm", ".", "max_anchor_offset", "=", "TARGET_MAX_ANCHOR_OFFSET", ";", "}", "max_insns_skipped", "=", "optimize_size", "?", "4", ":", "current_tune", "->", "max_insns_skipped", ";", "if", "(", "TARGET_THUMB2", ")", "max_insns_skipped", "=", "MIN", "(", "max_insns_skipped", ",", "MAX_INSN_PER_IT_BLOCK", ")", ";", "if", "(", "TARGET_THUMB1", ")", "targetm", ".", "md_asm_adjust", "=", "thumb1_md_asm_adjust", ";", "else", "targetm", ".", "md_asm_adjust", "=", "arm_md_asm_adjust", ";", "}", "</s>" ]

[ "Recompute", "the", "global", "settings", "depending", "on", "target", "attribute", "options", "." ]

[ "arm", "0", "127", "248", "4095", "4" ]

[]

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

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

[ "MBlaze" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Assembly Printer\"" ]

[]

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

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

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

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "ARMBaseInstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVD", "&&", "!", "isPredicated", "(", "MI", ")", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "(", "1", "<<", "ExeVFP", ")", "|", "(", "1", "<<", "ExeNEON", ")", ")", ";", "if", "(", "Subtarget", ".", "isCortexA9", "(", ")", "&&", "!", "isPredicated", "(", "MI", ")", "&&", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVRS", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVSR", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVS", ")", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "(", "1", "<<", "ExeVFP", ")", "|", "(", "1", "<<", "ExeNEON", ")", ")", ";", "unsigned", "Domain", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "if", "(", "Domain", "&", "ARMII", "::", "DomainNEON", ")", "return", "std", "::", "make_pair", "(", "ExeNEON", ",", "0", ")", ";", "if", "(", "(", "Domain", "&", "ARMII", "::", "DomainNEONA8", ")", "&&", "Subtarget", ".", "isCortexA8", "(", ")", ")", "return", "std", "::", "make_pair", "(", "ExeNEON", ",", "0", ")", ";", "if", "(", "Domain", "&", "ARMII", "::", "DomainVFP", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "0", ")", ";", "return", "std", "::", "make_pair", "(", "ExeGeneric", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "execution", "domain", "and", "bit", "mask", "of", "possible", "domains", "for", "instruction", "." ]

[ "ARM", "ARM", "ARM::VMOVD", "1", "1", "ARM::VMOVRS", "ARM::VMOVSR", "ARM::VMOVS", "1", "1", "ARMII::DomainMask", "ARMII::DomainNEON", "0", "ARMII::DomainNEONA8", "0", "ARMII::DomainVFP", "0", "0" ]

[]

[ "<s>", "static", "X86Operand", "*", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "bool", "AddressOf", "=", "false", ",", "SMLoc", "OffsetOfLoc", "=", "SMLoc", "(", ")", ",", "StringRef", "SymName", "=", "StringRef", "(", ")", ",", "void", "*", "OpDecl", "=", "0", ")", "{", "X86Operand", "*", "Res", "=", "new", "X86Operand", "(", "Register", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Res", "->", "AddressOf", "=", "AddressOf", ";", "Res", "->", "OffsetOfLoc", "=", "OffsetOfLoc", ";", "Res", "->", "SymName", "=", "SymName", ";", "Res", "->", "OpDecl", "=", "OpDecl", ";", "return", "Res", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "false", ";", "return", "Subtarget", ".", "enableUnalignedScalarMem", "(", ")", ";", "}", "EVT", "ElemVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "Alignment", ">=", "ElemVT", ".", "getStoreSize", "(", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "SSACCmpConv", "::", "isDeadDef", "(", "unsigned", "DstReg", ")", "{", "if", "(", "DstReg", "==", "AArch64", "::", "WZR", "||", "DstReg", "==", "AArch64", "::", "XZR", ")", "return", "true", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DstReg", ")", ")", "return", "false", ";", "return", "MRI", "->", "use_nodbg_empty", "(", "DstReg", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "has", "a", "dead", "def", "." ]

[ "AArch64", "AArch64::WZR", "AArch64::XZR" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isExtractSubvectorCheap", "(", "EVT", "ResVT", ",", "EVT", "SrcVT", ",", "unsigned", "Index", ")", "const", "{", "if", "(", "!", "isOperationLegalOrCustom", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "ResVT", ")", ")", "return", "false", ";", "return", "(", "Index", "==", "0", "||", "Index", "==", "ResVT", ".", "getVectorNumElements", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "EXTRACT_SUBVECTOR", "is", "cheap", "for", "this", "result", "type", "with", "this", "index", "." ]

[ "ARM", "ARM", "ISD::EXTRACT_SUBVECTOR", "0" ]

[]

[ "<s>", "int", "M68kFrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "MergeWithPrevious", ")", "const", "{", "if", "(", "(", "MergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "MergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "MergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "MachineBasicBlock", "::", "iterator", "NI", "=", "MergeWithPrevious", "?", "nullptr", ":", "std", "::", "next", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "!", "MergeWithPrevious", "&&", "NI", "!=", "MBB", ".", "end", "(", ")", "&&", "NI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", "{", "return", "Offset", ";", "}", "if", "(", "Opc", "==", "M68k", "::", "ADD32ri", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "+=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "MergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "Opc", "==", "M68k", "::", "SUB32ri", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "-=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "MergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "Check", "the", "instruction", "before/after", "the", "passed", "instruction", "." ]

[ "M68k", "M68k", "0", "0", "M68k::ADD32ri", "0", "1", "2", "M68k::SUB32ri", "0", "1", "2" ]

[]

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

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

[ "X86", "\"X86 LEA Optimize\"" ]

[]

[ "<s>", "static", "tree", "fold_build_vec_cmp", "(", "tree_code", "code", ",", "tree", "type", ",", "tree", "arg0", ",", "tree", "arg1", ")", "{", "tree", "cmp_type", "=", "build_same_sized_truth_vector_type", "(", "type", ")", ";", "tree", "zero_vec", "=", "build_zero_cst", "(", "type", ")", ";", "tree", "minus_one_vec", "=", "build_minus_one_cst", "(", "type", ")", ";", "tree", "cmp", "=", "fold_build2", "(", "code", ",", "cmp_type", ",", "arg0", ",", "arg1", ")", ";", "return", "fold_build3", "(", "VEC_COND_EXPR", ",", "type", ",", "cmp", ",", "minus_one_vec", ",", "zero_vec", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "handle", "the", "gimple", "folding", "of", "a", "vector", "compare", "operation", ".", "This", "sets", "up", "true/false", "vectors", ",", "and", "uses", "the", "VEC_COND_EXPR", "operation", ".", "CODE", "indicates", "which", "comparison", "is", "to", "be", "made", ".", "(", "EQ", ",", "GT", ",", "...", ")", ".", "TYPE", "indicates", "the", "type", "of", "the", "result", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "assert", "(", "!", "\"Not implemented\"", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "AMDGPU", "\"Not implemented\"" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "unsigned", "StackAlignOverride", ",", "bool", "is64Bit", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasCMov", "(", "false", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasPOPCNT", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAES", "(", "false", ")", ",", "HasCLMUL", "(", "false", ")", ",", "HasFMA3", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "HasXOP", "(", "false", ")", ",", "HasMOVBE", "(", "false", ")", ",", "HasRDRAND", "(", "false", ")", ",", "HasF16C", "(", "false", ")", ",", "HasFSGSBase", "(", "false", ")", ",", "HasLZCNT", "(", "false", ")", ",", "HasBMI", "(", "false", ")", ",", "HasBMI2", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "IsUAMemFast", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "HasCmpxchg16b", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "TargetTriple", "(", "TT", ")", ",", "In64BitMode", "(", "is64Bit", ")", "{", "if", "(", "!", "FS", ".", "empty", "(", ")", "||", "!", "CPU", ".", "empty", "(", ")", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "{", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "CPUName", "=", "\"generic\"", ";", "}", "std", "::", "string", "FullFS", "=", "FS", ";", "if", "(", "In64BitMode", ")", "{", "if", "(", "!", "FullFS", ".", "empty", "(", ")", ")", "FullFS", "=", "\"+64bit,+sse2,\"", "+", "FullFS", ";", "else", "FullFS", "=", "\"+64bit,+sse2\"", ";", "}", "ParseSubtargetFeatures", "(", "CPUName", ",", "FullFS", ")", ";", "}", "else", "{", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "In64BitMode", ")", "{", "HasX86_64", "=", "true", ";", "ToggleFeature", "(", "X86", "::", "Feature64Bit", ")", ";", "HasCMov", "=", "true", ";", "ToggleFeature", "(", "X86", "::", "FeatureCMOV", ")", ";", "if", "(", "X86SSELevel", "<", "SSE2", ")", "{", "X86SSELevel", "=", "SSE2", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE1", ")", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE2", ")", ";", "}", "}", "}", "if", "(", "In64BitMode", ")", "ToggleFeature", "(", "X86", "::", "Mode64Bit", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "In64BitMode", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "StackAlignOverride", ")", "stackAlignment", "=", "StackAlignOverride", ";", "else", "if", "(", "isTargetDarwin", "(", ")", "||", "isTargetFreeBSD", "(", ")", "||", "isTargetLinux", "(", ")", "||", "isTargetSolaris", "(", ")", "||", "In64BitMode", ")", "stackAlignment", "=", "16", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "4", "128", "\"generic\"", "\"+64bit,+sse2,\"", "\"+64bit,+sse2\"", "X86", "X86::Feature64Bit", "X86::FeatureCMOV", "X86", "X86", "X86::FeatureSSE1", "X86::FeatureSSE2", "X86::Mode64Bit", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "16" ]

[]

[ "<s>", "static", "void", "m32r_output_function_prologue", "(", "FILE", "*", "file", ")", "{", "enum", "m32r_function_type", "fn_type", "=", "m32r_compute_function_type", "(", "current_function_decl", ")", ";", "if", "(", "M32R_INTERRUPT_P", "(", "fn_type", ")", ")", "fprintf", "(", "file", ",", "\"\\t%s interrupt handler\\n\"", ",", "ASM_COMMENT_START", ")", ";", "if", "(", "!", "current_frame_info", ".", "initialized", ")", "m32r_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s PROLOGUE, vars= %d, regs= %d, args= %d, extra= %d\\n\"", ",", "ASM_COMMENT_START", ",", "current_frame_info", ".", "var_size", ",", "current_frame_info", ".", "reg_size", "/", "4", ",", "current_frame_info", ".", "args_size", ",", "current_frame_info", ".", "extra_size", ")", ";", "}", "</s>" ]

[ "Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", ".", "Note", ",", "if", "this", "is", "changed", ",", "you", "need", "to", "mirror", "the", "changes", "in", "m32r_compute_frame_size", "which", "calculates", "the", "prolog", "size", "." ]

[ "m32r", "\"\\t%s interrupt handler\\n\"", "\"\\t%s PROLOGUE, vars= %d, regs= %d, args= %d, extra= %d\\n\"", "4" ]

[]

[ "<s>", "void", "BPFAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "if", "(", "!", "BTF", "||", "!", "BTF", "->", "InstLower", "(", "MI", ",", "TmpInst", ")", ")", "{", "BPFMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "}", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "mips_symbolic_constant_p", "(", "rtx", "x", ",", "enum", "mips_symbol_context", "context", ",", "enum", "mips_symbol_type", "*", "symbol_type", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "UNSPEC_ADDRESS_P", "(", "x", ")", ")", "{", "*", "symbol_type", "=", "UNSPEC_ADDRESS_TYPE", "(", "x", ")", ";", "x", "=", "UNSPEC_ADDRESS", "(", "x", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "*", "symbol_type", "=", "mips_classify_symbol", "(", "x", ",", "context", ")", ";", "if", "(", "*", "symbol_type", "==", "SYMBOL_TLS", ")", "return", "false", ";", "}", "else", "return", "false", ";", "if", "(", "offset", "==", "const0_rtx", ")", "return", "true", ";", "switch", "(", "*", "symbol_type", ")", "{", "case", "SYMBOL_ABSOLUTE", ":", "case", "SYMBOL_64_HIGH", ":", "case", "SYMBOL_64_MID", ":", "case", "SYMBOL_64_LOW", ":", "if", "(", "Pmode", "==", "DImode", "&&", "!", "ABI_HAS_64BIT_SYMBOLS", ")", "return", "offset_within_block_p", "(", "x", ",", "INTVAL", "(", "offset", ")", ")", ";", "return", "true", ";", "case", "SYMBOL_PC_RELATIVE", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "case", "SYMBOL_GP_RELATIVE", ":", "return", "offset_within_block_p", "(", "x", ",", "INTVAL", "(", "offset", ")", ")", ";", "case", "SYMBOL_GOT_PAGE_OFST", ":", "case", "SYMBOL_GOTOFF_PAGE", ":", "return", "SMALL_INT", "(", "offset", ")", ";", "case", "SYMBOL_TPREL", ":", "case", "SYMBOL_DTPREL", ":", "return", "mips_offset_within_alignment_p", "(", "x", ",", "INTVAL", "(", "offset", ")", ")", ";", "case", "SYMBOL_GOT_DISP", ":", "case", "SYMBOL_GOTOFF_DISP", ":", "case", "SYMBOL_GOTOFF_CALL", ":", "case", "SYMBOL_GOTOFF_LOADGP", ":", "case", "SYMBOL_TLSGD", ":", "case", "SYMBOL_TLSLDM", ":", "case", "SYMBOL_GOTTPREL", ":", "case", "SYMBOL_TLS", ":", "case", "SYMBOL_HALF", ":", "return", "false", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "symbolic", "constant", "that", "can", "be", "calculated", "in", "the", "same", "way", "as", "a", "bare", "symbol", ".", "If", "it", "is", ",", "store", "the", "type", "of", "the", "symbol", "in", "*", "SYMBOL_TYPE", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AAResults", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "V_MOV_B32_e32", ":", "case", "AMDGPU", "::", "V_MOV_B32_e64", ":", "case", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "case", "AMDGPU", "::", "V_ACCVGPR_READ_B32", ":", "case", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32", ":", "return", "MI", ".", "getNumOperands", "(", ")", "==", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MOV_B32_e32", "AMDGPU::V_MOV_B32_e64", "AMDGPU::V_MOV_B64_PSEUDO", "AMDGPU::V_ACCVGPR_READ_B32", "AMDGPU::V_ACCVGPR_WRITE_B32" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "SystemZFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "TRI", ")", ";", "}", "SystemZ", "::", "GPRRegs", "RestoreGPRs", "=", "ZFI", "->", "getRestoreGPRRegs", "(", ")", ";", "if", "(", "RestoreGPRs", ".", "LowGPR", ")", "{", "assert", "(", "RestoreGPRs", ".", "LowGPR", "!=", "RestoreGPRs", ".", "HighGPR", "&&", "\"Should be loading %r15 and something else\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LMG", ")", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "LowGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "HighGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "HasFP", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ";", "MIB", ".", "addImm", "(", "RestoreGPRs", ".", "GPROffset", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "RestoreGPRs", ".", "LowGPR", "&&", "Reg", "!=", "RestoreGPRs", ".", "HighGPR", "&&", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::GPRRegs", "\"Should be loading %r15 and something else\"", "SystemZ::LMG", "SystemZ::R11D", "SystemZ::R15D", "0", "SystemZ::GR64BitRegClass" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SITargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", "==", "\"r\"", ")", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled type for 'r' inline asm constraint\"", ")", ";", "case", "MVT", "::", "i64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "case", "MVT", "::", "i32", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", ";", "}", "}", "if", "(", "Constraint", ".", "size", "(", ")", ">", "1", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "Constraint", "[", "1", "]", "==", "'v'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "}", "else", "if", "(", "Constraint", "[", "1", "]", "==", "'s'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "}", "if", "(", "RC", ")", "{", "unsigned", "Idx", "=", "std", "::", "atoi", "(", "Constraint", ".", "substr", "(", "2", ")", ".", "c_str", "(", ")", ")", ";", "if", "(", "Idx", "<", "RC", "->", "getNumRegs", "(", ")", ")", "return", "std", "::", "make_pair", "(", "RC", "->", "getRegister", "(", "Idx", ")", ",", "RC", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "R600", "SI", "\"r\"", "\"Unhandled type for 'r' inline asm constraint\"", "MVT::i64", "0U", "MVT::i32", "0U", "1", "1", "1", "2" ]

[]

[ "<s>", "static", "void", "ia64_init_sched_context", "(", "void", "*", "_sc", ",", "bool", "clean_p", ")", "{", "ia64_sched_context_t", "sc", "=", "(", "ia64_sched_context_t", ")", "_sc", ";", "sc", "->", "prev_cycle_state", "=", "xmalloc", "(", "dfa_state_size", ")", ";", "if", "(", "clean_p", ")", "{", "state_reset", "(", "sc", "->", "prev_cycle_state", ")", ";", "sc", "->", "last_scheduled_insn", "=", "NULL", ";", "memset", "(", "sc", "->", "rws_sum", ",", "0", ",", "sizeof", "(", "rws_sum", ")", ")", ";", "memset", "(", "sc", "->", "rws_insn", ",", "0", ",", "sizeof", "(", "rws_insn", ")", ")", ";", "sc", "->", "first_instruction", "=", "1", ";", "sc", "->", "pending_data_specs", "=", "0", ";", "sc", "->", "current_cycle", "=", "0", ";", "memset", "(", "sc", "->", "mem_ops_in_group", ",", "0", ",", "sizeof", "(", "mem_ops_in_group", ")", ")", ";", "}", "else", "{", "memcpy", "(", "sc", "->", "prev_cycle_state", ",", "prev_cycle_state", ",", "dfa_state_size", ")", ";", "sc", "->", "last_scheduled_insn", "=", "last_scheduled_insn", ";", "memcpy", "(", "sc", "->", "rws_sum", ",", "rws_sum", ",", "sizeof", "(", "rws_sum", ")", ")", ";", "memcpy", "(", "sc", "->", "rws_insn", ",", "rws_insn", ",", "sizeof", "(", "rws_insn", ")", ")", ";", "sc", "->", "first_instruction", "=", "first_instruction", ";", "sc", "->", "pending_data_specs", "=", "pending_data_specs", ";", "sc", "->", "current_cycle", "=", "current_cycle", ";", "memcpy", "(", "sc", "->", "mem_ops_in_group", ",", "mem_ops_in_group", ",", "sizeof", "(", "mem_ops_in_group", ")", ")", ";", "}", "}", "</s>" ]

[ "Initializes", "the", "_SC", "context", "with", "clean", "data", ",", "if", "CLEAN_P", ",", "and", "from", "the", "global", "context", "otherwise", "." ]

[ "ia64", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "comparison_string", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ")", "{", "bool", "is_nz_p", "=", "GET_MODE", "(", "op0", ")", "==", "CC_NZmode", ";", "switch", "(", "code", ")", "{", "default", ":", "output_operand_lossage", "(", "\"bad condition code\"", ")", ";", "case", "EQ", ":", "return", "\"eq\"", ";", "case", "NE", ":", "return", "\"ne\"", ";", "case", "LT", ":", "return", "is_nz_p", "?", "\"n\"", ":", "\"lt\"", ";", "case", "LE", ":", "return", "\"le\"", ";", "case", "GT", ":", "return", "\"gt\"", ";", "case", "GE", ":", "return", "is_nz_p", "?", "\"p\"", ":", "\"ge\"", ";", "case", "LTU", ":", "return", "is_nz_p", "?", "\"no\"", ":", "\"c\"", ";", "case", "LEU", ":", "return", "is_nz_p", "?", "\"eq\"", ":", "\"ls\"", ";", "case", "GTU", ":", "return", "is_nz_p", "?", "\"ne\"", ":", "\"hi\"", ";", "case", "GEU", ":", "return", "is_nz_p", "?", "\"ra\"", ":", "\"nc\"", ";", "}", "}", "</s>" ]

[ "Return", "the", "comparison", "operator", "to", "use", "for", "CODE", "given", "that", "the", "ICC", "register", "is", "OP0", "." ]

[ "frv", "\"bad condition code\"", "\"eq\"", "\"ne\"", "\"n\"", "\"lt\"", "\"le\"", "\"gt\"", "\"p\"", "\"ge\"", "\"no\"", "\"c\"", "\"eq\"", "\"ls\"", "\"ne\"", "\"hi\"", "\"ra\"", "\"nc\"" ]

[]

[ "<s>", "static", "void", "init_float128_ibm", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_XL_COMPAT", ")", "{", "set_optab_libfunc", "(", "add_optab", ",", "mode", ",", "\"__gcc_qadd\"", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "mode", ",", "\"__gcc_qsub\"", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "mode", ",", "\"__gcc_qmul\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "mode", ",", "\"__gcc_qdiv\"", ")", ";", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "&&", "(", "TARGET_FPRS", "||", "TARGET_E500_DOUBLE", ")", ")", ")", "{", "set_optab_libfunc", "(", "neg_optab", ",", "mode", ",", "\"__gcc_qneg\"", ")", ";", "set_optab_libfunc", "(", "eq_optab", ",", "mode", ",", "\"__gcc_qeq\"", ")", ";", "set_optab_libfunc", "(", "ne_optab", ",", "mode", ",", "\"__gcc_qne\"", ")", ";", "set_optab_libfunc", "(", "gt_optab", ",", "mode", ",", "\"__gcc_qgt\"", ")", ";", "set_optab_libfunc", "(", "ge_optab", ",", "mode", ",", "\"__gcc_qge\"", ")", ";", "set_optab_libfunc", "(", "lt_optab", ",", "mode", ",", "\"__gcc_qlt\"", ")", ";", "set_optab_libfunc", "(", "le_optab", ",", "mode", ",", "\"__gcc_qle\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "SFmode", ",", "\"__gcc_stoq\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "DFmode", ",", "\"__gcc_dtoq\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SFmode", ",", "mode", ",", "\"__gcc_qtos\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DFmode", ",", "mode", ",", "\"__gcc_qtod\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "SImode", ",", "mode", ",", "\"__gcc_qtoi\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "SImode", ",", "mode", ",", "\"__gcc_qtou\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "mode", ",", "SImode", ",", "\"__gcc_itoq\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "mode", ",", "SImode", ",", "\"__gcc_utoq\"", ")", ";", "}", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", ")", "set_optab_libfunc", "(", "unord_optab", ",", "mode", ",", "\"__gcc_qunord\"", ")", ";", "}", "else", "{", "set_optab_libfunc", "(", "add_optab", ",", "mode", ",", "\"_xlqadd\"", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "mode", ",", "\"_xlqsub\"", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "mode", ",", "\"_xlqmul\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "mode", ",", "\"_xlqdiv\"", ")", ";", "}", "if", "(", "mode", "==", "IFmode", ")", "{", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "SDmode", ",", "\"__dpd_extendsdtf2\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "DDmode", ",", "\"__dpd_extendddtf2\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "mode", ",", "TDmode", ",", "\"__dpd_trunctftd2\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SDmode", ",", "mode", ",", "\"__dpd_trunctfsd2\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DDmode", ",", "mode", ",", "\"__dpd_trunctfdd2\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TDmode", ",", "mode", ",", "\"__dpd_extendtdtf2\"", ")", ";", "if", "(", "TARGET_POWERPC64", ")", "{", "set_conv_libfunc", "(", "sfix_optab", ",", "TImode", ",", "mode", ",", "\"__fixtfti\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "TImode", ",", "mode", ",", "\"__fixunstfti\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "mode", ",", "TImode", ",", "\"__floattitf\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "mode", ",", "TImode", ",", "\"__floatuntitf\"", ")", ";", "}", "}", "}", "</s>" ]

[ "Set", "up", "AIX/Darwin/64-bit", "Linux", "quad", "floating", "point", "routines", "." ]

[ "rs6000", "\"__gcc_qadd\"", "\"__gcc_qsub\"", "\"__gcc_qmul\"", "\"__gcc_qdiv\"", "\"__gcc_qneg\"", "\"__gcc_qeq\"", "\"__gcc_qne\"", "\"__gcc_qgt\"", "\"__gcc_qge\"", "\"__gcc_qlt\"", "\"__gcc_qle\"", "\"__gcc_stoq\"", "\"__gcc_dtoq\"", "\"__gcc_qtos\"", "\"__gcc_qtod\"", "\"__gcc_qtoi\"", "\"__gcc_qtou\"", "\"__gcc_itoq\"", "\"__gcc_utoq\"", "\"__gcc_qunord\"", "\"_xlqadd\"", "\"_xlqsub\"", "\"_xlqmul\"", "\"_xlqdiv\"", "\"__dpd_extendsdtf2\"", "\"__dpd_extendddtf2\"", "\"__dpd_trunctftd2\"", "\"__dpd_trunctfsd2\"", "\"__dpd_trunctfdd2\"", "\"__dpd_extendtdtf2\"", "\"__fixtfti\"", "\"__fixunstfti\"", "\"__floattitf\"", "\"__floatuntitf\"" ]

[]

[ "<s>", "static", "int", "pa_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "src", ",", "dest", ";", "if", "(", "set", ")", "{", "src", "=", "SET_SRC", "(", "set", ")", ";", "dest", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "LO_SUM", "&&", "symbolic_operand", "(", "XEXP", "(", "src", ",", "1", ")", ",", "VOIDmode", ")", "&&", "!", "read_only_operand", "(", "XEXP", "(", "src", ",", "1", ")", ",", "VOIDmode", ")", ")", "priority", ">>=", "3", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "LO_SUM", "&&", "symbolic_operand", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", ",", "VOIDmode", ")", "&&", "!", "read_only_operand", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", ",", "VOIDmode", ")", ")", "priority", ">>=", "1", ";", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "LO_SUM", "&&", "symbolic_operand", "(", "XEXP", "(", "XEXP", "(", "dest", ",", "0", ")", ",", "1", ")", ",", "VOIDmode", ")", "&&", "!", "read_only_operand", "(", "XEXP", "(", "XEXP", "(", "dest", ",", "0", ")", ",", "1", ")", ",", "VOIDmode", ")", ")", "priority", ">>=", "3", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "Adjust", "scheduling", "priorities", ".", "We", "use", "this", "to", "try", "and", "keep", "addil", "and", "the", "next", "use", "of", "%", "r1", "close", "together", "." ]

[ "pa", "1", "1", "3", "0", "0", "1", "0", "1", "1", "0", "0", "1", "0", "1", "3" ]

[]

[ "<s>", "static", "addr_space_t", "avr_nonconst_pointer_addrspace", "(", "tree", "typ", ")", "{", "while", "(", "ARRAY_TYPE", "==", "TREE_CODE", "(", "typ", ")", ")", "typ", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "typ", ")", ")", "{", "addr_space_t", "as", ";", "tree", "target", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "FUNCTION_TYPE", "==", "TREE_CODE", "(", "target", ")", ")", "return", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "target", ")", ")", ";", "while", "(", "TREE_CODE", "(", "target", ")", "==", "ARRAY_TYPE", ")", "target", "=", "TREE_TYPE", "(", "target", ")", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "target", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", "&&", "!", "TYPE_READONLY", "(", "target", ")", "&&", "avr_addr_space_supported_p", "(", "as", ")", ")", "{", "return", "as", ";", "}", "return", "avr_nonconst_pointer_addrspace", "(", "target", ")", ";", "}", "return", "ADDR_SPACE_GENERIC", ";", "}", "</s>" ]

[ "Scan", "type", "TYP", "for", "pointer", "references", "to", "address", "space", "ASn", ".", "Return", "ADDR_SPACE_GENERIC", "(", "i.e", ".", "0", ")", "if", "all", "pointers", "targeting", "the", "AS", "are", "also", "declared", "to", "be", "CONST", ".", "Otherwise", ",", "return", "the", "respective", "address", "space", ",", "i.e", ".", "a", "value", "!", "=", "0", "." ]

[ "avr" ]

[]

[ "<s>", "void", "clear", "(", ")", "{", "BBInfo", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "ARM" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", ":", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "TT", ".", "isOSBinFormatELF", "(", ")", "?", "static_cast", "<", "TargetLoweringObjectFile", "*", ">", "(", "new", "WebAssemblyTargetObjectFileELF", "(", ")", ")", ":", "static_cast", "<", "TargetLoweringObjectFile", "*", ">", "(", "new", "WebAssemblyTargetObjectFile", "(", ")", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "if", "(", "!", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "{", "this", "->", "Options", ".", "FunctionSections", "=", "true", ";", "this", "->", "Options", ".", "DataSections", "=", "true", ";", "this", "->", "Options", ".", "UniqueSectionNames", "=", "true", ";", "}", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "void", "cr16_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "l", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "BITS_PER_WORD", ";", "if", "(", "!", "cum", "->", "last_parm_in_reg", ")", "return", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", "||", "(", "cum", "->", "ints", "<", "0", ")", ")", "return", ";", "if", "(", "(", "mode", "==", "SImode", ")", "||", "(", "mode", "==", "HImode", ")", "||", "(", "mode", "==", "QImode", ")", "||", "(", "mode", "==", "DImode", ")", ")", "{", "if", "(", "l", "<=", "1", ")", "cum", "->", "ints", "+=", "1", ";", "else", "cum", "->", "ints", "+=", "l", ";", "}", "else", "if", "(", "(", "mode", "==", "SFmode", ")", "||", "(", "mode", "==", "DFmode", ")", ")", "cum", "->", "ints", "+=", "l", ";", "else", "if", "(", "(", "mode", ")", "==", "BLKmode", ")", "{", "if", "(", "(", "l", "=", "enough_regs_for_param", "(", "cum", ",", "type", ",", "mode", ")", ")", "!=", "0", ")", "cum", "->", "ints", "+=", "l", ";", "}", "return", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "FUNCTION_ARG_ADVANCE", "defined", "in", "cr16.h", "." ]

[ "cr16", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "nios2_set_return_address", "(", "rtx", "address", ",", "rtx", "scratch", ")", "{", "nios2_compute_frame_layout", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "save_mask", "&", "(", "1", "<<", "RA_REGNO", ")", ")", "{", "unsigned", "offset", "=", "cfun", "->", "machine", "->", "save_reg_size", "-", "4", ";", "rtx", "base", ";", "if", "(", "frame_pointer_needed", ")", "base", "=", "hard_frame_pointer_rtx", ";", "else", "{", "base", "=", "stack_pointer_rtx", ";", "offset", "+=", "cfun", "->", "machine", "->", "save_regs_offset", ";", "if", "(", "!", "SMALL_INT", "(", "offset", ")", ")", "{", "emit_move_insn", "(", "scratch", ",", "gen_int_mode", "(", "offset", ",", "Pmode", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "scratch", ",", "base", ")", ")", ";", "base", "=", "scratch", ";", "offset", "=", "0", ";", "}", "}", "if", "(", "offset", ")", "base", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "Pmode", ",", "base", ")", ",", "address", ")", ";", "}", "else", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "RA_REGNO", ")", ",", "address", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "change", "the", "current", "function", "'s", "return", "address", "to", "ADDRESS", ".", "SCRATCH", "is", "available", "as", "a", "scratch", "register", ",", "if", "needed", ".", "ADDRESS", "and", "SCRATCH", "are", "both", "word-mode", "GPRs", "." ]

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

[]

[ "<s>", "void", "tilepro_expand_smulsi3_highpart", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "tilepro_expand_high_multiply", "(", "op0", ",", "op1", ",", "op2", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "smulsi3_highpart", "." ]

[ "tilepro" ]

[]

[ "<s>", "bool", "X86DAGToDAGISel", "::", "IsProfitableToFold", "(", "SDValue", "N", ",", "SDNode", "*", "U", ",", "SDNode", "*", "Root", ")", "const", "{", "if", "(", "OptLevel", "==", "CodeGenOpt", "::", "None", ")", "return", "false", ";", "if", "(", "!", "N", ".", "hasOneUse", "(", ")", ")", "return", "false", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "true", ";", "if", "(", "U", "==", "Root", ")", "{", "switch", "(", "U", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86ISD", "::", "ADD", ":", "case", "X86ISD", "::", "SUB", ":", "case", "X86ISD", "::", "AND", ":", "case", "X86ISD", "::", "XOR", ":", "case", "X86ISD", "::", "OR", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "ADDC", ":", "case", "ISD", "::", "ADDE", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "{", "SDValue", "Op1", "=", "U", "->", "getOperand", "(", "1", ")", ";", "if", "(", "ConstantSDNode", "*", "Imm", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op1", ")", ")", "if", "(", "Imm", "->", "getAPIntValue", "(", ")", ".", "isSignedIntN", "(", "8", ")", ")", "return", "false", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "X86ISD", "::", "Wrapper", ")", "{", "SDValue", "Val", "=", "Op1", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Val", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetGlobalTLSAddress", ")", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "IsProfitableToFold", "-", "Returns", "true", "if", "it", "'s", "profitable", "to", "fold", "the", "specific", "operand", "node", "N", "of", "U", "during", "instruction", "selection", "that", "starts", "at", "Root", "." ]

[ "X86", "X86", "ISD::LOAD", "X86ISD::ADD", "X86ISD::SUB", "X86ISD::AND", "X86ISD::XOR", "X86ISD::OR", "ISD::ADD", "ISD::ADDC", "ISD::ADDE", "ISD::AND", "ISD::OR", "ISD::XOR", "1", "8", "X86ISD::Wrapper", "0", "ISD::TargetGlobalTLSAddress" ]

[]

[ "<s>", "Register", "AMDGPULegalizerInfo", "::", "handleD16VData", "(", "MachineIRBuilder", "&", "B", ",", "MachineRegisterInfo", "&", "MRI", ",", "Register", "Reg", ")", "const", "{", "if", "(", "!", "ST", ".", "hasUnpackedD16VMem", "(", ")", ")", "return", "Reg", ";", "const", "LLT", "S16", "=", "LLT", "::", "scalar", "(", "16", ")", ";", "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "LLT", "StoreVT", "=", "MRI", ".", "getType", "(", "Reg", ")", ";", "assert", "(", "StoreVT", ".", "isVector", "(", ")", "&&", "StoreVT", ".", "getElementType", "(", ")", "==", "S16", ")", ";", "auto", "Unmerge", "=", "B", ".", "buildUnmerge", "(", "S16", ",", "Reg", ")", ";", "SmallVector", "<", "Register", ",", "4", ">", "WideRegs", ";", "for", "(", "int", "I", "=", "0", ",", "E", "=", "Unmerge", "->", "getNumOperands", "(", ")", "-", "1", ";", "I", "!=", "E", ";", "++", "I", ")", "WideRegs", ".", "push_back", "(", "B", ".", "buildAnyExt", "(", "S32", ",", "Unmerge", ".", "getReg", "(", "I", ")", ")", ".", "getReg", "(", "0", ")", ")", ";", "int", "NumElts", "=", "StoreVT", ".", "getNumElements", "(", ")", ";", "return", "B", ".", "buildBuildVector", "(", "LLT", "::", "vector", "(", "NumElts", ",", "S32", ")", ",", "WideRegs", ")", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Handle", "register", "layout", "difference", "for", "f16", "images", "for", "some", "subtargets", "." ]

[ "AMDGPU", "AMDGPU", "16", "32", "4", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isAssociativeAndCommutative", "(", "const", "MachineInstr", "&", "Inst", ")", "const", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "AND8rr", ":", "case", "X86", "::", "AND16rr", ":", "case", "X86", "::", "AND32rr", ":", "case", "X86", "::", "AND64rr", ":", "case", "X86", "::", "OR8rr", ":", "case", "X86", "::", "OR16rr", ":", "case", "X86", "::", "OR32rr", ":", "case", "X86", "::", "OR64rr", ":", "case", "X86", "::", "XOR8rr", ":", "case", "X86", "::", "XOR16rr", ":", "case", "X86", "::", "XOR32rr", ":", "case", "X86", "::", "XOR64rr", ":", "case", "X86", "::", "IMUL16rr", ":", "case", "X86", "::", "IMUL32rr", ":", "case", "X86", "::", "IMUL64rr", ":", "case", "X86", "::", "PANDrr", ":", "case", "X86", "::", "PORrr", ":", "case", "X86", "::", "PXORrr", ":", "case", "X86", "::", "VPANDrr", ":", "case", "X86", "::", "VPANDYrr", ":", "case", "X86", "::", "VPORrr", ":", "case", "X86", "::", "VPORYrr", ":", "case", "X86", "::", "VPXORrr", ":", "case", "X86", "::", "VPXORYrr", ":", "case", "X86", "::", "MAXCPDrr", ":", "case", "X86", "::", "MAXCPSrr", ":", "case", "X86", "::", "MAXCSDrr", ":", "case", "X86", "::", "MAXCSSrr", ":", "case", "X86", "::", "MINCPDrr", ":", "case", "X86", "::", "MINCPSrr", ":", "case", "X86", "::", "MINCSDrr", ":", "case", "X86", "::", "MINCSSrr", ":", "case", "X86", "::", "VMAXCPDrr", ":", "case", "X86", "::", "VMAXCPSrr", ":", "case", "X86", "::", "VMAXCPDYrr", ":", "case", "X86", "::", "VMAXCPSYrr", ":", "case", "X86", "::", "VMAXCSDrr", ":", "case", "X86", "::", "VMAXCSSrr", ":", "case", "X86", "::", "VMINCPDrr", ":", "case", "X86", "::", "VMINCPSrr", ":", "case", "X86", "::", "VMINCPDYrr", ":", "case", "X86", "::", "VMINCPSYrr", ":", "case", "X86", "::", "VMINCSDrr", ":", "case", "X86", "::", "VMINCSSrr", ":", "return", "true", ";", "case", "X86", "::", "ADDPDrr", ":", "case", "X86", "::", "ADDPSrr", ":", "case", "X86", "::", "ADDSDrr", ":", "case", "X86", "::", "ADDSSrr", ":", "case", "X86", "::", "MULPDrr", ":", "case", "X86", "::", "MULPSrr", ":", "case", "X86", "::", "MULSDrr", ":", "case", "X86", "::", "MULSSrr", ":", "case", "X86", "::", "VADDPDrr", ":", "case", "X86", "::", "VADDPSrr", ":", "case", "X86", "::", "VADDPDYrr", ":", "case", "X86", "::", "VADDPSYrr", ":", "case", "X86", "::", "VADDSDrr", ":", "case", "X86", "::", "VADDSSrr", ":", "case", "X86", "::", "VMULPDrr", ":", "case", "X86", "::", "VMULPSrr", ":", "case", "X86", "::", "VMULPDYrr", ":", "case", "X86", "::", "VMULPSYrr", ":", "case", "X86", "::", "VMULSDrr", ":", "case", "X86", "::", "VMULSSrr", ":", "return", "Inst", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "when", "\\P", "Inst", "is", "both", "associative", "and", "commutative", "." ]

[ "X86", "X86", "X86::AND8rr", "X86::AND16rr", "X86::AND32rr", "X86::AND64rr", "X86::OR8rr", "X86::OR16rr", "X86::OR32rr", "X86::OR64rr", "X86::XOR8rr", "X86::XOR16rr", "X86::XOR32rr", "X86::XOR64rr", "X86::IMUL16rr", "X86::IMUL32rr", "X86::IMUL64rr", "X86::PANDrr", "X86::PORrr", "X86::PXORrr", "X86::VPANDrr", "X86::VPANDYrr", "X86::VPORrr", "X86::VPORYrr", "X86::VPXORrr", "X86::VPXORYrr", "X86::MAXCPDrr", "X86::MAXCPSrr", "X86::MAXCSDrr", "X86::MAXCSSrr", "X86::MINCPDrr", "X86::MINCPSrr", "X86::MINCSDrr", "X86::MINCSSrr", "X86::VMAXCPDrr", "X86::VMAXCPSrr", "X86::VMAXCPDYrr", "X86::VMAXCPSYrr", "X86::VMAXCSDrr", "X86::VMAXCSSrr", "X86::VMINCPDrr", "X86::VMINCPSrr", "X86::VMINCPDYrr", "X86::VMINCPSYrr", "X86::VMINCSDrr", "X86::VMINCSSrr", "X86::ADDPDrr", "X86::ADDPSrr", "X86::ADDSDrr", "X86::ADDSSrr", "X86::MULPDrr", "X86::MULPSrr", "X86::MULSDrr", "X86::MULSSrr", "X86::VADDPDrr", "X86::VADDPSrr", "X86::VADDPDYrr", "X86::VADDPSYrr", "X86::VADDSDrr", "X86::VADDSSrr", "X86::VMULPDrr", "X86::VMULPSrr", "X86::VMULPDYrr", "X86::VMULPSYrr", "X86::VMULSDrr", "X86::VMULSSrr" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isOperandLegal", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ",", "const", "MachineOperand", "*", "MO", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "MI", ".", "getDesc", "(", ")", ";", "const", "MCOperandInfo", "&", "OpInfo", "=", "InstDesc", ".", "OpInfo", "[", "OpIdx", "]", ";", "const", "TargetRegisterClass", "*", "DefinedRC", "=", "OpInfo", ".", "RegClass", "!=", "-", "1", "?", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ":", "nullptr", ";", "if", "(", "!", "MO", ")", "MO", "=", "&", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "int", "ConstantBusLimit", "=", "ST", ".", "getConstantBusLimit", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "int", "VOP3LiteralLimit", "=", "ST", ".", "hasVOP3Literal", "(", ")", "?", "1", ":", "0", ";", "if", "(", "isVALU", "(", "MI", ")", "&&", "usesConstantBus", "(", "MRI", ",", "*", "MO", ",", "OpInfo", ")", ")", "{", "if", "(", "isVOP3", "(", "MI", ")", "&&", "isLiteralConstantLike", "(", "*", "MO", ",", "OpInfo", ")", "&&", "!", "VOP3LiteralLimit", "--", ")", "return", "false", ";", "SmallDenseSet", "<", "RegSubRegPair", ">", "SGPRsUsed", ";", "if", "(", "MO", "->", "isReg", "(", ")", ")", "SGPRsUsed", ".", "insert", "(", "RegSubRegPair", "(", "MO", "->", "getReg", "(", ")", ",", "MO", "->", "getSubReg", "(", ")", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "==", "OpIdx", ")", "continue", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "RegSubRegPair", "SGPR", "(", "Op", ".", "getReg", "(", ")", ",", "Op", ".", "getSubReg", "(", ")", ")", ";", "if", "(", "!", "SGPRsUsed", ".", "count", "(", "SGPR", ")", "&&", "usesConstantBus", "(", "MRI", ",", "Op", ",", "InstDesc", ".", "OpInfo", "[", "i", "]", ")", ")", "{", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "SGPRsUsed", ".", "insert", "(", "SGPR", ")", ";", "}", "}", "else", "if", "(", "InstDesc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", "==", "AMDGPU", "::", "OPERAND_KIMM32", ")", "{", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "}", "else", "if", "(", "isVOP3", "(", "MI", ")", "&&", "AMDGPU", "::", "isSISrcOperand", "(", "InstDesc", ",", "i", ")", "&&", "isLiteralConstantLike", "(", "Op", ",", "InstDesc", ".", "OpInfo", "[", "i", "]", ")", ")", "{", "if", "(", "!", "VOP3LiteralLimit", "--", ")", "return", "false", ";", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "}", "}", "}", "if", "(", "MO", "->", "isReg", "(", ")", ")", "{", "assert", "(", "DefinedRC", ")", ";", "return", "isLegalRegOperand", "(", "MRI", ",", "OpInfo", ",", "*", "MO", ")", ";", "}", "assert", "(", "MO", "->", "isImm", "(", ")", "||", "MO", "->", "isTargetIndex", "(", ")", "||", "MO", "->", "isFI", "(", ")", "||", "MO", "->", "isGlobal", "(", ")", ")", ";", "if", "(", "!", "DefinedRC", ")", "{", "return", "true", ";", "}", "return", "isImmOperandLegal", "(", "MI", ",", "OpIdx", ",", "*", "MO", ")", ";", "}", "</s>" ]

[ "Check", "if", "MO", "is", "a", "legal", "operand", "if", "it", "was", "the", "OpIdx", "Operand", "for", "MI", "." ]

[ "AMDGPU", "SI", "1", "1", "0", "0", "0", "AMDGPU::OPERAND_KIMM32", "0", "AMDGPU::isSISrcOperand", "0" ]

[]

[ "<s>", "int", "barrier_align", "(", "rtx", "barrier_or_label", ")", "{", "rtx", "next", "=", "next_real_insn", "(", "barrier_or_label", ")", ",", "pat", ",", "prev", ";", "int", "slot", ",", "credit", ",", "jump_to_next", "=", "0", ";", "if", "(", "!", "next", ")", "return", "0", ";", "pat", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "ADDR_DIFF_VEC", ")", "return", "2", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "pat", ",", "1", ")", "==", "UNSPECV_ALIGN", ")", "return", "0", ";", "prev", "=", "prev_real_insn", "(", "barrier_or_label", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "ADDR_DIFF_VEC", ")", "{", "pat", "=", "PATTERN", "(", "prev", ")", ";", "return", "(", "(", "TARGET_SMALLCODE", "||", "(", "(", "unsigned", ")", "XVECLEN", "(", "pat", ",", "1", ")", "*", "GET_MODE_SIZE", "(", "GET_MODE", "(", "pat", ")", ")", "<=", "(", "unsigned", ")", "1", "<<", "(", "CACHE_LOG", "-", "2", ")", ")", ")", "?", "1", "<<", "TARGET_SHMEDIA", ":", "align_jumps_log", ")", ";", "}", "if", "(", "TARGET_SMALLCODE", ")", "return", "0", ";", "if", "(", "!", "TARGET_SH2", "||", "!", "optimize", ")", "return", "align_jumps_log", ";", "if", "(", "mdep_reorg_phase", ">", "SH_FIXUP_PCLOAD", ")", "{", "prev", "=", "prev_real_insn", "(", "prev", ")", ";", "for", "(", "slot", "=", "2", ",", "credit", "=", "(", "1", "<<", "(", "CACHE_LOG", "-", "2", ")", ")", "+", "2", ";", "credit", ">=", "0", "&&", "prev", "&&", "GET_CODE", "(", "prev", ")", "==", "INSN", ";", "prev", "=", "prev_real_insn", "(", "prev", ")", ")", "{", "jump_to_next", "=", "0", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "CLOBBER", ")", "continue", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "{", "prev", "=", "XVECEXP", "(", "PATTERN", "(", "prev", ")", ",", "0", ",", "1", ")", ";", "if", "(", "INSN_UID", "(", "prev", ")", "==", "INSN_UID", "(", "next", ")", ")", "{", "jump_to_next", "=", "1", ";", "continue", ";", "}", "}", "if", "(", "slot", "&&", "get_attr_in_delay_slot", "(", "prev", ")", "==", "IN_DELAY_SLOT_YES", ")", "slot", "=", "0", ";", "credit", "-=", "get_attr_length", "(", "prev", ")", ";", "}", "if", "(", "prev", "&&", "GET_CODE", "(", "prev", ")", "==", "JUMP_INSN", "&&", "JUMP_LABEL", "(", "prev", ")", ")", "{", "rtx", "x", ";", "if", "(", "jump_to_next", "||", "next_real_insn", "(", "JUMP_LABEL", "(", "prev", ")", ")", "==", "next", "||", "JUMP_LABEL", "(", "prev", ")", "==", "next_nonnote_insn", "(", "next", ")", "||", "(", "x", "=", "(", "NEXT_INSN", "(", "NEXT_INSN", "(", "PREV_INSN", "(", "prev", ")", ")", ")", ")", ",", "(", "INSN_P", "(", "x", ")", "&&", "(", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_block_branch_redirect", "||", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_indirect_jump_scratch", "||", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_stuff_delay_slot", ")", ")", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "prev", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "credit", "-", "slot", ">=", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "PC", "?", "2", ":", "0", ")", ")", "return", "0", ";", "}", "}", "}", "return", "align_jumps_log", ";", "}", "</s>" ]

[ "BARRIER_OR_LABEL", "is", "either", "a", "BARRIER", "or", "a", "CODE_LABEL", "immediately", "following", "a", "barrier", ".", "Return", "the", "base", "2", "logarithm", "of", "the", "desired", "alignment", "." ]

[ "sh", "0", "0", "2", "1", "0", "1", "1", "2", "1", "0", "2", "1", "2", "2", "0", "0", "0", "1", "1", "0", "0", "0", "2", "0", "0" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "ExtraCode", "||", "!", "ExtraCode", "[", "0", "]", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected operand for inline assembly\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "printModifiedFPRAsmOperand", "(", "MO", ",", "TRI", ",", "'v'", ",", "O", ")", ")", "O", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "'#'", "<<", "MO", ".", "getImm", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "assert", "(", "MO", ".", "getFPImm", "(", ")", "->", "isExactlyValue", "(", "0.0", ")", "&&", "\"Only FP 0.0 expected\"", ")", ";", "O", "<<", "\"#0.0\"", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "return", "printSymbolicAddress", "(", "MO", ",", "false", ",", "\"\"", ",", "O", ")", ";", "}", "return", "false", ";", "}", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'c'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isImm", "(", ")", ")", "return", "true", ";", "O", "<<", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'w'", ":", "return", "printModifiedGPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "GPR32RegClass", ",", "O", ")", ";", "case", "'x'", ":", "return", "printModifiedGPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "GPR64RegClass", ",", "O", ")", ";", "case", "'H'", ":", "case", "'Q'", ":", "case", "'R'", ":", "llvm_unreachable", "(", "\"FIXME: Unimplemented register pairs\"", ")", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'s'", ":", "case", "'d'", ":", "case", "'q'", ":", "return", "printModifiedFPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "case", "'A'", ":", "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "false", ",", "\"\"", ",", "O", ")", ";", "case", "'L'", ":", "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "true", ",", "\"lo12\"", ",", "O", ")", ";", "case", "'G'", ":", "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "true", ",", "\"hi12\"", ",", "O", ")", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "\"Unexpected operand for inline assembly\"", "AArch64", "0.0", "\"Only FP 0.0 expected\"", "\"#0.0\"", "\"\"", "0", "AArch64::GPR32RegClass", "AArch64::GPR64RegClass", "\"FIXME: Unimplemented register pairs\"", "0", "\"\"", "\"lo12\"", "\"hi12\"" ]

[]

[ "<s>", "static", "ArrayRef", "<", "MCPhysReg", ">", "getAllSGPR128", "(", "const", "SISubtarget", "&", "ST", ",", "const", "MachineFunction", "&", "MF", ")", "{", "return", "makeArrayRef", "(", "AMDGPU", "::", "SGPR_128RegClass", ".", "begin", "(", ")", ",", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", "/", "4", ")", ";", "}", "</s>" ]

[ "Return", "all", "SGPR128", "which", "satisfy", "the", "waves", "per", "execution", "unit", "requirement", "of", "the", "subtarget", "." ]

[ "AMDGPU", "SI", "AMDGPU::SGPR_128RegClass", "4" ]

[]

[ "<s>", "rtx", "aarch64_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "int", "icode", ";", "rtx", "pat", ",", "op0", ";", "tree", "arg0", ";", "switch", "(", "fcode", ")", "{", "case", "AARCH64_BUILTIN_GET_FPCR", ":", "case", "AARCH64_BUILTIN_SET_FPCR", ":", "case", "AARCH64_BUILTIN_GET_FPSR", ":", "case", "AARCH64_BUILTIN_SET_FPSR", ":", "if", "(", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPCR", ")", "||", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPSR", ")", ")", "{", "icode", "=", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPSR", ")", "?", "CODE_FOR_get_fpsr", ":", "CODE_FOR_get_fpcr", ";", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "}", "else", "{", "target", "=", "NULL_RTX", ";", "icode", "=", "(", "fcode", "==", "AARCH64_BUILTIN_SET_FPSR", ")", "?", "CODE_FOR_set_fpsr", ":", "CODE_FOR_set_fpcr", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ")", ";", "}", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "if", "(", "fcode", ">=", "AARCH64_SIMD_BUILTIN_BASE", "&&", "fcode", "<=", "AARCH64_SIMD_BUILTIN_MAX", ")", "return", "aarch64_simd_expand_builtin", "(", "fcode", ",", "exp", ",", "target", ")", ";", "else", "if", "(", "fcode", ">=", "AARCH64_CRC32_BUILTIN_BASE", "&&", "fcode", "<=", "AARCH64_CRC32_BUILTIN_MAX", ")", "return", "aarch64_crc32_expand_builtin", "(", "fcode", ",", "exp", ",", "target", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN", "." ]

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

[]

[ "<s>", "inline", "mode_suffix_index", "find_mode_suffix", "(", "vector_type_index", "base_vector_type", ",", "vector_type_index", "displacement_vector_type", ",", "units_index", "displacement_units", ")", "{", "for", "(", "unsigned", "int", "mode_i", "=", "0", ";", "mode_i", "<", "ARRAY_SIZE", "(", "mode_suffixes", ")", ";", "++", "mode_i", ")", "{", "const", "mode_suffix_info", "&", "mode", "=", "mode_suffixes", "[", "mode_i", "]", ";", "if", "(", "mode", ".", "base_vector_type", "==", "base_vector_type", "&&", "mode", ".", "displacement_vector_type", "==", "displacement_vector_type", "&&", "mode", ".", "displacement_units", "==", "displacement_units", ")", "return", "mode_suffix_index", "(", "mode_i", ")", ";", "}", "return", "MODE_none", ";", "}", "</s>" ]

[ "Try", "to", "find", "a", "mode", "with", "the", "given", "mode_suffix_info", "fields", ".", "Return", "the", "mode", "on", "success", "or", "MODE_none", "on", "failure", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "s390_output_pool_entry", "(", "rtx", "exp", ",", "machine_mode", "mode", ",", "unsigned", "int", "align", ")", "{", "REAL_VALUE_TYPE", "r", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_FLOAT", ":", "case", "MODE_DECIMAL_FLOAT", ":", "gcc_assert", "(", "GET_CODE", "(", "exp", ")", "==", "CONST_DOUBLE", ")", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "exp", ")", ";", "assemble_real", "(", "r", ",", "mode", ",", "align", ")", ";", "break", ";", "case", "MODE_INT", ":", "assemble_integer", "(", "exp", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "align", ",", "1", ")", ";", "mark_symbol_refs_as_used", "(", "exp", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "the", "constant", "pool", "entry", "EXP", "in", "mode", "MODE", "with", "alignment", "ALIGN", "." ]

[ "s390", "1" ]

[]

[ "<s>", "bool", "RISCVELFTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalObject", "*", "GO", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GO", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "GVA", "->", "hasSection", "(", ")", ")", "{", "StringRef", "Section", "=", "GVA", "->", "getSection", "(", ")", ";", "if", "(", "Section", "==", "\".sdata\"", "||", "Section", "==", "\".sbss\"", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "(", "(", "GVA", "->", "hasExternalLinkage", "(", ")", "&&", "GVA", "->", "isDeclaration", "(", ")", ")", "||", "GVA", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GVA", "->", "getValueType", "(", ")", ";", "if", "(", "!", "Ty", "->", "isSized", "(", ")", ")", "return", "false", ";", "return", "isInSmallSection", "(", "GVA", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "RI5CY", "RISCV", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "JIT", ",", "RM", ")", ",", "getEffectiveX86CodeModel", "(", "CM", ",", "JIT", ",", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", "{", "if", "(", "TT", ".", "isPS4", "(", ")", "||", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "TT", ".", "isOSBinFormatMachO", "(", ")", ";", "}", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "setMachineOutliner", "(", "true", ")", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "Cpu0TargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">>", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "||", "!", "GlobalOrExternal", ")", "{", "unsigned", "T9Reg", "=", "Cpu0", "::", "T9", ";", "RegsToPass", ".", "push_front", "(", "std", "::", "make_pair", "(", "T9Reg", ",", "Callee", ")", ")", ";", "}", "else", "{", "Ops", ".", "push_back", "(", "Callee", ")", ";", "}", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", ")", "{", "unsigned", "GPReg", "=", "Cpu0", "::", "GP", ";", "EVT", "Ty", "=", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "unsigned", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "DAG", ".", "getMachineFunction", "(", ")", ",", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Cpu0", "Cpu0", "Cpu0::T9", "Cpu0::GP", "MVT::i32", "0", "1", "0", "\"Missing call preserved mask for calling convention\"" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "void", "SPIRVAsmPrinter", "::", "emitBasicBlockStart", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "{", "if", "(", "MBB", ".", "getNumber", "(", ")", "==", "MF", "->", "front", "(", ")", ".", "getNumber", "(", ")", ")", "{", "for", "(", "const", "MachineInstr", "&", "MI", ":", "MBB", ")", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SPIRV", "::", "OpFunction", ")", "return", ";", "report_fatal_error", "(", "\"OpFunction is expected in the front MBB of MF\"", ")", ";", "}", "emitOpLabel", "(", "MBB", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "at", "the", "start", "of", "a", "basic", "block", "." ]

[ "SPIRV", "SPIRV", "SPIRV::OpFunction", "\"OpFunction is expected in the front MBB of MF\"" ]

[]

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

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

[ "ARC", "ARC" ]

[]

[ "<s>", "const", "char", "*", "output_sibcall", "(", "rtx", "x", ")", "{", "if", "(", "symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "m68k_symbolic_jump", ";", "else", "return", "\"jmp %a0\"", ";", "}", "</s>" ]

[ "Output", "a", "sibling", "call", "." ]

[ "m68k", "\"jmp %a0\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "getWavesPerEU", "(", ")", "const", "{", "return", "WavesPerEU", ";", "}", "</s>" ]

[ "Overload", "which", "uses", "the", "specified", "values", "for", "the", "flat", "work", "group", "sizes", ",", "rather", "than", "querying", "the", "function", "itself", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ISelDAGToDAG **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "hasAddr64", "(", ")", ")", "report_fatal_error", "(", "\"64-bit WebAssembly (wasm64) is not currently supported\"", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"********** ISelDAGToDAG **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"64-bit WebAssembly (wasm64) is not currently supported\"" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "}", "</s>" ]

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

[ "OR1K" ]

[]

[ "<s>", "void", "final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "opvec", "[", "]", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "dslots_number_nops", ">", "0", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "int", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", "==", "0", "||", "(", "iq2000_load_reg", "!=", "0", "&&", "reg_mentioned_p", "(", "iq2000_load_reg", ",", "pattern", ")", ")", "||", "(", "iq2000_load_reg2", "!=", "0", "&&", "reg_mentioned_p", "(", "iq2000_load_reg2", ",", "pattern", ")", ")", "||", "(", "iq2000_load_reg3", "!=", "0", "&&", "reg_mentioned_p", "(", "iq2000_load_reg3", ",", "pattern", ")", ")", "||", "(", "iq2000_load_reg4", "!=", "0", "&&", "reg_mentioned_p", "(", "iq2000_load_reg4", ",", "pattern", ")", ")", ")", "fputs", "(", "\"\\tnop\\n\"", ",", "asm_out_file", ")", ";", "else", "dslots_load_filled", "++", ";", "while", "(", "--", "dslots_number_nops", ">", "0", ")", "fputs", "(", "\"\\tnop\\n\"", ",", "asm_out_file", ")", ";", "iq2000_load_reg", "=", "0", ";", "iq2000_load_reg2", "=", "0", ";", "iq2000_load_reg3", "=", "0", ";", "iq2000_load_reg4", "=", "0", ";", "}", "if", "(", "(", "JUMP_P", "(", "insn", ")", "||", "CALL_P", "(", "insn", ")", "||", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "RETURN", ")", ")", "&&", "NEXT_INSN", "(", "PREV_INSN", "(", "insn", ")", ")", "==", "insn", ")", "{", "rtx_insn", "*", "tmp", "=", "insn", ";", "while", "(", "NEXT_INSN", "(", "tmp", ")", "&&", "NOTE_P", "(", "NEXT_INSN", "(", "tmp", ")", ")", "&&", "NOTE_KIND", "(", "NEXT_INSN", "(", "tmp", ")", ")", "==", "NOTE_INSN_CALL_ARG_LOCATION", ")", "tmp", "=", "NEXT_INSN", "(", "tmp", ")", ";", "rtx_insn", "*", "nop_insn", "=", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "tmp", ")", ";", "INSN_ADDRESSES_NEW", "(", "nop_insn", ",", "-", "1", ")", ";", "}", "if", "(", "TARGET_STATS", "&&", "(", "JUMP_P", "(", "insn", ")", "||", "CALL_P", "(", "insn", ")", ")", ")", "dslots_jump_total", "++", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "." ]

[ "iq2000", "0", "0", "0", "0", "0", "0", "\"\\tnop\\n\"", "0", "\"\\tnop\\n\"", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "AArch64InstrInfo", "::", "suppressLdStPair", "(", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "memoperands_empty", "(", ")", ")", "return", ";", "assert", "(", "MOSuppressPair", "<", "(", "1", "<<", "MachineMemOperand", "::", "MOTargetNumBits", ")", "&&", "\"Too many target MO flags\"", ")", ";", "(", "*", "MI", "->", "memoperands_begin", "(", ")", ")", "->", "setFlags", "(", "MOSuppressPair", "<<", "MachineMemOperand", "::", "MOTargetStartBit", ")", ";", "}", "</s>" ]

[ "Hint", "that", "pairing", "the", "given", "load", "or", "store", "is", "unprofitable", "." ]

[ "AArch64", "AArch64", "1", "\"Too many target MO flags\"" ]

[]

[ "<s>", "void", "AlphaTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "VAARG", "&&", "\"Unknown node to custom promote!\"", ")", ";", "SDValue", "Chain", ",", "DataPtr", ";", "LowerVAARG", "(", "N", ",", "Chain", ",", "DataPtr", ",", "DAG", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getLoad", "(", "N", "->", "getValueType", "(", "0", ")", ",", "dl", ",", "Chain", ",", "DataPtr", ",", "NULL", ",", "0", ")", ";", "Results", ".", "push_back", "(", "Res", ")", ";", "Results", ".", "push_back", "(", "SDValue", "(", "Res", ".", "getNode", "(", ")", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "Alpha", "Alpha", "0", "MVT::i32", "ISD::VAARG", "\"Unknown node to custom promote!\"", "0", "0", "1" ]

[]

[ "<s>", "bool", "m32c_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "int", "mode_adjust", ";", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "1", ";", "if", "(", "TARGET_A16", "&&", "GET_MODE", "(", "x", ")", "!=", "HImode", "&&", "GET_MODE", "(", "x", ")", "!=", "SImode", ")", "return", "0", ";", "if", "(", "TARGET_A24", "&&", "GET_MODE", "(", "x", ")", "!=", "PSImode", ")", "return", "0", ";", "mode_adjust", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_MODIFY", ")", "{", "return", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SP_REGNO", ")", ";", "}", "if", "(", "TARGET_A24", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "!=", "PLUS", ")", "{", "fprintf", "(", "stderr", ",", "\"double indirect\\n\"", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "encode_pattern", "(", "x", ")", ";", "if", "(", "RTX_IS", "(", "\"r\"", ")", ")", "{", "switch", "(", "REGNO", "(", "patternr", "[", "0", "]", ")", ")", "{", "case", "A1_REGNO", ":", "case", "SB_REGNO", ":", "case", "FB_REGNO", ":", "case", "SP_REGNO", ":", "if", "(", "TARGET_A16", "&&", "GET_MODE", "(", "x", ")", "==", "SImode", ")", "return", "0", ";", "case", "A0_REGNO", ":", "return", "1", ";", "default", ":", "if", "(", "IS_PSEUDO", "(", "patternr", "[", "0", "]", ",", "strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "}", "if", "(", "TARGET_A16", "&&", "GET_MODE", "(", "x", ")", "==", "SImode", ")", "return", "0", ";", "if", "(", "RTX_IS", "(", "\"+ri\"", ")", ")", "{", "int", "rn", "=", "REGNO", "(", "patternr", "[", "1", "]", ")", ";", "HOST_WIDE_INT", "offs", "=", "INTVAL", "(", "patternr", "[", "2", "]", ")", ";", "switch", "(", "rn", ")", "{", "case", "A0_REGNO", ":", "case", "A1_REGNO", ":", "case", "SB_REGNO", ":", "if", "(", "TARGET_A16", ")", "return", "(", "offs", ">=", "-", "65536", "&&", "offs", "<=", "65535", "-", "mode_adjust", ")", ";", "if", "(", "rn", "==", "SB_REGNO", ")", "return", "(", "offs", ">=", "0", "&&", "offs", "<=", "65535", "-", "mode_adjust", ")", ";", "return", "(", "offs", ">=", "-", "16777216", "&&", "offs", "<=", "16777215", ")", ";", "case", "FB_REGNO", ":", "if", "(", "TARGET_A16", ")", "return", "(", "offs", ">=", "-", "128", "&&", "offs", "<=", "127", "-", "mode_adjust", ")", ";", "return", "(", "offs", ">=", "-", "65536", "&&", "offs", "<=", "65535", "-", "mode_adjust", ")", ";", "case", "SP_REGNO", ":", "return", "(", "offs", ">=", "-", "128", "&&", "offs", "<=", "127", "-", "mode_adjust", ")", ";", "default", ":", "if", "(", "IS_PSEUDO", "(", "patternr", "[", "1", "]", ",", "strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "}", "if", "(", "RTX_IS", "(", "\"+rs\"", ")", "||", "RTX_IS", "(", "\"+r+si\"", ")", ")", "{", "rtx", "reg", "=", "patternr", "[", "1", "]", ";", "switch", "(", "REGNO", "(", "reg", ")", ")", "{", "case", "A0_REGNO", ":", "case", "A1_REGNO", ":", "return", "1", ";", "default", ":", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "return", "0", ";", "if", "(", "IS_PSEUDO", "(", "reg", ",", "strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Used", "by", "GO_IF_LEGITIMATE_ADDRESS", ".", "The", "r8c/m32c", "family", "supports", "a", "wide", "range", "of", "non-orthogonal", "addressing", "modes", ",", "including", "the", "ability", "to", "double-indirect", "on", "*", "some", "*", "of", "them", ".", "Not", "all", "insns", "support", "all", "modes", ",", "either", ",", "but", "we", "rely", "on", "predicates", "and", "constraints", "to", "deal", "with", "that", "." ]

[ "m32c", "1", "0", "0", "1", "0", "0", "0", "\"double indirect\\n\"", "0", "\"r\"", "0", "0", "1", "0", "1", "0", "0", "\"+ri\"", "1", "2", "65536", "65535", "0", "65535", "16777216", "16777215", "128", "127", "65536", "65535", "128", "127", "1", "1", "0", "\"+rs\"", "\"+r+si\"", "1", "1", "0", "1", "0", "0" ]

[]

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

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

[ "WebAssembly", "\"relooper\"" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "SLLW", ":", "case", "RISCVISD", "::", "SRAW", ":", "case", "RISCVISD", "::", "SRLW", ":", "case", "RISCVISD", "::", "DIVW", ":", "case", "RISCVISD", "::", "DIVUW", ":", "case", "RISCVISD", "::", "REMUW", ":", "case", "RISCVISD", "::", "ROLW", ":", "case", "RISCVISD", "::", "RORW", ":", "case", "RISCVISD", "::", "GREVIW", ":", "case", "RISCVISD", "::", "GORCIW", ":", "case", "RISCVISD", "::", "FSLW", ":", "case", "RISCVISD", "::", "FSRW", ":", "return", "33", ";", "}", "return", "1", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVISD::SLLW", "RISCVISD::SRAW", "RISCVISD::SRLW", "RISCVISD::DIVW", "RISCVISD::DIVUW", "RISCVISD::REMUW", "RISCVISD::ROLW", "RISCVISD::RORW", "RISCVISD::GREVIW", "RISCVISD::GORCIW", "RISCVISD::FSLW", "RISCVISD::FSRW", "33", "1" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CCAssignFnForCall", "(", "CallConv", ",", "isVarArg", ")", ")", ";", "}", "else", "{", "analyzeFormalArgumentsCompute", "(", "CCInfo", ",", "Ins", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "R600", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUASI", ".", "CONSTANT_BUFFER_0", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "PartOffset", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "4", ",", "MachineMemOperand", "::", "MONonTemporal", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "msp430_mcu_name", "(", "void", ")", "{", "if", "(", "target_mcu", ")", "{", "unsigned", "int", "i", ";", "unsigned", "int", "start_upper", ";", "unsigned", "int", "end_upper", ";", "static", "char", "mcu_name", "[", "64", "]", ";", "if", "(", "strncmp", "(", "target_mcu", ",", "\"msp430i\"", ",", "7", ")", "==", "0", ")", "{", "snprintf", "(", "mcu_name", ",", "sizeof", "(", "mcu_name", ")", "-", "1", ",", "\"__MSP430i%s__\"", ",", "target_mcu", "+", "7", ")", ";", "start_upper", "=", "9", ";", "}", "else", "{", "snprintf", "(", "mcu_name", ",", "sizeof", "(", "mcu_name", ")", "-", "1", ",", "\"__%s__\"", ",", "target_mcu", ")", ";", "start_upper", "=", "2", ";", "}", "end_upper", "=", "strlen", "(", "mcu_name", ")", "-", "2", ";", "for", "(", "i", "=", "start_upper", ";", "i", "<", "end_upper", ";", "i", "++", ")", "mcu_name", "[", "i", "]", "=", "TOUPPER", "(", "mcu_name", "[", "i", "]", ")", ";", "return", "mcu_name", ";", "}", "return", "msp430x", "?", "\"__MSP430XGENERIC__\"", ":", "\"__MSP430GENERIC__\"", ";", "}", "</s>" ]

[ "Generate", "a", "C", "preprocessor", "symbol", "based", "upon", "the", "MCU", "selected", "by", "the", "user", ".", "If", "a", "specific", "MCU", "has", "not", "been", "selected", "then", "return", "a", "generic", "symbol", "instead", "." ]

[ "msp430", "64", "\"msp430i\"", "7", "0", "1", "\"__MSP430i%s__\"", "7", "9", "1", "\"__%s__\"", "2", "2", "\"__MSP430XGENERIC__\"", "\"__MSP430GENERIC__\"" ]

[]

[ "<s>", "bool", "Z80oldRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SrcSubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "(", "void", ")", "TRI", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "TRI", ".", "getRegClassName", "(", "SrcRC", ")", "<<", "'['", "<<", "SrcRC", "->", "getNumRegs", "(", ")", "<<", "\"]:\"", "<<", "(", "SrcSubReg", "?", "TRI", ".", "getSubRegIndexName", "(", "SrcSubReg", ")", ":", "\"\"", ")", "<<", "\" -> \"", "<<", "TRI", ".", "getRegClassName", "(", "DstRC", ")", "<<", "'['", "<<", "DstRC", "->", "getNumRegs", "(", ")", "<<", "\"]:\"", "<<", "(", "DstSubReg", "?", "TRI", ".", "getSubRegIndexName", "(", "DstSubReg", ")", ":", "\"\"", ")", "<<", "' '", "<<", "TRI", ".", "getRegClassName", "(", "NewRC", ")", "<<", "'['", "<<", "NewRC", "->", "getNumRegs", "(", ")", "<<", "\"]\\n\"", ")", ";", "return", "std", "::", "min", "(", "SrcRC", "->", "getNumRegs", "(", ")", ",", "DstRC", "->", "getNumRegs", "(", ")", ")", "<=", "NewRC", "->", "getNumRegs", "(", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "\"]:\"", "\"\"", "\" -> \"", "\"]:\"", "\"\"", "\"]\\n\"" ]

[]

[ "<s>", "static", "tree", "nvptx_handle_kernel_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "ARG_UNUSED", "(", "args", ")", ",", "int", "ARG_UNUSED", "(", "flags", ")", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "decl", "=", "*", "node", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", ")", "{", "error", "(", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "decl", ")", ")", "!=", "void_type_node", ")", "{", "error", "(", "\"%qE attribute requires a void return type\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

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

[ "nvptx", "\"%qE attribute only applies to functions\"", "\"%qE attribute requires a void return type\"" ]

[]

[ "<s>", "void", "m32c_emit_epilogue", "(", "void", ")", "{", "if", "(", "m32c_pushm_popm", "(", "PP_justcount", ")", ">", "0", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", "emit_insn", "(", "gen_epilogue_start", "(", ")", ")", ";", "m32c_pushm_popm", "(", "PP_popm", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "{", "enum", "machine_mode", "spmode", "=", "TARGET_A16", "?", "HImode", ":", "PSImode", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "spmode", ",", "A0_REGNO", ")", ",", "gen_rtx_REG", "(", "spmode", ",", "FP_REGNO", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "spmode", ",", "SP_REGNO", ")", ",", "gen_rtx_REG", "(", "spmode", ",", "A0_REGNO", ")", ")", ";", "if", "(", "TARGET_A16", ")", "emit_insn", "(", "gen_pophi_16", "(", "gen_rtx_REG", "(", "HImode", ",", "FP_REGNO", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_poppsi", "(", "gen_rtx_REG", "(", "PSImode", ",", "FP_REGNO", ")", ")", ")", ";", "emit_insn", "(", "gen_popm", "(", "GEN_INT", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", ")", ")", ";", "emit_jump_insn", "(", "gen_epilogue_reit", "(", "GEN_INT", "(", "TARGET_A16", "?", "4", ":", "6", ")", ")", ")", ";", "}", "else", "if", "(", "cfun", "->", "machine", "->", "use_rts", ")", "emit_jump_insn", "(", "gen_epilogue_rts", "(", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_epilogue_exitd", "(", "GEN_INT", "(", "TARGET_A16", "?", "2", ":", "4", ")", ")", ")", ";", "emit_barrier", "(", ")", ";", "}", "</s>" ]

[ "Likewise", ",", "for", "the", "epilogue", ".", "The", "only", "exception", "is", "that", ",", "for", "interrupts", ",", "we", "must", "manually", "unwind", "the", "frame", "as", "the", "REIT", "opcode", "does", "n't", "do", "that", "." ]

[ "m32c", "0", "4", "6", "2", "4" ]

[]

[ "<s>", "bool", "nios2_emit_move_sequence", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "to", "=", "operands", "[", "0", "]", ";", "rtx", "from", "=", "operands", "[", "1", "]", ";", "if", "(", "!", "register_operand", "(", "to", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "from", ",", "mode", ")", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "from", "=", "copy_to_mode_reg", "(", "mode", ",", "from", ")", ";", "}", "if", "(", "CONSTANT_P", "(", "from", ")", ")", "{", "if", "(", "CONST_INT_P", "(", "from", ")", ")", "{", "if", "(", "!", "SMALL_INT", "(", "INTVAL", "(", "from", ")", ")", "&&", "!", "SMALL_INT_UNSIGNED", "(", "INTVAL", "(", "from", ")", ")", "&&", "!", "UPPER16_INT", "(", "INTVAL", "(", "from", ")", ")", ")", "{", "HOST_WIDE_INT", "high", "=", "(", "INTVAL", "(", "from", ")", "+", "0x8000", ")", "&", "~", "0xffff", ";", "HOST_WIDE_INT", "low", "=", "INTVAL", "(", "from", ")", "&", "0xffff", ";", "emit_move_insn", "(", "to", ",", "gen_int_mode", "(", "high", ",", "SImode", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "to", ",", "gen_int_mode", "(", "low", ",", "HImode", ")", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "from", ")", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "!", "gprel_constant_p", "(", "from", ")", ")", "{", "if", "(", "!", "nios2_large_unspec_reloc_p", "(", "from", ")", ")", "from", "=", "nios2_legitimize_constant_address", "(", "from", ")", ";", "if", "(", "CONSTANT_P", "(", "from", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "to", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "copy_rtx", "(", "from", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "to", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "to", ",", "from", ")", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "operands", "[", "1", "]", ")", ")", ";", "return", "true", ";", "}", "}", "}", "operands", "[", "0", "]", "=", "to", ";", "operands", "[", "1", "]", "=", "from", ";", "return", "false", ";", "}", "</s>" ]

[ "Main", "expander", "function", "for", "RTL", "moves", "." ]

[ "nios2", "0", "1", "0x8000", "0xffff", "0xffff", "1", "0", "1" ]

[]

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

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "Patmos" ]

[]

[ "<s>", "SDValue", "OpenRISCTargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "doesNotRet", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "unsigned", "int", "rs6000_data_alignment", "(", "tree", "type", ",", "unsigned", "int", "align", ",", "enum", "data_align", "how", ")", "{", "if", "(", "how", "!=", "align_opt", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "if", "(", "(", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "||", "(", "TARGET_PAIRED_FLOAT", "&&", "PAIRED_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", ")", "{", "if", "(", "align", "<", "64", ")", "align", "=", "64", ";", "}", "else", "if", "(", "align", "<", "128", ")", "align", "=", "128", ";", "}", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "&&", "TYPE_MODE", "(", "type", ")", "==", "DFmode", ")", "{", "if", "(", "align", "<", "64", ")", "align", "=", "64", ";", "}", "}", "if", "(", "how", "!=", "align_abi", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", "&&", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "QImode", ")", "{", "if", "(", "align", "<", "BITS_PER_WORD", ")", "align", "=", "BITS_PER_WORD", ";", "}", "}", "return", "align", ";", "}", "</s>" ]

[ "Return", "alignment", "of", "TYPE", ".", "Existing", "alignment", "is", "ALIGN", ".", "HOW", "selects", "whether", "the", "alignment", "is", "abi", "mandated", ",", "optional", ",", "or", "both", "abi", "and", "optional", "alignment", "." ]

[ "powerpcspe", "64", "64", "128", "128", "64", "64" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "O", "<<", "formatImm", "(", "Op", ".", "getImm", "(", ")", ")", ";", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"unknown pcrel immediate operand\"", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "evaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "formatHex", "(", "(", "uint64_t", ")", "Address", ")", ";", "}", "else", "{", "Op", ".", "getExpr", "(", ")", "->", "print", "(", "O", ",", "&", "MAI", ")", ";", "}", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "X86", "X86", "\"unknown pcrel immediate operand\"" ]

[]

[ "<s>", "bool", "PPCCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "MovePCtoLROffset", "=", "nullptr", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "emitBasicBlock", "(", "*", "BB", ")", ";", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"JIT relocation model must be set to static or default!\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "MCAssembler", "*", "getAssembler", "(", ")", "const", "{", "return", "Assembler", ";", "}", "</s>" ]

[ "Get", "the", "assembler", "object", "this", "is", "a", "layout", "for", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "ix86_avoid_lea_for_add", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ")", "{", "unsigned", "int", "regno0", ",", "regno1", ",", "regno2", ";", "if", "(", "!", "TARGET_OPT_AGU", "||", "optimize_function_for_size_p", "(", "cfun", ")", ")", "return", "false", ";", "regno0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "regno1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "regno2", "=", "true_regnum", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "regno0", "==", "regno1", "||", "regno0", "==", "regno2", ")", "return", "false", ";", "else", "return", "!", "ix86_lea_outperforms", "(", "insn", ",", "regno0", ",", "regno1", ",", "regno2", ",", "1", ",", "false", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "need", "to", "split", "op0", "=", "op1", "+", "op2", "into", "a", "sequence", "of", "move", "and", "add", "to", "avoid", "AGU", "stalls", "." ]

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

[]

[ "<s>", "virtual", "const", "MCSection", "*", "getSectionForConstant", "(", "SectionKind", "Kind", ")", "const", "{", "return", "ReadOnlySection", ";", "}", "</s>" ]

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

[ "WDC65816" ]

[]

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

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

[ "R600", "1", "0", "4" ]

[]

[ "<s>", "unsigned", "CAHPInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "assert", "(", "TBB", "&&", "\"InsertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"CAHP branch conditions have two components!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "CAHP", "::", "JS", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "1", ";", "}", "unsigned", "Opc", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "MachineInstr", "&", "CondMI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "add", "(", "Cond", "[", "2", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "CondMI", ")", ";", "if", "(", "!", "FBB", ")", "return", "1", ";", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "CAHP", "::", "JS", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "0", "\"InsertBranch must not be told to insert a fallthrough\"", "3", "0", "\"CAHP branch conditions have two components!\"", "CAHP::JS", "1", "0", "1", "2", "1", "CAHP::JS", "2" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "isReg", "(", ")", ")", ";", "return", "MVTToWasmReg", "(", "Reg", ".", "Type", ")", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "void", "addInstruction", "(", "TagStoreInstr", "I", ")", "{", "assert", "(", "(", "TagStores", ".", "empty", "(", ")", "||", "TagStores", ".", "back", "(", ")", ".", "Offset", "+", "TagStores", ".", "back", "(", ")", ".", "Size", "==", "I", ".", "Offset", ")", "&&", "\"Non-adjacent tag store instructions.\"", ")", ";", "TagStores", ".", "push_back", "(", "I", ")", ";", "}", "</s>" ]

[ "Record", "pressure", "difference", "induced", "by", "the", "given", "operand", "list", "to", "node", "with", "index", "Idx", "." ]

[ "AArch64", "\"Non-adjacent tag store instructions.\"" ]

[]

[ "<s>", "static", "void", "ix86_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "next_cum", ";", "tree", "fntype", ";", "gcc_assert", "(", "!", "no_rtl", ")", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", ";", "fntype", "=", "TREE_TYPE", "(", "current_function_decl", ")", ";", "next_cum", "=", "*", "cum", ";", "if", "(", "stdarg_p", "(", "fntype", ")", ")", "ix86_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "arg", ")", ";", "if", "(", "cum", "->", "call_abi", "==", "MS_ABI", ")", "setup_incoming_varargs_ms_64", "(", "&", "next_cum", ")", ";", "else", "setup_incoming_varargs_64", "(", "&", "next_cum", ")", ";", "}", "</s>" ]

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

[ "i386" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "prepareVolatileOrAtomicLoad", "(", "SDValue", "Chain", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SERIALIZE", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "used", "to", "prepare", "for", "a", "volatile", "or", "atomic", "load", "." ]

[ "SystemZ", "SystemZ", "SystemZISD::SERIALIZE", "MVT::Other" ]

[]

[ "<s>", "void", "emitBytes", "(", "StringRef", "Data", ")", "override", "{", "emitDataMappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "emitBytes", "(", "Data", ")", ";", "}", "</s>" ]

[ "Emit", "the", "bytes", "in", "Data", "into", "the", "output", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "char", "*", "arc_tolower", "(", "char", "*", "lo", ",", "const", "char", "*", "up", ")", "{", "char", "*", "lo0", "=", "lo", ";", "for", "(", ";", "*", "up", ";", "up", "++", ",", "lo", "++", ")", "*", "lo", "=", "TOLOWER", "(", "*", "up", ")", ";", "*", "lo", "=", "'\\0'", ";", "return", "lo0", ";", "}", "</s>" ]

[ "Transform", "UP", "into", "lowercase", "and", "write", "the", "result", "to", "LO", ".", "You", "must", "provide", "enough", "space", "for", "LO", ".", "Return", "LO", "." ]

[ "arc" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode!\"", ")", ";", "case", "RISCV", "::", "BEQ", ":", "case", "RISCV", "::", "BNE", ":", "case", "RISCV", "::", "BLT", ":", "case", "RISCV", "::", "BGE", ":", "case", "RISCV", "::", "BLTU", ":", "case", "RISCV", "::", "BGEU", ":", "case", "RISCV", "::", "P_BEQIMM", ":", "case", "RISCV", "::", "P_BNEIMM", ":", "return", "isIntN", "(", "13", ",", "BrOffset", ")", ";", "case", "RISCV", "::", "JAL", ":", "case", "RISCV", "::", "PseudoBR", ":", "return", "isIntN", "(", "21", ",", "BrOffset", ")", ";", "case", "RISCV", "::", "LoopBranch", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "RISCV", "RISCV", "\"Unexpected opcode!\"", "RISCV::BEQ", "RISCV::BNE", "RISCV::BLT", "RISCV::BGE", "RISCV::BLTU", "RISCV::BGEU", "RISCV::P_BEQIMM", "RISCV::P_BNEIMM", "13", "RISCV::JAL", "RISCV::PseudoBR", "21", "RISCV::LoopBranch" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "RISCV", "::", "GPRRegClass", ";", "if", "(", "!", "isInt", "<", "11", ">", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ")", ")", "{", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ",", "DL", ")", ",", "RegInfo", "->", "getSpillAlignment", "(", "*", "RC", ",", "DL", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "11" ]

[]

[ "<s>", "void", "ix86_expand_vector_logical_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "op1", "=", "NULL_RTX", ",", "op2", "=", "NULL_RTX", ";", "if", "(", "SUBREG_P", "(", "operands", "[", "1", "]", ")", ")", "{", "op1", "=", "operands", "[", "1", "]", ";", "op2", "=", "operands", "[", "2", "]", ";", "}", "else", "if", "(", "SUBREG_P", "(", "operands", "[", "2", "]", ")", ")", "{", "op1", "=", "operands", "[", "2", "]", ";", "op2", "=", "operands", "[", "1", "]", ";", "}", "if", "(", "op1", "&&", "!", "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL", "&&", "(", "SUBREG_P", "(", "op2", ")", "||", "GET_CODE", "(", "op2", ")", "==", "CONST_VECTOR", ")", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", ")", "==", "MODE_VECTOR_FLOAT", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", ")", "==", "GET_MODE_SIZE", "(", "mode", ")", "&&", "SUBREG_BYTE", "(", "op1", ")", "==", "0", "&&", "(", "GET_CODE", "(", "op2", ")", "==", "CONST_VECTOR", "||", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", "==", "GET_MODE", "(", "SUBREG_REG", "(", "op2", ")", ")", "&&", "SUBREG_BYTE", "(", "op2", ")", "==", "0", ")", ")", "&&", "can_create_pseudo_p", "(", ")", ")", "{", "rtx", "dst", ";", "switch", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", ")", "{", "case", "E_V4SFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V16SFmode", ":", "case", "E_V2DFmode", ":", "case", "E_V4DFmode", ":", "case", "E_V8DFmode", ":", "dst", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", ")", ";", "if", "(", "GET_CODE", "(", "op2", ")", "==", "CONST_VECTOR", ")", "{", "op2", "=", "gen_lowpart", "(", "GET_MODE", "(", "dst", ")", ",", "op2", ")", ";", "op2", "=", "force_reg", "(", "GET_MODE", "(", "dst", ")", ",", "op2", ")", ";", "}", "else", "{", "op1", "=", "operands", "[", "1", "]", ";", "op2", "=", "SUBREG_REG", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "!", "vector_operand", "(", "op2", ",", "GET_MODE", "(", "dst", ")", ")", ")", "op2", "=", "force_reg", "(", "GET_MODE", "(", "dst", ")", ",", "op2", ")", ";", "}", "op1", "=", "SUBREG_REG", "(", "op1", ")", ";", "if", "(", "!", "vector_operand", "(", "op1", ",", "GET_MODE", "(", "dst", ")", ")", ")", "op1", "=", "force_reg", "(", "GET_MODE", "(", "dst", ")", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "dst", ")", ",", "op1", ",", "op2", ")", ")", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "gen_lowpart", "(", "mode", ",", "dst", ")", ")", ";", "return", ";", "default", ":", "break", ";", "}", "}", "if", "(", "!", "vector_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "vector_operand", "(", "operands", "[", "2", "]", ",", "mode", ")", ")", "operands", "[", "2", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "2", "]", ")", ";", "ix86_fixup_binary_operands_no_copy", "(", "code", ",", "mode", ",", "operands", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "vector", "logical", "operation", "CODE", "(", "AND", ",", "IOR", ",", "XOR", ")", "in", "MODE", "with", "the", "given", "OPERANDS", "." ]

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

[]

[ "<s>", "void", "SystemZMCAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "Size", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "assert", "(", "Offset", "+", "Size", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "Value", "=", "extractBitsForFixup", "(", "Kind", ",", "Value", ")", ";", "unsigned", "ShiftValue", "=", "(", "Size", "*", "8", ")", "-", "8", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "Size", ";", "++", "I", ")", "{", "Data", "[", "Offset", "+", "I", "]", "|=", "uint8_t", "(", "Value", ">>", "ShiftValue", ")", ";", "ShiftValue", "-=", "8", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "SystemZ", "SystemZ", "7", "8", "\"Invalid fixup offset!\"", "8", "8", "0", "8" ]

[]

[ "<s>", "bool", "WebAssemblyMCLowerPrePass", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "auto", "*", "MMIWP", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ";", "if", "(", "!", "MMIWP", ")", "return", "true", ";", "MachineModuleInfo", "&", "MMI", "=", "MMIWP", "->", "getMMI", "(", ")", ";", "MachineModuleInfoWasm", "&", "MMIW", "=", "MMI", ".", "getObjFileInfo", "<", "MachineModuleInfoWasm", ">", "(", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "MachineFunction", "*", "MF", "=", "MMI", ".", "getMachineFunction", "(", "F", ")", ";", "if", "(", "!", "MF", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MC Lower Pre Pass **********\\n\"", "\"********** Function: \"", "<<", "MF", "->", "getName", "(", ")", "<<", "'\\n'", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "*", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isInlineAsm", "(", ")", ")", "continue", ";", "for", "(", "MachineOperand", "&", "MO", ":", "MI", ".", "uses", "(", ")", ")", "{", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "MMIW", ".", "MachineSymbolsUsed", ".", "insert", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** MC Lower Pre Pass **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "bool", "GCNTargetMachine", "::", "parseMachineFunctionInfo", "(", "const", "yaml", "::", "MachineFunctionInfo", "&", "MFI_", ",", "PerFunctionMIParsingState", "&", "PFS", ",", "SMDiagnostic", "&", "Error", ",", "SMRange", "&", "SourceRange", ")", "const", "{", "const", "yaml", "::", "SIMachineFunctionInfo", "&", "YamlMFI", "=", "reinterpret_cast", "<", "const", "yaml", "::", "SIMachineFunctionInfo", "&", ">", "(", "MFI_", ")", ";", "MachineFunction", "&", "MF", "=", "PFS", ".", "MF", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "initializeBaseYamlFields", "(", "YamlMFI", ")", ";", "auto", "parseRegister", "=", "[", "&", "]", "(", "const", "yaml", "::", "StringValue", "&", "RegName", ",", "unsigned", "&", "RegVal", ")", "{", "if", "(", "parseNamedRegisterReference", "(", "PFS", ",", "RegVal", ",", "RegName", ".", "Value", ",", "Error", ")", ")", "{", "SourceRange", "=", "RegName", ".", "SourceRange", ";", "return", "true", ";", "}", "return", "false", ";", "}", ";", "auto", "diagnoseRegisterClass", "=", "[", "&", "]", "(", "const", "yaml", "::", "StringValue", "&", "RegName", ")", "{", "const", "MemoryBuffer", "&", "Buffer", "=", "*", "PFS", ".", "SM", "->", "getMemoryBuffer", "(", "PFS", ".", "SM", "->", "getMainFileID", "(", ")", ")", ";", "Error", "=", "SMDiagnostic", "(", "*", "PFS", ".", "SM", ",", "SMLoc", "(", ")", ",", "Buffer", ".", "getBufferIdentifier", "(", ")", ",", "1", ",", "RegName", ".", "Value", ".", "size", "(", ")", ",", "SourceMgr", "::", "DK_Error", ",", "\"incorrect register class for field\"", ",", "RegName", ".", "Value", ",", "None", ",", "None", ")", ";", "SourceRange", "=", "RegName", ".", "SourceRange", ";", "return", "true", ";", "}", ";", "if", "(", "parseRegister", "(", "YamlMFI", ".", "ScratchRSrcReg", ",", "MFI", "->", "ScratchRSrcReg", ")", "||", "parseRegister", "(", "YamlMFI", ".", "ScratchWaveOffsetReg", ",", "MFI", "->", "ScratchWaveOffsetReg", ")", "||", "parseRegister", "(", "YamlMFI", ".", "FrameOffsetReg", ",", "MFI", "->", "FrameOffsetReg", ")", "||", "parseRegister", "(", "YamlMFI", ".", "StackPtrOffsetReg", ",", "MFI", "->", "StackPtrOffsetReg", ")", ")", "return", "true", ";", "if", "(", "MFI", "->", "ScratchRSrcReg", "!=", "AMDGPU", "::", "PRIVATE_RSRC_REG", "&&", "!", "AMDGPU", "::", "SReg_128RegClass", ".", "contains", "(", "MFI", "->", "ScratchRSrcReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "ScratchRSrcReg", ")", ";", "}", "if", "(", "MFI", "->", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "SCRATCH_WAVE_OFFSET_REG", "&&", "!", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MFI", "->", "ScratchWaveOffsetReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "ScratchWaveOffsetReg", ")", ";", "}", "if", "(", "MFI", "->", "FrameOffsetReg", "!=", "AMDGPU", "::", "FP_REG", "&&", "!", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MFI", "->", "FrameOffsetReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "FrameOffsetReg", ")", ";", "}", "if", "(", "MFI", "->", "StackPtrOffsetReg", "!=", "AMDGPU", "::", "SP_REG", "&&", "!", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MFI", "->", "StackPtrOffsetReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "StackPtrOffsetReg", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Parse", "out", "the", "target", "'s", "MachineFunctionInfo", "from", "the", "YAML", "reprsentation", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "1", "\"incorrect register class for field\"", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::SReg_128RegClass", "AMDGPU::SCRATCH_WAVE_OFFSET_REG", "AMDGPU::SGPR_32RegClass", "AMDGPU::FP_REG", "AMDGPU::SGPR_32RegClass", "AMDGPU::SP_REG", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "void", "aarch64_asm_output_external", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ")", "{", "default_elf_asm_output_external", "(", "stream", ",", "decl", ",", "name", ")", ";", "aarch64_asm_output_variant_pcs", "(", "stream", ",", "decl", ",", "name", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_EXTERNAL", ".", "Output", ".variant_pcs", "for", "undefined", "function", "symbol", "references", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "ia64_expand_vecint_minmax", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "xops", "[", "6", "]", ";", "if", "(", "mode", "==", "V8QImode", "&&", "(", "code", "==", "UMIN", "||", "code", "==", "UMAX", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "V4HImode", "&&", "(", "code", "==", "SMIN", "||", "code", "==", "SMAX", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "V4HImode", "&&", "code", "==", "UMAX", ")", "{", "rtx", "x", ",", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "x", "=", "gen_rtx_US_MINUS", "(", "mode", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "x", ")", ")", ";", "emit_insn", "(", "gen_addv4hi3", "(", "operands", "[", "0", "]", ",", "tmp", ",", "operands", "[", "2", "]", ")", ")", ";", "return", "true", ";", "}", "xops", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "xops", "[", "4", "]", "=", "xops", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "xops", "[", "5", "]", "=", "xops", "[", "2", "]", "=", "operands", "[", "2", "]", ";", "switch", "(", "code", ")", "{", "case", "UMIN", ":", "code", "=", "LTU", ";", "break", ";", "case", "UMAX", ":", "code", "=", "GTU", ";", "break", ";", "case", "SMIN", ":", "code", "=", "LT", ";", "break", ";", "case", "SMAX", ":", "code", "=", "GT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "xops", "[", "3", "]", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "ia64_expand_vecint_cmov", "(", "xops", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "an", "integral", "vector", "min", "or", "max", "operation", ".", "Return", "true", "if", "all", "done", "." ]

[ "ia64", "6", "1", "2", "0", "2", "0", "0", "4", "1", "1", "5", "2", "2", "3", "1", "2" ]

[]

[ "<s>", "static", "void", "aarch64_select_early_remat_modes", "(", "sbitmap", "modes", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "++", "i", ")", "if", "(", "aarch64_sve_mode_p", "(", "(", "machine_mode", ")", "i", ")", ")", "bitmap_set_bit", "(", "modes", ",", "i", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EARLY_REMAT_MODES", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "RISCVSubtarget", "&", "RISCVSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "StringRef", "ABIName", ")", "{", "bool", "Is64Bit", "=", "TT", ".", "isArch64Bit", "(", ")", ";", "std", "::", "string", "CPUName", "=", "std", "::", "string", "(", "CPU", ")", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "Is64Bit", "?", "\"generic-rv64\"", ":", "\"generic-rv32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPUName", ",", "FS", ")", ";", "if", "(", "Is64Bit", ")", "{", "XLenVT", "=", "MVT", "::", "i64", ";", "XLen", "=", "64", ";", "}", "TargetABI", "=", "RISCVABI", "::", "computeTargetABI", "(", "TT", ",", "getFeatureBits", "(", ")", ",", "ABIName", ")", ";", "RISCVFeatures", "::", "validate", "(", "TT", ",", "getFeatureBits", "(", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "\"generic-rv64\"", "\"generic-rv32\"", "MVT::i64", "64", "RISCVABI::computeTargetABI", "RISCVFeatures::validate" ]

[]

[ "<s>", "static", "tree", "ix86_generate_version_dispatcher_body", "(", "void", "*", "node_p", ")", "{", "tree", "resolver_decl", ";", "basic_block", "empty_bb", ";", "tree", "default_ver_decl", ";", "struct", "cgraph_node", "*", "versn", ";", "struct", "cgraph_node", "*", "node", ";", "struct", "cgraph_function_version_info", "*", "node_version_info", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "versn_info", "=", "NULL", ";", "node", "=", "(", "cgraph_node", "*", ")", "node_p", ";", "node_version_info", "=", "node", "->", "function_version", "(", ")", ";", "gcc_assert", "(", "node", "->", "dispatcher_function", "&&", "node_version_info", "!=", "NULL", ")", ";", "if", "(", "node_version_info", "->", "dispatcher_resolver", ")", "return", "node_version_info", "->", "dispatcher_resolver", ";", "default_ver_decl", "=", "node_version_info", "->", "next", "->", "this_node", "->", "decl", ";", "node", "->", "definition", "=", "false", ";", "resolver_decl", "=", "make_resolver_func", "(", "default_ver_decl", ",", "node", "->", "decl", ",", "&", "empty_bb", ")", ";", "node_version_info", "->", "dispatcher_resolver", "=", "resolver_decl", ";", "push_cfun", "(", "DECL_STRUCT_FUNCTION", "(", "resolver_decl", ")", ")", ";", "auto_vec", "<", "tree", ",", "2", ">", "fn_ver_vec", ";", "for", "(", "versn_info", "=", "node_version_info", "->", "next", ";", "versn_info", ";", "versn_info", "=", "versn_info", "->", "next", ")", "{", "versn", "=", "versn_info", "->", "this_node", ";", "if", "(", "DECL_VINDEX", "(", "versn", "->", "decl", ")", ")", "sorry", "(", "\"virtual function multiversioning not supported\"", ")", ";", "fn_ver_vec", ".", "safe_push", "(", "versn", "->", "decl", ")", ";", "}", "dispatch_function_versions", "(", "resolver_decl", ",", "&", "fn_ver_vec", ",", "&", "empty_bb", ")", ";", "cgraph_edge", "::", "rebuild_edges", "(", ")", ";", "pop_cfun", "(", ")", ";", "return", "resolver_decl", ";", "}", "</s>" ]

[ "Generate", "the", "dispatching", "code", "body", "to", "dispatch", "multi-versioned", "function", "DECL", ".", "The", "target", "hook", "is", "called", "to", "process", "the", "``", "target", "''", "attributes", "and", "provide", "the", "code", "to", "dispatch", "the", "right", "function", "at", "run-time", ".", "NODE", "points", "to", "the", "dispatcher", "decl", "whose", "body", "will", "be", "created", "." ]

[ "i386", "2", "\"virtual function multiversioning not supported\"" ]

[]

[ "<s>", "const", "M680x0InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0" ]

[]

[ "<s>", "void", "RISCVMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCALLReg", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCALL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoTAIL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoJump", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCCALLReg", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCCALL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCTAIL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCJump", ")", "{", "expandFunctionCall", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "2", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoAddTPRel", ")", "{", "expandAddTPRel", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "1", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCIncOffsetTPRel", ")", "{", "expandCIncOffsetTPRel", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "1", ";", "return", ";", "}", "switch", "(", "Size", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled encodeInstruction length!\"", ")", ";", "case", "2", ":", "{", "uint16_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "case", "4", ":", "{", "uint32_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::PseudoCALLReg", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "RISCV::PseudoJump", "RISCV::PseudoCCALLReg", "RISCV::PseudoCCALL", "RISCV::PseudoCTAIL", "RISCV::PseudoCJump", "2", "RISCV::PseudoAddTPRel", "1", "RISCV::PseudoCIncOffsetTPRel", "1", "\"Unhandled encodeInstruction length!\"", "2", "support::endian", "support::little", "4", "support::endian", "support::little" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createX86MaxStackAlignmentCalculatorPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "X86AsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "{", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "{", "if", "(", "Name", "==", "\"R_X86_64_NONE\"", ")", "return", "FK_NONE", ";", "}", "else", "{", "if", "(", "Name", "==", "\"R_386_NONE\"", ")", "return", "FK_NONE", ";", "}", "}", "return", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"R_X86_64_NONE\"", "\"R_386_NONE\"" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "StackPtr", ",", "int64_t", "NumBytes", ",", "bool", "Is64Bit", ",", "const", "TargetInstrInfo", "&", "TII", ")", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "unsigned", "Opc", "=", "isSub", "?", "getSUBriOpcode", "(", "Is64Bit", ",", "Offset", ")", ":", "getADDriOpcode", "(", "Is64Bit", ",", "Offset", ")", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "while", "(", "Offset", ")", "{", "uint64_t", "ThisVal", "=", "(", "Offset", ">", "Chunk", ")", "?", "Chunk", ":", "Offset", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "ThisVal", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "X86", "0", "1LL", "31", "1", "3" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "isRegister", "(", "const", "AsmToken", "&", "Token", ",", "const", "AsmToken", "&", "NextToken", ")", "const", "{", "if", "(", "Token", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "return", "true", ";", "if", "(", "!", "Token", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "false", ";", "StringRef", "RegName", "=", "Token", ".", "getString", "(", ")", ";", "for", "(", "StringRef", "Reg", ":", "Registers", ")", "{", "if", "(", "RegName", ".", "startswith", "(", "Reg", ")", ")", "{", "if", "(", "Reg", ".", "size", "(", ")", "<", "RegName", ".", "size", "(", ")", ")", "{", "unsigned", "RegNum", ";", "if", "(", "!", "RegName", ".", "substr", "(", "Reg", ".", "size", "(", ")", ")", ".", "getAsInteger", "(", "10", ",", "RegNum", ")", ")", "return", "true", ";", "}", "else", "{", "if", "(", "NextToken", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "return", "true", ";", "}", "}", "}", "return", "getSpecialRegForName", "(", "RegName", ")", ";", "}", "</s>" ]

[ "isRegister", "-", "Returns", "true", "if", "this", "is", "a", "normal", "register", "use/def", "slot", "." ]

[ "AMDGPU", "AMDGPU", "10" ]

[]

[ "<s>", "void", "StoreInitializer", "::", "print", "(", "raw_ostream", "&", "O", ")", "{", "StringRef", "Str", "=", "str", "(", ")", ";", "assert", "(", "Str", ".", "size", "(", ")", "%", "InitEltSize", "==", "0", ")", ";", "if", "(", "InitEltSize", "==", "1", ")", "{", "for", "(", "size_t", "I", "=", "0", ",", "E", "=", "Str", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "0", ")", "O", "<<", "\", \"", ";", "O", "<<", "(", "static_cast", "<", "int", ">", "(", "Str", "[", "I", "]", ")", "&", "0xff", ")", ";", "}", "return", ";", "}", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Str", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "I", "+=", "InitEltSize", ")", "{", "if", "(", "I", "!=", "0", ")", "O", "<<", "\", \"", ";", "const", "char", "*", "Ptr", "=", "&", "Str", ".", "data", "(", ")", "[", "I", "]", ";", "switch", "(", "InitEltSize", ")", "{", "case", "4", ":", "{", "uint32_t", "Tmp", ";", "std", "::", "memcpy", "(", "&", "Tmp", ",", "Ptr", ",", "4", ")", ";", "if", "(", "IsFPElt", ")", "printFloat", "(", "Tmp", ",", "O", ")", ";", "else", "O", "<<", "Tmp", ";", "break", ";", "}", "case", "8", ":", "{", "uint64_t", "Tmp", ";", "std", "::", "memcpy", "(", "&", "Tmp", ",", "Ptr", ",", "8", ")", ";", "if", "(", "IsFPElt", ")", "printDouble", "(", "Tmp", ",", "O", ")", ";", "else", "O", "<<", "Tmp", ";", "break", ";", "}", "case", "2", ":", "{", "uint16_t", "Tmp", ";", "std", "::", "memcpy", "(", "&", "Tmp", ",", "Ptr", ",", "2", ")", ";", "assert", "(", "!", "IsFPElt", "&&", "\"half not implemented\"", ")", ";", "O", "<<", "Tmp", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unhandled element size\"", ")", ";", "}", "}", "}", "</s>" ]

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

[ "HSAIL", "0", "1", "0", "0", "\", \"", "0xff", "0", "0", "\", \"", "4", "4", "8", "8", "2", "2", "\"half not implemented\"", "\"Unhandled element size\"" ]

[]