Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "rtx_insn", "*", "aarch64_prev_real_insn", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", ")", "return", "NULL", ";", "do", "{", "insn", "=", "prev_real_insn", "(", "insn", ")", ";", "}", "while", "(", "insn", "&&", "recog_memoized", "(", "insn", ")", "<", "0", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Find", "the", "first", "rtx_insn", "before", "insn", "that", "will", "generate", "an", "assembly", "instruction", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dumpr", "(", "&", "DAG", ")", ";", "if", "(", "Opc", ">", "HexagonISD", "::", "OP_BEGIN", "&&", "Opc", "<", "HexagonISD", "::", "OP_END", ")", "errs", "(", ")", "<<", "\"Check for a non-legal type in this operation\\n\"", ";", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "return", "LowerINSERT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerVECTOR_SHIFT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "LowerVSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTPOP", ":", "return", "LowerCTPOP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INLINEASM", ":", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::OP_BEGIN", "HexagonISD::OP_END", "\"Check for a non-legal type in this operation\\n\"", "\"Should not custom lower this!\"", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_SUBVECTOR", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SRA", "ISD::SHL", "ISD::SRL", "ISD::ConstantPool", "ISD::JumpTable", "ISD::EH_RETURN", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::ATOMIC_FENCE", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GLOBAL_OFFSET_TABLE", "ISD::VASTART", "ISD::LOAD", "ISD::DYNAMIC_STACKALLOC", "ISD::SETCC", "ISD::VSELECT", "ISD::CTPOP", "ISD::INTRINSIC_WO_CHAIN", "ISD::INLINEASM" ]

[]

[ "<s>", "static", "bool", "m32r_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "(", "m32r_hard_regno_modes", "[", "regno", "]", "&", "m32r_mode_class", "[", "mode", "]", ")", "!=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "m32r", "0" ]

[]

[ "<s>", "static", "void", "ix86_vec_perm_index_canon", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "nelt", "=", "d", "->", "nelt", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "<", "nelt", ")", "return", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "nelt", ";", "i", "++", ")", "d", "->", "perm", "[", "i", "]", "=", "(", "d", "->", "perm", "[", "i", "]", "+", "nelt", ")", "%", "(", "2", "*", "nelt", ")", ";", "std", "::", "swap", "(", "d", "->", "op0", ",", "d", "->", "op1", ")", ";", "return", ";", "}", "</s>" ]

[ "Canonicalize", "vec_perm", "index", "to", "make", "the", "first", "index", "always", "comes", "from", "the", "first", "vector", "." ]

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

[]

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

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

[ "LEG", "LEG", "LEG" ]

[]

[ "<s>", "void", "AGCInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "MII", ".", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "AGCII", "::", "IsExtracode", ")", "O", "<<", "\"\\t\"", "<<", "\"extend\"", "<<", "\"\\n\"", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "AGCII::IsExtracode", "\"\\t\"", "\"extend\"", "\"\\n\"" ]

[]

[ "<s>", "static", "unsigned", "int", "mn10300_case_values_threshold", "(", "void", ")", "{", "return", "6", ";", "}", "</s>" ]

[ "Dispatch", "tables", "on", "the", "mn10300", "are", "extremely", "expensive", "in", "terms", "of", "code", "and", "readonly", "data", "size", ".", "So", "we", "crank", "up", "the", "case", "threshold", "value", "to", "encourage", "a", "series", "of", "if/else", "comparisons", "to", "implement", "many", "small", "switch", "statements", ".", "In", "theory", ",", "this", "value", "could", "be", "increased", "much", "more", "if", "we", "were", "solely", "optimizing", "for", "space", ",", "but", "we", "keep", "it", "``", "reasonable", "''", "to", "avoid", "serious", "code", "efficiency", "lossage", "." ]

[ "mn10300", "6" ]

[]

[ "<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", ")", ",", "HasAVX", "(", "false", ")", ",", "HasAVX2", "(", "false", ")", ",", "HasAES", "(", "false", ")", ",", "HasCLMUL", "(", "false", ")", ",", "HasFMA3", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "HasMOVBE", "(", "false", ")", ",", "HasRDRAND", "(", "false", ")", ",", "HasF16C", "(", "false", ")", ",", "HasFSGSBase", "(", "false", ")", ",", "HasLZCNT", "(", "false", ")", ",", "HasBMI", "(", "false", ")", ",", "HasBMI2", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "IsUAMemFast", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "HasCmpxchg16b", "(", "false", ")", ",", "stackAlignment", "(", "8", ")", ",", "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", "(", "!", "HasAVX", "&&", "X86SSELevel", "<", "SSE2", ")", "{", "X86SSELevel", "=", "SSE2", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE1", ")", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE2", ")", ";", "}", "}", "}", "if", "(", "In64BitMode", ")", "ToggleFeature", "(", "X86", "::", "Mode64Bit", ")", ";", "if", "(", "HasAVX", ")", "X86SSELevel", "=", "NoMMXSSE", ";", "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", "(", "EnableSegmentedStacks", "&&", "!", "isTargetELF", "(", ")", ")", "report_fatal_error", "(", "\"Segmented stacks are only implemented on ELF.\"", ")", ";", "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", "8", "128", "\"generic\"", "\"+64bit,+sse2,\"", "\"+64bit,+sse2\"", "X86", "X86::Feature64Bit", "X86::FeatureCMOV", "X86", "X86", "X86::FeatureSSE1", "X86::FeatureSSE2", "X86::Mode64Bit", "X86", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "\"Segmented stacks are only implemented on ELF.\"", "16" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUInstrInfo", "::", "expandPostRAPseudo", "(", "MI", ")", ";", "case", "AMDGPU", "::", "SI_CONSTDATA_PTR", ":", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "RegLo", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "RegHi", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub1", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_GETPC_B64", ")", ",", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADD_I32", ")", ",", "RegLo", ")", ".", "addReg", "(", "RegLo", ")", ".", "addTargetIndex", "(", "AMDGPU", "::", "TI_CONSTDATA_START", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADDC_U32", ")", ",", "RegHi", ")", ".", "addReg", "(", "RegHi", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Implicit", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI", "0", "0" ]

[]

[ "<s>", "bool", "ARCBranchFinalize", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running ARC Branch Finalize on \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Branches", ";", "bool", "Changed", "=", "false", ";", "unsigned", "MaxSize", "=", "0", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "std", "::", "map", "<", "MachineBasicBlock", "*", ",", "unsigned", ">", "BlockToPCMap", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "MachineInstr", "*", ",", "unsigned", ">>", "BranchToPCList", ";", "unsigned", "PC", "=", "0", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "BlockToPCMap", ".", "insert", "(", "std", "::", "make_pair", "(", "&", "MBB", ",", "PC", ")", ")", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "unsigned", "Size", "=", "TII", "->", "getInstSizeInBytes", "(", "MI", ")", ";", "if", "(", "Size", ">", "8", "||", "Size", "==", "0", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unknown (or size 0) size for: \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "}", "else", "{", "MaxSize", "+=", "Size", ";", "}", "if", "(", "MI", ".", "isBranch", "(", ")", ")", "{", "Branches", ".", "push_back", "(", "&", "MI", ")", ";", "BranchToPCList", ".", "emplace_back", "(", "&", "MI", ",", "PC", ")", ";", "}", "PC", "+=", "Size", ";", "}", "}", "for", "(", "auto", "P", ":", "BranchToPCList", ")", "{", "if", "(", "isBRccPseudo", "(", "P", ".", "first", ")", ")", "isInt", "<", "9", ">", "(", "MaxSize", ")", "?", "replaceWithBRcc", "(", "P", ".", "first", ")", ":", "replaceWithCmpBcc", "(", "P", ".", "first", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Estimated function size for \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\": \"", "<<", "MaxSize", "<<", "\"\\n\"", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Running ARC Branch Finalize on \"", "\"\\n\"", "0", "ARC", "0", "8", "0", "\"Unknown (or size 0) size for: \"", "\"\\n\"", "9", "\"Estimated function size for \"", "\": \"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "GCNHazardRecognizer", "::", "PreEmitNoops", "(", "MachineInstr", "*", "MI", ")", "{", "int", "WaitStates", "=", "std", "::", "max", "(", "0", ",", "checkAnyInstHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkSMRDHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", ")", "{", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkVALUHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkVMEMHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkDPPHazards", "(", "MI", ")", ")", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkDivFMasHazards", "(", "MI", ")", ")", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkRWLaneHazards", "(", "MI", ")", ")", ";", "if", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkReadM0Hazards", "(", "MI", ")", ")", ";", "return", "WaitStates", ";", "}", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkGetRegHazards", "(", "MI", ")", ")", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkSetRegHazards", "(", "MI", ")", ")", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkRFEHazards", "(", "MI", ")", ")", ";", "if", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkReadM0Hazards", "(", "MI", ")", ")", ";", "return", "WaitStates", ";", "}", "</s>" ]

[ "PreEmitNoops", "-", "This", "callback", "is", "invoked", "prior", "to", "emitting", "an", "instruction", "." ]

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

[]

[ "<s>", "static", "void", "s390_cpu_cpp_builtins_internal", "(", "cpp_reader", "*", "pfile", ",", "struct", "cl_target_option", "*", "opts", ",", "const", "struct", "cl_target_option", "*", "old_opts", ")", "{", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_OPT_HTM", ",", "old_opts", ",", "opts", ",", "\"__HTM__\"", ",", "\"__HTM__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"__VEC__=10301\"", ",", "\"__VEC__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"__vector=__attribute__((vector_size(16)))\"", ",", "\"__vector__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"__bool=__attribute__((s390_vector_bool)) unsigned\"", ",", "\"__bool\"", ")", ";", "if", "(", "!", "flag_iso", ")", "{", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"__VECTOR_KEYWORD_SUPPORTED__\"", ",", "\"__VECTOR_KEYWORD_SUPPORTED__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"vector=vector\"", ",", "\"vector\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"bool=bool\"", ",", "\"bool\"", ")", ";", "if", "(", "TARGET_ZVECTOR_P", "(", "opts", "->", "x_target_flags", ")", "&&", "__vector_keyword", "==", "NULL", ")", "{", "__vector_keyword", "=", "get_identifier", "(", "\"__vector\"", ")", ";", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "vector_keyword", "=", "get_identifier", "(", "\"vector\"", ")", ";", "C_CPP_HASHNODE", "(", "vector_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "__bool_keyword", "=", "get_identifier", "(", "\"__bool\"", ")", ";", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "bool_keyword", "=", "get_identifier", "(", "\"bool\"", ")", ";", "C_CPP_HASHNODE", "(", "bool_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "_Bool_keyword", "=", "get_identifier", "(", "\"_Bool\"", ")", ";", "C_CPP_HASHNODE", "(", "_Bool_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "cpp_get_callbacks", "(", "pfile", ")", "->", "macro_to_expand", "=", "s390_macro_to_expand", ";", "}", "}", "}", "</s>" ]

[ "Internal", "function", "to", "either", "define", "or", "undef", "the", "appropriate", "system", "macros", "." ]

[ "s390", "\"__HTM__\"", "\"__HTM__\"", "\"__VEC__=10301\"", "\"__VEC__\"", "\"__vector=__attribute__((vector_size(16)))\"", "\"__vector__\"", "\"__bool=__attribute__((s390_vector_bool)) unsigned\"", "\"__bool\"", "\"__VECTOR_KEYWORD_SUPPORTED__\"", "\"__VECTOR_KEYWORD_SUPPORTED__\"", "\"vector=vector\"", "\"vector\"", "\"bool=bool\"", "\"bool\"", "\"__vector\"", "\"vector\"", "\"__bool\"", "\"bool\"", "\"_Bool\"" ]

[]

[ "<s>", "MVT", "SITargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "CC", "!=", "CallingConv", "::", "AMDGPU_KERNEL", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Size", "=", "ScalarVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "32", ")", "return", "ScalarVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "Size", "==", "64", ")", "return", "MVT", "::", "i32", ";", "if", "(", "Size", "==", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", "&&", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", ")", "return", "VT", ".", "isInteger", "(", ")", "?", "MVT", "::", "v2i16", ":", "MVT", "::", "v2f16", ";", "}", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "32", "64", "MVT::i32", "16", "MVT::v2i16", "MVT::v2f16" ]

[]

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

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

[ "MMIX", "\"MMIX Assembly Printer\"" ]

[]

[ "<s>", "static", "int", "pru_arg_partial_bytes", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", ")", "{", "return", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ARG_PARTIAL_BYTES", ".", "PRU", "never", "splits", "any", "arguments", "between", "registers", "and", "memory", ",", "so", "we", "can", "return", "0", "." ]

[ "pru", "0" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "bool", "IsN64", "=", "Subtarget", ".", "isABI_N64", "(", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Mips", "::", "S0", ":", "Mips", "::", "SP", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "IsN64", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ")", ":", "(", "IsN64", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips::S0", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::SP_64", "Mips::SP" ]

[]

[ "<s>", "static", "void", "cris_option_override", "(", "void", ")", "{", "if", "(", "cris_max_stackframe_str", ")", "{", "cris_max_stackframe", "=", "atoi", "(", "cris_max_stackframe_str", ")", ";", "if", "(", "cris_max_stackframe", "<", "0", "||", "cris_max_stackframe", ">", "0x20000000", ")", "internal_error", "(", "\"%<-max-stackframe=%d%> is not usable, \"", "\"not between 0 and %d\"", ",", "cris_max_stackframe", ",", "0x20000000", ")", ";", "}", "if", "(", "TARGET_SVINTO", "&&", "cris_cpu_version", "<", "CRIS_CPU_SVINTO", ")", "cris_cpu_version", "=", "CRIS_CPU_SVINTO", ";", "else", "if", "(", "TARGET_ETRAX4_ADD", "&&", "cris_cpu_version", "<", "CRIS_CPU_ETRAX4", ")", "cris_cpu_version", "=", "CRIS_CPU_ETRAX4", ";", "if", "(", "cris_cpu_str", ")", "{", "cris_cpu_version", "=", "(", "*", "cris_cpu_str", "==", "'v'", "?", "atoi", "(", "cris_cpu_str", "+", "1", ")", ":", "-", "1", ")", ";", "if", "(", "strcmp", "(", "\"etrax4\"", ",", "cris_cpu_str", ")", "==", "0", ")", "cris_cpu_version", "=", "3", ";", "if", "(", "strcmp", "(", "\"svinto\"", ",", "cris_cpu_str", ")", "==", "0", "||", "strcmp", "(", "\"etrax100\"", ",", "cris_cpu_str", ")", "==", "0", ")", "cris_cpu_version", "=", "8", ";", "if", "(", "strcmp", "(", "\"ng\"", ",", "cris_cpu_str", ")", "==", "0", "||", "strcmp", "(", "\"etrax100lx\"", ",", "cris_cpu_str", ")", "==", "0", ")", "cris_cpu_version", "=", "10", ";", "if", "(", "cris_cpu_version", "<", "0", "||", "cris_cpu_version", ">", "10", ")", "error", "(", "\"unknown CRIS version specification in %<-march=%> or \"", "\"%<-mcpu=%>: %s\"", ",", "cris_cpu_str", ")", ";", "if", "(", "cris_cpu_version", ">=", "CRIS_CPU_ETRAX4", ")", "target_flags", "|=", "MASK_ETRAX4_ADD", ";", "if", "(", "cris_cpu_version", ">=", "CRIS_CPU_SVINTO", ")", "target_flags", "|=", "(", "MASK_SVINTO", "|", "MASK_ALIGN_BY_32", "|", "MASK_STACK_ALIGN", "|", "MASK_CONST_ALIGN", "|", "MASK_DATA_ALIGN", ")", ";", "}", "if", "(", "cris_tune_str", ")", "{", "int", "cris_tune", "=", "(", "*", "cris_tune_str", "==", "'v'", "?", "atoi", "(", "cris_tune_str", "+", "1", ")", ":", "-", "1", ")", ";", "if", "(", "strcmp", "(", "\"etrax4\"", ",", "cris_tune_str", ")", "==", "0", ")", "cris_tune", "=", "3", ";", "if", "(", "strcmp", "(", "\"svinto\"", ",", "cris_tune_str", ")", "==", "0", "||", "strcmp", "(", "\"etrax100\"", ",", "cris_tune_str", ")", "==", "0", ")", "cris_tune", "=", "8", ";", "if", "(", "strcmp", "(", "\"ng\"", ",", "cris_tune_str", ")", "==", "0", "||", "strcmp", "(", "\"etrax100lx\"", ",", "cris_tune_str", ")", "==", "0", ")", "cris_tune", "=", "10", ";", "if", "(", "cris_tune", "<", "0", "||", "cris_tune", ">", "32", ")", "error", "(", "\"unknown CRIS cpu version specification in %<-mtune=%>: %s\"", ",", "cris_tune_str", ")", ";", "if", "(", "cris_tune", ">=", "CRIS_CPU_SVINTO", ")", "target_flags", "|=", "(", "MASK_STACK_ALIGN", "|", "MASK_CONST_ALIGN", "|", "MASK_DATA_ALIGN", "|", "MASK_ALIGN_BY_32", ")", ";", "}", "if", "(", "flag_pic", ")", "{", "error", "(", "\"%<-fPIC%> and %<-fpic%> are not supported on this target\"", ")", ";", "flag_pic", "=", "0", ";", "}", "init_machine_status", "=", "cris_init_machine_status", ";", "}", "</s>" ]

[ "The", "TARGET_OPTION_OVERRIDE", "worker", ".", "As", "is", "the", "norm", ",", "this", "also", "parses", "-mfoo=bar", "type", "parameters", "." ]

[ "cris", "0", "0x20000000", "\"%<-max-stackframe=%d%> is not usable, \"", "\"not between 0 and %d\"", "0x20000000", "1", "1", "\"etrax4\"", "0", "3", "\"svinto\"", "0", "\"etrax100\"", "0", "8", "\"ng\"", "0", "\"etrax100lx\"", "0", "10", "0", "10", "\"unknown CRIS version specification in %<-march=%> or \"", "\"%<-mcpu=%>: %s\"", "1", "1", "\"etrax4\"", "0", "3", "\"svinto\"", "0", "\"etrax100\"", "0", "8", "\"ng\"", "0", "\"etrax100lx\"", "0", "10", "0", "32", "\"unknown CRIS cpu version specification in %<-mtune=%>: %s\"", "\"%<-fPIC%> and %<-fpic%> are not supported on this target\"", "0" ]

[]

[ "<s>", "static", "void", "expand_block_move_4", "(", "rtx", "dst", ",", "rtx", "dst_reg", ",", "rtx", "src", ",", "rtx", "src_reg", ",", "rtx", "bytes_rtx", ")", "{", "const", "rtx", "sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__long_int_memcpy\"", ")", ";", "unsigned", "HOST_WIDE_INT", "bytes", "=", "UINTVAL", "(", "bytes_rtx", ")", ";", "unsigned", "int", "rem", "=", "bytes", "%", "4", ";", "if", "(", "TARGET_BMI", ")", "{", "unsigned", "int", "i", ";", "rtx", "insn", ";", "emit_move_insn", "(", "regno_reg_rtx", "[", "1", "]", ",", "dst_reg", ")", ";", "emit_move_insn", "(", "regno_reg_rtx", "[", "2", "]", ",", "src_reg", ")", ";", "emit_move_insn", "(", "regno_reg_rtx", "[", "3", "]", ",", "bytes_rtx", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "8", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "replace_equiv_address_nv", "(", "dst", ",", "regno_reg_rtx", "[", "1", "]", ")", ",", "replace_equiv_address_nv", "(", "src", ",", "regno_reg_rtx", "[", "2", "]", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "1", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "regno_reg_rtx", "[", "3", "]", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "6", ";", "i", "++", ")", "XVECEXP", "(", "insn", ",", "0", ",", "1", "+", "i", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "regno_reg_rtx", "[", "i", "]", ")", ";", "emit_insn", "(", "insn", ")", ";", "}", "else", "emit_library_call", "(", "sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "dst_reg", ",", "Pmode", ",", "src_reg", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "GEN_INT", "(", "bytes", ">>", "2", ")", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "if", "(", "rem", "==", "0", ")", "return", ";", "dst", "=", "replace_equiv_address_nv", "(", "dst", ",", "dst_reg", ")", ";", "src", "=", "replace_equiv_address_nv", "(", "src", ",", "src_reg", ")", ";", "bytes", "-=", "rem", ";", "if", "(", "rem", ">", "1", ")", "{", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "HImode", ",", "bytes", ")", ",", "adjust_address_nv", "(", "src", ",", "HImode", ",", "bytes", ")", ")", ";", "bytes", "+=", "2", ";", "rem", "-=", "2", ";", "}", "if", "(", "rem", ">", "0", ")", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "adjust_address_nv", "(", "src", ",", "QImode", ",", "bytes", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "move", "BYTES_RTX", "bytes", "from", "SRC", "with", "address", "SRC_REG", "to", "DST", "with", "address", "DST_REG", "in", "4-byte", "chunks", "." ]

[ "visium", "\"__long_int_memcpy\"", "4", "1", "2", "3", "8", "0", "0", "1", "2", "0", "1", "3", "1", "6", "0", "1", "3", "2", "0", "1", "2", "2", "0" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "findUnusedRegister", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "for", "(", "unsigned", "Reg", ":", "*", "RC", ")", "if", "(", "MRI", ".", "isAllocatable", "(", "Reg", ")", "&&", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "return", "Reg", ";", "return", "AMDGPU", "::", "NoRegister", ";", "}", "</s>" ]

[ "Returns", "a", "lowest", "register", "that", "is", "not", "used", "at", "any", "point", "in", "the", "function", "." ]

[ "AMDGPU", "SI", "AMDGPU::NoRegister" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "bool", "IsN64", "=", "Subtarget", ".", "isABI_N64", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "IsN64", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ")", ":", "(", "IsN64", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::FP_64", "Mips::FP", "Mips::SP_64", "Mips::SP" ]

[]

[ "<s>", "int", "frv_adjust_field_align", "(", "tree", "field", ",", "int", "computed", ")", "{", "if", "(", "field", "&&", "DECL_BIT_FIELD", "(", "field", ")", "&&", "!", "DECL_ARTIFICIAL", "(", "field", ")", ")", "{", "tree", "parent", "=", "DECL_CONTEXT", "(", "field", ")", ";", "tree", "prev", "=", "NULL_TREE", ";", "tree", "cur", ";", "for", "(", "cur", "=", "TYPE_FIELDS", "(", "parent", ")", ";", "cur", "&&", "cur", "!=", "field", ";", "cur", "=", "DECL_CHAIN", "(", "cur", ")", ")", "{", "if", "(", "TREE_CODE", "(", "cur", ")", "!=", "FIELD_DECL", ")", "continue", ";", "prev", "=", "cur", ";", "}", "gcc_assert", "(", "cur", ")", ";", "if", "(", "prev", "&&", "!", "DECL_PACKED", "(", "field", ")", "&&", "!", "integer_zerop", "(", "DECL_SIZE", "(", "field", ")", ")", "&&", "DECL_BIT_FIELD_TYPE", "(", "field", ")", "!=", "DECL_BIT_FIELD_TYPE", "(", "prev", ")", ")", "{", "int", "prev_align", "=", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "prev", ")", ")", ";", "int", "cur_align", "=", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "field", ")", ")", ";", "computed", "=", "(", "prev_align", ">", "cur_align", ")", "?", "prev_align", ":", "cur_align", ";", "}", "}", "return", "computed", ";", "}", "</s>" ]

[ "The", "definition", "type", "of", "the", "bit", "field", "data", "is", "either", "char", ",", "short", ",", "long", "or", "long", "long", ".", "The", "maximum", "bit", "size", "is", "the", "number", "of", "bits", "of", "its", "own", "type", ".", "The", "bit", "field", "data", "is", "assigned", "to", "a", "storage", "unit", "that", "has", "an", "adequate", "size", "for", "bit", "field", "data", "retention", "and", "is", "located", "at", "the", "smallest", "address", ".", "Consecutive", "bit", "field", "data", "are", "packed", "at", "consecutive", "bits", "having", "the", "same", "storage", "unit", ",", "with", "regard", "to", "the", "type", ",", "beginning", "with", "the", "MSB", "and", "continuing", "toward", "the", "LSB", ".", "If", "a", "field", "to", "be", "assigned", "lies", "over", "a", "bit", "field", "type", "boundary", ",", "its", "assignment", "is", "completed", "by", "aligning", "it", "with", "a", "boundary", "suitable", "for", "the", "type", ".", "When", "a", "bit", "field", "having", "a", "bit", "length", "of", "0", "is", "declared", ",", "it", "is", "forcibly", "assigned", "to", "the", "next", "storage", "unit", ".", "e.g", ")", "struct", "{", "int", "a:2", ";", "int", "b:6", ";", "char", "c:4", ";", "int", "d:10", ";", "int", ":0", ";", "int", "f:2", ";", "}", "x", ";", "+0", "+1", "+2", "+3", "&", "x", "00000000", "00000000", "00000000", "00000000", "MLM", "--", "--", "L", "a", "b", "&", "x+4", "00000000", "00000000", "00000000", "00000000", "M", "--", "L", "c", "&", "x+8", "00000000", "00000000", "00000000", "00000000", "M", "--", "--", "--", "--", "--", "L", "d", "&", "x+12", "00000000", "00000000", "00000000", "00000000", "ML", "f" ]

[ "frv" ]

[]

[ "<s>", "static", "void", "nvptx_assemble_undefined_decl", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const_tree", "decl", ")", "{", "if", "(", "DECL_IN_CONSTANT_POOL", "(", "decl", ")", ")", "return", ";", "if", "(", "DECL_WEAK", "(", "decl", ")", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"PTX does not support weak declarations\"", "\" (only weak definitions)\"", ")", ";", "write_var_marker", "(", "file", ",", "false", ",", "TREE_PUBLIC", "(", "decl", ")", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.extern \"", ")", ";", "tree", "size", "=", "DECL_SIZE_UNIT", "(", "decl", ")", ";", "nvptx_assemble_decl_begin", "(", "file", ",", "name", ",", "section_for_decl", "(", "decl", ")", ",", "TREE_TYPE", "(", "decl", ")", ",", "size", "?", "tree_to_shwi", "(", "size", ")", ":", "0", ",", "DECL_ALIGN", "(", "decl", ")", ",", "true", ")", ";", "nvptx_assemble_decl_end", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_ASSEMBLE_UNDEFINED_DECL", ".", "Write", "an", "extern", "declaration", "only", "for", "variable", "DECL", "with", "NAME", "to", "FILE", "." ]

[ "nvptx", "\"PTX does not support weak declarations\"", "\" (only weak definitions)\"", "\"\\t.extern \"", "0" ]

[]

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

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

[ "CAHP", "CAHP" ]

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "unsigned", "ClassID", ")", "const", "{", "bool", "Vector", "=", "(", "ClassID", "==", "1", ")", ";", "if", "(", "Vector", ")", "{", "if", "(", "ST", "->", "hasVInstructions", "(", ")", ")", "return", "32", ";", "return", "0", ";", "}", "return", "31", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "RISCV", "1", "32", "0", "31" ]

[]

[ "<s>", "bool", "SIInsertWaits", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changes", "=", "false", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "WaitedOn", "=", "ZeroCounts", ";", "LastIssued", "=", "ZeroCounts", ";", "memset", "(", "&", "UsedRegs", ",", "0", ",", "sizeof", "(", "UsedRegs", ")", ")", ";", "memset", "(", "&", "DefinedRegs", ",", "0", ",", "sizeof", "(", "DefinedRegs", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "handleOperands", "(", "*", "I", ")", ")", ";", "pushInstruction", "(", "*", "I", ")", ";", "}", "Changes", "|=", "insertWait", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ",", "LastIssued", ")", ";", "}", "return", "Changes", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "0", "0" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "CallingConv", "::", "ID", "CallConv", ",", "const", "MachineOperand", "&", "Callee", ",", "const", "ArgInfo", "&", "OrigRet", ",", "ArrayRef", "<", "ArgInfo", ">", "OrigArgs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "const", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "genLongCalls", "(", ")", ")", "return", "false", ";", "auto", "CallSeqStart", "=", "MIRBuilder", ".", "buildInstr", "(", "ARM", "::", "ADJCALLSTACKDOWN", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "ARM", "::", "BLX", ")", ".", "add", "(", "Callee", ")", ".", "addRegMask", "(", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallConv", ")", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "for", "(", "auto", "Arg", ":", "OrigArgs", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "Ty", ")", ")", "return", "false", ";", "if", "(", "!", "Arg", ".", "IsFixed", ")", "return", "false", ";", "splitToValueTypes", "(", "Arg", ",", "ArgInfos", ",", "DL", ",", "MRI", ")", ";", "}", "auto", "ArgAssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "CallConv", ",", "false", ")", ";", "OutgoingValueHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "ArgAssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "if", "(", "!", "OrigRet", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "OrigRet", ".", "Ty", ")", ")", "return", "false", ";", "ArgInfos", ".", "clear", "(", ")", ";", "splitToValueTypes", "(", "OrigRet", ",", "ArgInfos", ",", "DL", ",", "MRI", ")", ";", "auto", "RetAssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "CallConv", ",", "false", ")", ";", "CallReturnHandler", "RetHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetAssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "RetHandler", ")", ")", "return", "false", ";", "}", "CallSeqStart", ".", "addImm", "(", "ArgHandler", ".", "StackSize", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "ARM", "::", "ADJCALLSTACKUP", ")", ".", "addImm", "(", "ArgHandler", ".", "StackSize", ")", ".", "addImm", "(", "0", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::ADJCALLSTACKDOWN", "ARM::BLX", "8", "ARMCC::AL", "ARM::ADJCALLSTACKUP", "0", "ARMCC::AL" ]

[]

[ "<s>", "BitVector", "HSAILRegisterInfo", "::", "getRegsAvailable", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "BitVector", "Mask", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "E", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Mask", ".", "set", "(", "*", "I", ")", ";", "return", "Mask", ";", "}", "</s>" ]

[ "Return", "all", "available", "registers", "in", "the", "register", "class", "in", "Mask", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "int", "byte_immediate_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op", ")", "<=", "0xff", "&&", "INTVAL", "(", "op", ")", ">=", "0", ")", ";", "}", "</s>" ]

[ "Predicate", "function", "for", "immediate", "operand", "which", "fits", "to", "byte", "(", "8bit", ")" ]

[ "avr", "0xff", "0" ]

[]

[ "<s>", "static", "bool", "save_reg_p", "(", "int", "reg", ")", "{", "if", "(", "reg", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "!", "TARGET_SINGLE_PIC_BASE", ")", "{", "if", "(", "crtl", "->", "calls_eh_return", "&&", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "||", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", ")", ")", "return", "true", ";", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", "&&", "!", "constant_pool_empty_p", "(", ")", ")", "return", "true", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "flag_pic", "==", "1", "||", "(", "flag_pic", "&&", "TARGET_SECURE_PLT", ")", ")", "&&", "df_regs_ever_live_p", "(", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ")", "return", "true", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", "&&", "crtl", "->", "uses_pic_offset_table", ")", "return", "true", ";", "}", "return", "!", "call_used_regs", "[", "reg", "]", "&&", "df_regs_ever_live_p", "(", "reg", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "the", "REG", "is", "really", "used", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "static", "rtx", "rs6000_internal_arg_pointer", "(", "void", ")", "{", "if", "(", "flag_split_stack", "&&", "(", "lookup_attribute", "(", "\"no_split_stack\"", ",", "DECL_ATTRIBUTES", "(", "cfun", "->", "decl", ")", ")", "==", "NULL", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "==", "NULL_RTX", ")", "{", "rtx", "pat", ";", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "REG_POINTER", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "=", "1", ";", "pat", "=", "gen_rtx_SET", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ")", ";", "push_topmost_sequence", "(", ")", ";", "emit_insn_after", "(", "pat", ",", "get_insns", "(", ")", ")", ";", "pop_topmost_sequence", "(", ")", ";", "}", "return", "plus_constant", "(", "Pmode", ",", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "FIRST_PARM_OFFSET", "(", "current_function_decl", ")", ")", ";", "}", "return", "virtual_incoming_args_rtx", ";", "}", "</s>" ]

[ "Return", "the", "internal", "arg", "pointer", "used", "for", "function", "incoming", "arguments", ".", "When", "-fsplit-stack", ",", "the", "arg", "pointer", "is", "r12", "so", "we", "need", "to", "copy", "it", "to", "a", "pseudo", "in", "order", "for", "it", "to", "be", "preserved", "over", "calls", "and", "suchlike", ".", "We", "'d", "really", "like", "to", "use", "a", "pseudo", "here", "for", "the", "internal", "arg", "pointer", "but", "data-flow", "analysis", "is", "not", "prepared", "to", "accept", "pseudos", "as", "live", "at", "the", "beginning", "of", "a", "function", "." ]

[ "powerpcspe", "\"no_split_stack\"", "1", "12" ]

[]

[ "<s>", "static", "unsigned", "selectBinaryOp", "(", "unsigned", "GenericOpc", ",", "unsigned", "RegBankID", ",", "unsigned", "OpSize", ")", "{", "switch", "(", "RegBankID", ")", "{", "case", "AArch64", "::", "GPRRegBankID", ":", "if", "(", "OpSize", "<=", "32", ")", "{", "assert", "(", "(", "OpSize", "==", "32", "||", "(", "GenericOpc", "!=", "TargetOpcode", "::", "G_SDIV", "&&", "GenericOpc", "!=", "TargetOpcode", "::", "G_UDIV", "&&", "GenericOpc", "!=", "TargetOpcode", "::", "G_LSHR", "&&", "GenericOpc", "!=", "TargetOpcode", "::", "G_ASHR", ")", ")", "&&", "\"operation should have been legalized before now\"", ")", ";", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_OR", ":", "return", "AArch64", "::", "ORRWrr", ";", "case", "TargetOpcode", "::", "G_XOR", ":", "return", "AArch64", "::", "EORWrr", ";", "case", "TargetOpcode", "::", "G_AND", ":", "return", "AArch64", "::", "ANDWrr", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "assert", "(", "OpSize", "!=", "32", "&&", "\"s32 G_ADD should have been selected\"", ")", ";", "return", "AArch64", "::", "ADDWrr", ";", "case", "TargetOpcode", "::", "G_SUB", ":", "return", "AArch64", "::", "SUBWrr", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVWr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVWr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVWr", ";", "case", "TargetOpcode", "::", "G_SDIV", ":", "return", "AArch64", "::", "SDIVWr", ";", "case", "TargetOpcode", "::", "G_UDIV", ":", "return", "AArch64", "::", "UDIVWr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "else", "if", "(", "OpSize", "==", "64", ")", "{", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_OR", ":", "return", "AArch64", "::", "ORRXrr", ";", "case", "TargetOpcode", "::", "G_XOR", ":", "return", "AArch64", "::", "EORXrr", ";", "case", "TargetOpcode", "::", "G_AND", ":", "return", "AArch64", "::", "ANDXrr", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "AArch64", "::", "ADDXrr", ";", "case", "TargetOpcode", "::", "G_SUB", ":", "return", "AArch64", "::", "SUBXrr", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVXr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVXr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVXr", ";", "case", "TargetOpcode", "::", "G_SDIV", ":", "return", "AArch64", "::", "SDIVXr", ";", "case", "TargetOpcode", "::", "G_UDIV", ":", "return", "AArch64", "::", "UDIVXr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "case", "AArch64", "::", "FPRRegBankID", ":", "switch", "(", "OpSize", ")", "{", "case", "32", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDSrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBSrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULSrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVSrr", ";", "default", ":", "return", "GenericOpc", ";", "}", "case", "64", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDDrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBDrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULDrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVDrr", ";", "case", "TargetOpcode", "::", "G_OR", ":", "return", "AArch64", "::", "ORRv8i8", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "}", ";", "return", "GenericOpc", ";", "}", "</s>" ]

[ "Select", "and", "emit", "code", "for", "a", "binary", "operator", "instruction", ",", "which", "has", "an", "opcode", "which", "directly", "corresponds", "to", "the", "given", "ISD", "opcode", "." ]

[ "AArch64", "AArch64::GPRRegBankID", "32", "32", "\"operation should have been legalized before now\"", "AArch64::ORRWrr", "AArch64::EORWrr", "AArch64::ANDWrr", "32", "\"s32 G_ADD should have been selected\"", "AArch64::ADDWrr", "AArch64::SUBWrr", "AArch64::LSLVWr", "AArch64::LSRVWr", "AArch64::ASRVWr", "AArch64::SDIVWr", "AArch64::UDIVWr", "64", "AArch64::ORRXrr", "AArch64::EORXrr", "AArch64::ANDXrr", "AArch64::ADDXrr", "AArch64::SUBXrr", "AArch64::LSLVXr", "AArch64::LSRVXr", "AArch64::ASRVXr", "AArch64::SDIVXr", "AArch64::UDIVXr", "AArch64::FPRRegBankID", "32", "AArch64::FADDSrr", "AArch64::FSUBSrr", "AArch64::FMULSrr", "AArch64::FDIVSrr", "64", "AArch64::FADDDrr", "AArch64::FSUBDrr", "AArch64::FMULDrr", "AArch64::FDIVDrr", "AArch64::ORRv8i8" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Register", "&&", "!", "Reg", ".", "isVector", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "ARM64" ]

[]

[ "<s>", "static", "machine_mode", "frv_matching_accg_mode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V4SImode", ":", "return", "V4QImode", ";", "case", "E_DImode", ":", "return", "HImode", ";", "case", "E_SImode", ":", "return", "QImode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "If", "an", "ACC", "rtx", "has", "mode", "MODE", ",", "return", "the", "mode", "that", "the", "matching", "ACCG", "should", "have", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "AMDGPUMachineCFGStructurizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "(", "MF", ".", "getRegInfo", "(", ")", ")", ";", "initFallthroughMap", "(", "MF", ")", ";", "checkRegOnlyPHIInputs", "(", "MF", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"----STRUCTURIZER START----\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "Regions", "=", "&", "(", "getAnalysis", "<", "MachineRegionInfoPass", ">", "(", ")", ".", "getRegionInfo", "(", ")", ")", ";", "LLVM_DEBUG", "(", "Regions", "->", "dump", "(", ")", ")", ";", "RegionMRT", "*", "RTree", "=", "MRT", "::", "buildMRT", "(", "MF", ",", "Regions", ",", "TII", ",", "MRI", ")", ";", "setRegionMRT", "(", "RTree", ")", ";", "initializeSelectRegisters", "(", "RTree", ",", "0", ",", "MRI", ",", "TII", ")", ";", "LLVM_DEBUG", "(", "RTree", "->", "dump", "(", "TRI", ")", ")", ";", "bool", "result", "=", "structurizeRegions", "(", "RTree", ",", "true", ")", ";", "delete", "RTree", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"----STRUCTURIZER END----\\n\"", ")", ";", "initFallthroughMap", "(", "MF", ")", ";", "return", "result", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "\"----STRUCTURIZER START----\\n\"", "0", "\"----STRUCTURIZER END----\\n\"" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "Sparc" ]

[]

[ "<s>", "void", "h8300_expand_branch", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "label", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_COMPARE", "(", "VOIDmode", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cc0_rtx", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cc0_rtx", ",", "const0_rtx", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "tmp", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "conditional", "branch", "." ]

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

[]

[ "<s>", "bool", "TypedPointerType", "::", "isValidElementType", "(", "Type", "*", "ElemTy", ")", "{", "return", "!", "ElemTy", "->", "isVoidTy", "(", ")", "&&", "!", "ElemTy", "->", "isLabelTy", "(", ")", "&&", "!", "ElemTy", "->", "isMetadataTy", "(", ")", "&&", "!", "ElemTy", "->", "isTokenTy", "(", ")", "&&", "!", "ElemTy", "->", "isX86_AMXTy", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "type", "is", "valid", "as", "a", "element", "type", "." ]

[ "DirectX" ]

[]

[ "<s>", "void", "SparcPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSparcDelaySlotFillerPass", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "emit_load_locked", "(", "machine_mode", "mode", ",", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "mode", "==", "SImode", ")", "fn", "=", "gen_load_locked_si", ";", "else", "if", "(", "mode", "==", "DImode", ")", "fn", "=", "gen_load_locked_di", ";", "emit_insn", "(", "fn", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "load-locked", "instruction", "in", "MODE", ".", "For", "QI/HImode", ",", "possibly", "use", "a", "pattern", "than", "includes", "the", "zero_extend", "operation", "." ]

[ "alpha" ]

[]

[ "<s>", "static", "unsigned", "arm_add_stmt_cost", "(", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "unsigned", "*", "cost", "=", "(", "unsigned", "*", ")", "data", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "tree", "vectype", "=", "stmt_info", "?", "stmt_vectype", "(", "stmt_info", ")", ":", "NULL_TREE", ";", "int", "stmt_cost", "=", "arm_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "stmt_info", ")", ")", "count", "*=", "50", ";", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "cost", "[", "where", "]", "+=", "retval", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.add_stmt_cost", "." ]

[ "arm", "0", "50" ]

[]

[ "<s>", "void", "ARMCallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "nullptr", ",", "nullptr", ",", "0", ")", ";", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", "&&", "\"Regs / types mismatch\"", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "auto", "Flags", "=", "OrigArg", ".", "Flags", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "OrigArg", ".", "Ty", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "0", "]", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "EVT", "SplitVT", "=", "SplitVTs", "[", "i", "]", ";", "Type", "*", "SplitTy", "=", "SplitVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "auto", "Flags", "=", "OrigArg", ".", "Flags", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "SplitTy", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "bool", "NeedsConsecutiveRegisters", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "SplitTy", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "if", "(", "NeedsConsecutiveRegisters", ")", "{", "Flags", ".", "setInConsecutiveRegs", "(", ")", ";", "if", "(", "i", "==", "e", "-", "1", ")", "Flags", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}", "Register", "PartReg", "=", "OrigArg", ".", "Regs", "[", "i", "]", ";", "SplitArgs", ".", "emplace_back", "(", "PartReg", ",", "SplitTy", ",", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "4", "0", "\"Regs / types mismatch\"", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "MachineBasicBlock", "*", "getHeader", "(", ")", "const", "override", "{", "return", "Region", "->", "getHeader", "(", ")", ";", "}", "</s>" ]

[ "The", "header", "is", "the", "entry", "for", "each", "iteration", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "direct_move_p", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "int", "regno0", ",", "regno1", ";", "if", "(", "!", "REG_P", "(", "op0", ")", "||", "!", "REG_P", "(", "op1", ")", ")", "return", "false", ";", "if", "(", "!", "TARGET_DIRECT_MOVE", "&&", "!", "TARGET_MFPGPR", ")", "return", "false", ";", "regno0", "=", "REGNO", "(", "op0", ")", ";", "regno1", "=", "REGNO", "(", "op1", ")", ";", "if", "(", "regno0", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno1", ">=", "FIRST_PSEUDO_REGISTER", ")", "return", "false", ";", "if", "(", "INT_REGNO_P", "(", "regno0", ")", ")", "return", "(", "TARGET_DIRECT_MOVE", ")", "?", "VSX_REGNO_P", "(", "regno1", ")", ":", "FP_REGNO_P", "(", "regno1", ")", ";", "else", "if", "(", "INT_REGNO_P", "(", "regno1", ")", ")", "{", "if", "(", "TARGET_MFPGPR", "&&", "FP_REGNO_P", "(", "regno0", ")", ")", "return", "true", ";", "else", "if", "(", "TARGET_DIRECT_MOVE", "&&", "VSX_REGNO_P", "(", "regno0", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "move", "direct", "operation", "between", "GPR", "registers", "and", "floating", "point/VSX", "registers", "." ]

[ "rs6000" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "M680x0InstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "M680x0II", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_ABSOLUTE_ADDRESS", ",", "\"M680x0-absolute\"", "}", ",", "{", "MO_PC_RELATIVE_ADDRESS", ",", "\"M680x0-pcrel\"", "}", ",", "{", "MO_GOT", ",", "\"M680x0-got\"", "}", ",", "{", "MO_GOTOFF", ",", "\"M680x0-gotoff\"", "}", ",", "{", "MO_GOTPCREL", ",", "\"M680x0-gotpcrel\"", "}", ",", "{", "MO_PLT", ",", "\"M680x0-plt\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "M680x0", "M680x0", "M680x0", "\"M680x0-absolute\"", "\"M680x0-pcrel\"", "\"M680x0-got\"", "\"M680x0-gotoff\"", "\"M680x0-gotpcrel\"", "\"M680x0-plt\"" ]

[]

[ "<s>", "static", "bool", "mmix_pass_by_reference", "(", "cumulative_args_t", "argsp_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "argsp", "=", "get_cumulative_args", "(", "argsp_v", ")", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ")", "return", "true", ";", "if", "(", "MMIX_FUNCTION_ARG_SIZE", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ">", "8", "&&", "!", "TARGET_LIBFUNC", "&&", "(", "!", "argsp", "||", "!", "argsp", "->", "lib", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "nonzero", "for", "everything", "that", "goes", "by", "reference", ",", "0", "for", "everything", "that", "goes", "by", "value", "." ]

[ "mmix", "8" ]

[]

[ "<s>", "void", "SPUFrameInfo", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "Align", "=", "std", "::", "max", "(", "TargetAlign", ",", "MFI", "->", "getMaxAlignment", "(", ")", ")", ";", "assert", "(", "isPowerOf2_32", "(", "Align", ")", "&&", "\"Alignment is not power of 2\"", ")", ";", "unsigned", "AlignMask", "=", "Align", "-", "1", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "\"Alignment is not power of 2\"", "1" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "F", ",", "Mang", ",", "TM", ")", ")", ";", "switch", "(", "F", "->", "getLinkage", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown linkage type!\"", ")", ";", "case", "Function", "::", "PrivateLinkage", ":", "case", "Function", "::", "LinkerPrivateLinkage", ":", "case", "Function", "::", "InternalLinkage", ":", "break", ";", "case", "Function", "::", "ExternalLinkage", ":", "O", "<<", "\"\\t.globl\\t\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "break", ";", "case", "Function", "::", "WeakAnyLinkage", ":", "case", "Function", "::", "WeakODRLinkage", ":", "case", "Function", "::", "LinkOnceAnyLinkage", ":", "case", "Function", "::", "LinkOnceODRLinkage", ":", "O", "<<", "\"\\t.globl\\t\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "O", "<<", "\"\\t.weak_definition\\t\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "break", ";", "}", "printVisibility", "(", "CurrentFnName", ",", "F", "->", "getVisibility", "(", ")", ")", ";", "EmitAlignment", "(", "MF", ".", "getAlignment", "(", ")", ",", "F", ")", ";", "O", "<<", "CurrentFnName", "<<", "\":\\n\"", ";", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "if", "(", "++", "I", "==", "MF", ".", "end", "(", ")", "&&", "MF", ".", "front", "(", ")", ".", "empty", "(", ")", ")", "O", "<<", "\"\\tnop\\n\"", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ",", "VerboseAsm", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "IE", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "IE", ";", "++", "II", ")", "{", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "DW", "->", "EndFunction", "(", "&", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"\\n\\n\"", "\"Unknown linkage type!\"", "\"\\t.globl\\t\"", "\"\\t.globl\\t\"", "\"\\t.weak_definition\\t\"", "\":\\n\"", "\"\\tnop\\n\"" ]

[]

[ "<s>", "static", "void", "aapcs_layout_arg", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "int", "nregs", ",", "nregs2", ";", "int", "ncrn", ";", "if", "(", "pcum", "->", "aapcs_arg_processed", ")", "return", ";", "pcum", "->", "aapcs_arg_processed", "=", "true", ";", "if", "(", "!", "named", ")", "return", ";", "if", "(", "pcum", "->", "pcs_variant", "!=", "ARM_PCS_AAPCS", ")", "{", "int", "slot", "=", "aapcs_select_call_coproc", "(", "pcum", ",", "mode", ",", "type", ")", ";", "pcum", "->", "aapcs_cprc_slot", "=", "slot", ";", "if", "(", "slot", ">=", "0", ")", "{", "if", "(", "!", "pcum", "->", "aapcs_cprc_failed", "[", "slot", "]", ")", "{", "if", "(", "aapcs_cp_arg_layout", "[", "slot", "]", ".", "allocate", "(", "pcum", ",", "mode", ",", "type", ")", ")", "return", ";", "pcum", "->", "aapcs_cprc_failed", "[", "slot", "]", "=", "true", ";", "pcum", "->", "can_split", "=", "false", ";", "}", "gcc_assert", "(", "pcum", "->", "can_split", "==", "false", ")", ";", "return", ";", "}", "}", "ncrn", "=", "pcum", "->", "aapcs_ncrn", ";", "if", "(", "ncrn", "&", "1", ")", "{", "int", "res", "=", "arm_needs_doubleword_align", "(", "mode", ",", "type", ")", ";", "if", "(", "res", "<", "0", "&&", "warn_psabi", "&&", "currently_expanding_gimple_stmt", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 7.1\"", ",", "type", ")", ";", "else", "if", "(", "res", ">", "0", ")", "ncrn", "++", ";", "}", "nregs", "=", "ARM_NUM_REGS2", "(", "mode", ",", "type", ")", ";", "gcc_assert", "(", "nregs", ">=", "0", ")", ";", "nregs2", "=", "nregs", "?", "nregs", ":", "1", ";", "if", "(", "ncrn", "+", "nregs2", "<=", "NUM_ARG_REGS", ")", "{", "pcum", "->", "aapcs_reg", "=", "gen_rtx_REG", "(", "mode", ",", "ncrn", ")", ";", "pcum", "->", "aapcs_next_ncrn", "=", "ncrn", "+", "nregs", ";", "return", ";", "}", "if", "(", "ncrn", "<", "NUM_ARG_REGS", "&&", "pcum", "->", "can_split", ")", "{", "pcum", "->", "aapcs_reg", "=", "gen_rtx_REG", "(", "mode", ",", "ncrn", ")", ";", "pcum", "->", "aapcs_next_ncrn", "=", "NUM_ARG_REGS", ";", "pcum", "->", "aapcs_partial", "=", "(", "NUM_ARG_REGS", "-", "ncrn", ")", "*", "UNITS_PER_WORD", ";", "return", ";", "}", "pcum", "->", "aapcs_next_ncrn", "=", "NUM_ARG_REGS", ";", "return", ";", "}", "</s>" ]

[ "Lay", "out", "a", "function", "argument", "using", "the", "AAPCS", "rules", ".", "The", "rule", "numbers", "referred", "to", "here", "are", "those", "in", "the", "AAPCS", "." ]

[ "arm", "0", "1", "0", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 7.1\"", "0", "0", "1" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTarget21OpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "2", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTarget21OpValue expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "FixupExpression", "=", "MCBinaryExpr", "::", "createAdd", "(", "MO", ".", "getExpr", "(", ")", ",", "MCConstantExpr", "::", "create", "(", "-", "4", ",", "Ctx", ")", ",", "Ctx", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "FixupExpression", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MIPS_PC21_S2", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTarget21OpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "2", "\"getBranchTarget21OpValue expects only expressions or immediates\"", "4", "0", "Mips::fixup_MIPS_PC21_S2", "0" ]

[]

[ "<s>", "static", "void", "eco32_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "first_anon_arg", ";", "if", "(", "no_rtl", ")", "return", ";", "gcc_assert", "(", "mode", "!=", "BLKmode", ")", ";", "if", "(", "targetm", ".", "calls", ".", "strict_argument_naming", "(", "cum_v", ")", ")", "*", "cum", "+=", "eco32_num_arg_regs", "(", "mode", ",", "type", ")", ";", "first_anon_arg", "=", "*", "cum", "+", "ECO32_FIRST_ARG_REGNO", ";", "if", "(", "first_anon_arg", "<", "(", "ECO32_FIRST_ARG_REGNO", "+", "ECO32_NUM_ARG_REGS", ")", ")", "{", "int", "size", "=", "ECO32_FIRST_ARG_REGNO", "+", "ECO32_NUM_ARG_REGS", "-", "first_anon_arg", ";", "rtx", "regblock", ";", "int", "offset", "=", "(", "first_anon_arg", "-", "ECO32_FIRST_ARG_REGNO", ")", "*", "UNITS_PER_WORD", ";", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "offset", ")", ")", ";", "move_block_from_reg", "(", "first_anon_arg", ",", "regblock", ",", "size", ")", ";", "*", "pretend_size", "=", "size", "*", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]

[ "Setup", "incoming", "varargs", "by", "copying", "the", "anonymous", "argument", "register", "into", "their", "respective", "spot", "on", "the", "stack" ]

[ "eco32" ]

[]

[ "<s>", "uint64_t", "SIMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isExpr", "(", ")", "&&", "MO", ".", "getExpr", "(", ")", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "Constant", ")", "{", "const", "MCSymbolRefExpr", "*", "Expr", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "MO", ".", "getExpr", "(", ")", ")", ";", "MCFixupKind", "Kind", ";", "if", "(", "Expr", "&&", "Expr", "->", "getSymbol", "(", ")", ".", "isExternal", "(", ")", ")", "Kind", "=", "FK_Data_4", ";", "else", "Kind", "=", "FK_PCRel_4", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "4", ",", "MO", ".", "getExpr", "(", ")", ",", "Kind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "}", "unsigned", "OpNo", "=", "0", ";", "for", "(", "unsigned", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "OpNo", "<", "e", ";", "++", "OpNo", ")", "{", "if", "(", "&", "MO", "==", "&", "MI", ".", "getOperand", "(", "OpNo", ")", ")", "break", ";", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "isSrcOperand", "(", "Desc", ",", "OpNo", ")", ")", "{", "int", "RCID", "=", "Desc", ".", "OpInfo", "[", "OpNo", "]", ".", "RegClass", ";", "const", "MCRegisterClass", "&", "RC", "=", "MRI", ".", "getRegClass", "(", "RCID", ")", ";", "uint32_t", "Enc", "=", "getLitEncoding", "(", "MO", ",", "RC", ".", "getSize", "(", ")", ")", ";", "if", "(", "Enc", "!=", "~", "0U", "&&", "(", "Enc", "!=", "255", "||", "Desc", ".", "getSize", "(", ")", "==", "4", ")", ")", "return", "Enc", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "llvm_unreachable", "(", "\"Encoding of this operand type is not supported yet.\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "AMDGPU", "SI", "4", "0", "0U", "255", "4", "\"Encoding of this operand type is not supported yet.\"", "0" ]

[]

[ "<s>", "static", "enum", "machine_mode", "type_natural_mode", "(", "tree", "type", ")", "{", "enum", "machine_mode", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "(", "size", "==", "8", "||", "size", "==", "16", ")", "&&", "TYPE_VECTOR_SUBPARTS", "(", "type", ")", ">", "1", ")", "{", "enum", "machine_mode", "innermode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "REAL_TYPE", ")", "mode", "=", "MIN_MODE_VECTOR_FLOAT", ";", "else", "mode", "=", "MIN_MODE_VECTOR_INT", ";", "for", "(", ";", "mode", "!=", "VOIDmode", ";", "mode", "=", "GET_MODE_WIDER_MODE", "(", "mode", ")", ")", "if", "(", "GET_MODE_NUNITS", "(", "mode", ")", "==", "TYPE_VECTOR_SUBPARTS", "(", "type", ")", "&&", "GET_MODE_INNER", "(", "mode", ")", "==", "innermode", ")", "return", "mode", ";", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "mode", ";", "}", "</s>" ]

[ "Return", "the", "``", "natural", "''", "mode", "for", "TYPE", ".", "In", "most", "cases", ",", "this", "is", "just", "TYPE_MODE", ".", "But", "in", "the", "case", "of", "vector", "types", ",", "it", "is", "some", "vector", "mode", ".", "When", "we", "have", "only", "some", "of", "our", "vector", "isa", "extensions", "enabled", ",", "then", "there", "are", "some", "modes", "for", "which", "vector_mode_supported_p", "is", "false", ".", "For", "these", "modes", ",", "the", "generic", "vector", "support", "in", "gcc", "will", "choose", "some", "non-vector", "mode", "in", "order", "to", "implement", "the", "type", ".", "By", "computing", "the", "natural", "mode", ",", "we", "'ll", "select", "the", "proper", "ABI", "location", "for", "the", "operand", "and", "not", "depend", "on", "whatever", "the", "middle-end", "decides", "to", "do", "with", "these", "vector", "types", "." ]

[ "i386", "8", "16", "1" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "enableAggressiveInterleaving", "(", "bool", "LoopHasReductions", ")", "{", "if", "(", "ST", "->", "getDarwinDirective", "(", ")", "==", "PPC", "::", "DIR_A2", ")", "return", "true", ";", "return", "LoopHasReductions", ";", "}", "</s>" ]

[ "Do", "n't", "restrict", "interleaved", "unrolling", "to", "small", "loops", "." ]

[ "PowerPC", "PPC", "PPC::DIR_A2" ]

[]

[ "<s>", "rtx", "m68k_unwrap_symbol", "(", "rtx", "orig", ",", "bool", "unwrap_reloc32_p", ")", "{", "return", "m68k_unwrap_symbol_1", "(", "orig", ",", "unwrap_reloc32_p", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Unwrap", "symbol", "from", "UNSPEC_RELOC16", "and", ",", "if", "unwrap_reloc32_p", ",", "UNSPEC_RELOC32", "wrappers", "." ]

[ "m68k" ]

[]

[ "<s>", "rtx", "parallel_element", "(", "rtx", "parallel_rtx", ",", "int", "nth", ")", "{", "parallel_rtx", "=", "extract_pattern_from_insn", "(", "parallel_rtx", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "parallel_rtx", ")", "==", "PARALLEL", ")", ";", "int", "len", "=", "parallel_elements", "(", "parallel_rtx", ")", ";", "if", "(", "nth", ">=", "0", ")", "{", "if", "(", "nth", ">=", "len", ")", "return", "NULL_RTX", ";", "return", "XVECEXP", "(", "parallel_rtx", ",", "0", ",", "nth", ")", ";", "}", "else", "{", "if", "(", "len", "+", "nth", "<", "0", ")", "return", "NULL_RTX", ";", "return", "XVECEXP", "(", "parallel_rtx", ",", "0", ",", "len", "+", "nth", ")", ";", "}", "}", "</s>" ]

[ "Extract", "an", "rtx", "from", "a", "parallel", "rtx", "with", "index", "NTH", ".", "If", "NTH", "is", "a", "negative", "value", ",", "the", "function", "returns", "the", "last", "NTH", "rtx", "." ]

[ "nds32", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "AMDGPUSubtarget", "&", "AMDGPUSubtarget", "::", "get", "(", "const", "TargetMachine", "&", "TM", ",", "const", "Function", "&", "F", ")", "{", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "return", "static_cast", "<", "const", "AMDGPUSubtarget", "&", ">", "(", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ")", ";", "else", "return", "static_cast", "<", "const", "AMDGPUSubtarget", "&", ">", "(", "TM", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "R600" ]

[]

[ "<s>", "void", "MSP430MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "Offset", "=", "(", "(", "Desc", ".", "TSFlags", "&", "MSP430TSFlags", "::", "ExtensionWord", ")", "?", "4", ":", "2", ")", ";", "uint64_t", "BinaryOpCode", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "if", "(", "Desc", ".", "TSFlags", "&", "MSP430TSFlags", "::", "ExtensionWord", ")", "BinaryOpCode", "=", "fixExtensionWord", "(", "BinaryOpCode", ")", ";", "size_t", "WordCount", "=", "Size", "/", "2", ";", "while", "(", "WordCount", "--", ")", "{", "support", "::", "endian", "::", "write", "(", "OS", ",", "(", "uint16_t", ")", "BinaryOpCode", ",", "support", "::", "little", ")", ";", "BinaryOpCode", ">>=", "16", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430TSFlags::ExtensionWord", "4", "2", "MSP430TSFlags::ExtensionWord", "2", "support::endian", "support::little", "16" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "\"TLS not implemented for Hexagon.\"", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "Op", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INLINEASM", ":", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Should not custom lower this!\"", "ISD::ConstantPool", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "\"TLS not implemented for Hexagon.\"", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::GlobalAddress", "ISD::VASTART", "ISD::BR_JT", "ISD::DYNAMIC_STACKALLOC", "ISD::SELECT_CC", "ISD::SELECT", "ISD::INTRINSIC_WO_CHAIN", "ISD::INLINEASM" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "AllSGPRSpilledToVGPRs", "=", "false", ";", "if", "(", "TRI", ".", "spillSGPRToVGPR", "(", ")", "&&", "FuncInfo", "->", "hasSpilledSGPRs", "(", ")", ")", "{", "AllSGPRSpilledToVGPRs", "=", "true", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", ";", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "TII", "->", "isSGPRSpill", "(", "MI", ")", ")", "{", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "assert", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "SIStackID", "::", "SGPR_SPILL", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "bool", "Spilled", "=", "TRI", ".", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "RS", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "\"failed to spill SGPR to VGPR when allocated\"", ")", ";", "}", "else", "AllSGPRSpilledToVGPRs", "=", "false", ";", "}", "}", "}", "FuncInfo", "->", "removeSGPRToVGPRFrameIndices", "(", "MFI", ")", ";", "}", "if", "(", "FuncInfo", "->", "hasNonSpillStackObjects", "(", ")", "||", "FuncInfo", "->", "hasSpilledVGPRs", "(", ")", "||", "!", "AllSGPRSpilledToVGPRs", "||", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "int", "ScavengeFI", "=", "MFI", ".", "CreateFixedObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "0", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU::OpName", "SIStackID::SGPR_SPILL", "\"failed to spill SGPR to VGPR when allocated\"", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "0" ]

[]

[ "<s>", "virtual", "MVT", "getScalarShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "X86", "MVT::i8" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldInsertFixupForCodeAlign", "(", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "MCAlignFragment", "&", "AF", ")", "{", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "return", "false", ";", "unsigned", "Count", ";", "if", "(", "!", "shouldInsertExtraNopBytesForCodeAlign", "(", "AF", ",", "Count", ")", "||", "(", "Count", "==", "0", ")", ")", "return", "false", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "const", "MCExpr", "*", "Dummy", "=", "MCConstantExpr", "::", "create", "(", "0", ",", "Ctx", ")", ";", "MCFixup", "Fixup", "=", "MCFixup", "::", "create", "(", "0", ",", "Dummy", ",", "MCFixupKind", "(", "RISCV", "::", "fixup_riscv_align", ")", ",", "SMLoc", "(", ")", ")", ";", "uint64_t", "FixedValue", "=", "0", ";", "MCValue", "NopBytes", "=", "MCValue", "::", "get", "(", "Count", ")", ";", "Asm", ".", "getWriter", "(", ")", ".", "recordRelocation", "(", "Asm", ",", "Layout", ",", "&", "AF", ",", "Fixup", ",", "NopBytes", ",", "FixedValue", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Hook", "which", "indicates", "if", "the", "target", "requires", "a", "fixup", "to", "be", "generated", "when", "handling", "an", "align", "directive", "in", "an", "executable", "section", "." ]

[ "RI5CY", "RISCV", "RISCV::FeatureRelax", "0", "0", "0", "RISCV::fixup_riscv_align", "0" ]

[]

[ "<s>", "unsigned", "OR1KMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getOR1KRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "OR1K", "::", "Fixups", "FixupKind", "=", "OR1K", "::", "Fixups", "(", "0", ")", ";", "switch", "(", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown fixup kind!\"", ")", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_REL26", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_ABS_HI", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_HI16_INSN", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_ABS_LO", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_LO16_INSN", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_PLT", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_PLT26", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOTPCHI", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOTPC_HI16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOTPCLO", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOTPC_LO16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOTOFFHI", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOTOFF_HI16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOTOFFLO", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOTOFF_LO16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOT", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOT16", ";", "break", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "OR1K", "OR1K", "OR1K", "OR1K::Fixups", "OR1K::Fixups", "0", "\"Unknown fixup kind!\"", "OR1K::fixup_OR1K_REL26", "OR1K", "OR1K::fixup_OR1K_HI16_INSN", "OR1K", "OR1K::fixup_OR1K_LO16_INSN", "OR1K", "OR1K::fixup_OR1K_PLT26", "OR1K", "OR1K::fixup_OR1K_GOTPC_HI16", "OR1K", "OR1K::fixup_OR1K_GOTPC_LO16", "OR1K", "OR1K::fixup_OR1K_GOTOFF_HI16", "OR1K", "OR1K::fixup_OR1K_GOTOFF_LO16", "OR1K", "OR1K::fixup_OR1K_GOT16", "0", "0" ]

[]

[ "<s>", "bool", "X86DomainReassignment", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "DisableX86DomainReassignment", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function before Domain Reassignment *****\\n\"", ")", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "hasAVX512", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "initConverters", "(", ")", ";", "bool", "Changed", "=", "false", ";", "DenseSet", "<", "unsigned", ">", "EnclosedEdges", ";", "DenseMap", "<", "MachineInstr", "*", ",", "Closure", "*", ">", "EnclosedInstrs", ";", "std", "::", "vector", "<", "Closure", ">", "Closures", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "++", "Idx", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "Idx", ")", ";", "if", "(", "!", "isGPR", "(", "MRI", "->", "getRegClass", "(", "Reg", ")", ")", ")", "continue", ";", "if", "(", "EnclosedEdges", ".", "count", "(", "Reg", ")", ")", "continue", ";", "Closure", "C", "(", "TII", ",", "MRI", ",", "Converters", ",", "{", "MaskDomain", "}", ",", "EnclosedEdges", ",", "EnclosedInstrs", ")", ";", "C", ".", "buildClosure", "(", "Reg", ")", ";", "if", "(", "!", "C", ".", "empty", "(", ")", "&&", "C", ".", "isLegal", "(", "MaskDomain", ")", ")", "Closures", ".", "push_back", "(", "std", "::", "move", "(", "C", ")", ")", ";", "}", "for", "(", "Closure", "&", "C", ":", "Closures", ")", "if", "(", "C", ".", "isReassignmentProfitable", "(", "MaskDomain", ")", ")", "{", "C", ".", "Reassign", "(", "MaskDomain", ")", ";", "++", "NumClosuresConverted", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "I", ":", "Converters", ")", "delete", "I", ".", "second", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function after Domain Reassignment *****\\n\"", ")", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"***** Machine Function before Domain Reassignment *****\\n\"", "X86", "\"Expected MIR to be in SSA form\"", "0", "\"***** Machine Function after Domain Reassignment *****\\n\"" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "LowerAArch64MachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "true", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "iterator", "end", "(", ")", "{", "return", "(", "Packet", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "1", "<<", "12", ")", "-", "1", ")", "/", "2", ")", "return", "false", ";", "return", "!", "MFI", ".", "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", "." ]

[ "ARM", "ARM", "1", "12", "1", "2" ]

[]

[ "<s>", "void", "AMDGPURegisterBankInfo", "::", "applyMappingImpl", "(", "const", "OperandsMapper", "&", "OpdMapper", ")", "const", "{", "return", "applyDefaultMapping", "(", "OpdMapper", ")", ";", "}", "</s>" ]

[ "See", "RegisterBankInfo", ":", ":applyMapping", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "use_vfp_abi", "(", "enum", "arm_pcs", "pcs_variant", ",", "bool", "is_double", ")", "{", "if", "(", "pcs_variant", "==", "ARM_PCS_AAPCS_VFP", ")", "{", "static", "bool", "seen_thumb1_vfp", "=", "false", ";", "if", "(", "TARGET_THUMB1", "&&", "!", "seen_thumb1_vfp", ")", "{", "sorry", "(", "\"Thumb-1 %<hard-float%> VFP ABI\"", ")", ";", "seen_thumb1_vfp", "=", "true", ";", "}", "return", "true", ";", "}", "if", "(", "pcs_variant", "!=", "ARM_PCS_AAPCS_LOCAL", ")", "return", "false", ";", "return", "(", "TARGET_32BIT", "&&", "TARGET_HARD_FLOAT", "&&", "(", "TARGET_VFP_DOUBLE", "||", "!", "is_double", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "PCS_VARIANT", "should", "use", "VFP", "registers", "." ]

[ "arm", "\"Thumb-1 %<hard-float%> VFP ABI\"" ]

[]

[ "<s>", "unsigned", "OR1KMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getOR1KRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "OR1K", "::", "Fixups", "FixupKind", "=", "OR1K", "::", "Fixups", "(", "0", ")", ";", "switch", "(", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown fixup kind!\"", ")", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "switch", "(", "InstrInfo", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ")", "{", "case", "OR1KII", "::", "AFrm", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_LO16_INSN", ";", "break", ";", "case", "OR1KII", "::", "JFrm", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_REL26", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported expression operand in assembly source\"", ")", ";", "}", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_ABS_HI", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_HI16_INSN", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_ABS_LO", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_LO16_INSN", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_PLT", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_PLT26", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOTPCHI", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOTPC_HI16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOTPCLO", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOTPC_LO16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOTOFFHI", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOTOFF_HI16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOTOFFLO", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOTOFF_LO16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_OR1K_GOT", ":", "FixupKind", "=", "OR1K", "::", "fixup_OR1K_GOT16", ";", "break", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "OR1K", "OR1K", "OR1K", "OR1K::Fixups", "OR1K::Fixups", "0", "\"Unknown fixup kind!\"", "OR1KII::AFrm", "OR1K::fixup_OR1K_LO16_INSN", "OR1KII::JFrm", "OR1K::fixup_OR1K_REL26", "\"Unsupported expression operand in assembly source\"", "OR1K", "OR1K::fixup_OR1K_HI16_INSN", "OR1K", "OR1K::fixup_OR1K_LO16_INSN", "OR1K", "OR1K::fixup_OR1K_PLT26", "OR1K", "OR1K::fixup_OR1K_GOTPC_HI16", "OR1K", "OR1K::fixup_OR1K_GOTPC_LO16", "OR1K", "OR1K::fixup_OR1K_GOTOFF_HI16", "OR1K", "OR1K::fixup_OR1K_GOTOFF_LO16", "OR1K", "OR1K::fixup_OR1K_GOT16", "0", "0" ]

[]

[ "<s>", "static", "const", "MachineOperand", "&", "getLdStOffsetOp", "(", "const", "MachineInstr", "*", "MI", ")", "{", "unsigned", "Idx", "=", "isPairedLdSt", "(", "MI", ")", "?", "3", ":", "2", ";", "return", "MI", "->", "getOperand", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "immediate", "offset", "operator", "of", "a", "load/store", "." ]

[ "AArch64", "3", "2" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "O", ")", ";", "case", "'a'", ":", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "return", "true", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "llvm_unreachable", "(", "\"unexpected operand type!\"", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "O", ")", ";", "if", "(", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", ")", "O", "<<", "\"(%rip)\"", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "O", "<<", "'('", ";", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "')'", ";", "return", "false", ";", "}", "case", "'c'", ":", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "llvm_unreachable", "(", "\"unexpected operand type!\"", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "O", ")", ";", "break", ";", "}", "return", "false", ";", "case", "'A'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'*'", ";", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "case", "'V'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "*", "this", ",", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'x'", ":", "case", "'t'", ":", "case", "'g'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmVRegister", "(", "*", "this", ",", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'P'", ":", "PrintPCRelImm", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'n'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "-", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "O", "<<", "'-'", ";", "}", "}", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "1", "0", "0", "\"unexpected operand type!\"", "\"(%rip)\"", "\"unexpected operand type!\"", "0", "0" ]

[]

[ "<s>", "static", "rtx", "mips_force_unary", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "op0", ")", "{", "rtx", "reg", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "mips_emit_unary", "(", "code", ",", "reg", ",", "op0", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Compute", "(", "CODE", "OP0", ")", "and", "store", "the", "result", "in", "a", "new", "register", "of", "mode", "MODE", ".", "Return", "that", "new", "register", "." ]

[ "mips" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "NonScalarIntSafe", ",", "bool", "MemcpyStrSrc", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "Function", "*", "F", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "if", "(", "NonScalarIntSafe", "&&", "!", "F", "->", "hasFnAttr", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "Subtarget", "->", "isUnalignedMemAccessFast", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "16", ")", "{", "if", "(", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "8", "&&", "Subtarget", "->", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "16", "MVT::v4i32", "MVT::v4f32", "8", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "EVT", "MipsTargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "Mips", "Mips", "MVT::i32" ]

[]

[ "<s>", "TargetTransformInfo", "MipsTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "if", "(", "Subtarget", "->", "allowMixed16_32", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"No Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "}", "DEBUG", "(", "errs", "(", ")", "<<", "\"Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "BasicTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "Mips", "Mips", "\"No Target Transform Info Pass Added\\n\"", "\"Target Transform Info Pass Added\\n\"" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "fitsConstReadLimitations", "(", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "MIs", ")", "const", "{", "std", "::", "vector", "<", "unsigned", ">", "Consts", ";", "SmallSet", "<", "int64_t", ",", "4", ">", "Literals", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "MIs", ".", "size", "(", ")", ";", "i", "<", "n", ";", "i", "++", ")", "{", "MachineInstr", "*", "MI", "=", "MIs", "[", "i", "]", ";", "if", "(", "!", "isALUInstr", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "ArrayRef", "<", "std", "::", "pair", "<", "MachineOperand", "*", ",", "int64_t", ">>", "Srcs", "=", "getSrcs", "(", "MI", ")", ";", "for", "(", "const", "auto", "&", "Src", ":", "Srcs", ")", "{", "if", "(", "Src", ".", "first", "->", "getReg", "(", ")", "==", "AMDGPU", "::", "ALU_LITERAL_X", ")", "Literals", ".", "insert", "(", "Src", ".", "second", ")", ";", "if", "(", "Literals", ".", "size", "(", ")", ">", "4", ")", "return", "false", ";", "if", "(", "Src", ".", "first", "->", "getReg", "(", ")", "==", "AMDGPU", "::", "ALU_CONST", ")", "Consts", ".", "push_back", "(", "Src", ".", "second", ")", ";", "if", "(", "AMDGPU", "::", "R600_KC0RegClass", ".", "contains", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "R600_KC1RegClass", ".", "contains", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", ")", "{", "unsigned", "Index", "=", "RI", ".", "getEncodingValue", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", "&", "0xff", ";", "unsigned", "Chan", "=", "RI", ".", "getHWRegChan", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", ";", "Consts", ".", "push_back", "(", "(", "Index", "<<", "2", ")", "|", "Chan", ")", ";", "}", "}", "}", "return", "fitsConstReadLimitations", "(", "Consts", ")", ";", "}", "</s>" ]

[ "Same", "but", "using", "const", "index", "set", "instead", "of", "MI", "set", "." ]

[ "AMDGPU", "R600", "4", "0", "AMDGPU::ALU_LITERAL_X", "4", "AMDGPU::ALU_CONST", "AMDGPU::R600_KC0RegClass", "AMDGPU::R600_KC1RegClass", "0xff", "2" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "M68kRegisterInfo", "::", "getMaximalPhysRegClass", "(", "unsigned", "reg", ",", "MVT", "VT", ")", "const", "{", "assert", "(", "Register", "::", "isPhysicalRegister", "(", "reg", ")", "&&", "\"reg must be a physical register\"", ")", ";", "const", "TargetRegisterClass", "*", "BestRC", "=", "nullptr", ";", "for", "(", "regclass_iterator", "I", "=", "regclass_begin", "(", ")", ",", "E", "=", "regclass_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "*", "I", ";", "if", "(", "(", "VT", "==", "MVT", "::", "Other", "||", "isTypeLegalForClass", "(", "*", "RC", ",", "VT", ")", ")", "&&", "RC", "->", "contains", "(", "reg", ")", "&&", "(", "!", "BestRC", "||", "(", "BestRC", "->", "hasSubClass", "(", "RC", ")", "&&", "RC", "->", "getNumRegs", "(", ")", ">", "BestRC", "->", "getNumRegs", "(", ")", ")", ")", ")", "BestRC", "=", "RC", ";", "}", "assert", "(", "BestRC", "&&", "\"Couldn't find the register class\"", ")", ";", "return", "BestRC", ";", "}", "</s>" ]

[ "Returns", "the", "Register", "Class", "of", "a", "physical", "register", "of", "the", "given", "type", ",", "picking", "the", "biggest", "register", "class", "of", "the", "right", "type", "that", "contains", "this", "physreg", "." ]

[ "M68k", "M68k", "\"reg must be a physical register\"", "MVT::Other", "\"Couldn't find the register class\"" ]

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "Optional", "<", "Hexagon", "::", "ArchEnum", ">", "ArchVer", "=", "Hexagon", "::", "GetCpu", "(", "Hexagon", "::", "CpuTable", ",", "CPUString", ")", ";", "if", "(", "ArchVer", ")", "HexagonArchVersion", "=", "*", "ArchVer", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseAudioOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "if", "(", "isTinyCore", "(", ")", ")", "{", "if", "(", "!", "EnableBSBSched", ".", "getPosition", "(", ")", ")", "UseBSBScheduling", "=", "false", ";", "}", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "reset", "(", "Hexagon", "::", "FeatureDuplex", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "Hexagon::GetCpu", "Hexagon::CpuTable", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon::FeatureDuplex", "Hexagon" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", "{", "bool", "OnlyOptimizeForSize", "=", "(", "TM", "->", "getOptLevel", "(", ")", "<", "CodeGenOpt", "::", "Aggressive", ")", "&&", "(", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", ";", "bool", "MergeExternalByDefault", "=", "!", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ";", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "127", ",", "OnlyOptimizeForSize", ",", "MergeExternalByDefault", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createHardwareLoopsPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "ARM", "ARM", "127" ]

[]

[ "<s>", "void", "TargetLoweringObjectFileNaCl", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "StaticCtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".init_array\"", ",", "ELF", "::", "SHT_INIT_ARRAY", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "StaticDtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".fini_array\"", ",", "ELF", "::", "SHT_FINI_ARRAY", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "\".init_array\"", "\".fini_array\"" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "AArch64", "AArch64", "MVT::i32" ]

[]

[ "<s>", "static", "void", "mep_make_parallel", "(", "rtx_insn", "*", "insn1", ",", "rtx_insn", "*", "insn2", ")", "{", "rtx", "expr", ";", "if", "(", "RTX_FRAME_RELATED_P", "(", "insn2", ")", ")", "{", "expr", "=", "mep_frame_expr", "(", "insn2", ")", ";", "if", "(", "RTX_FRAME_RELATED_P", "(", "insn1", ")", ")", "expr", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "mep_frame_expr", "(", "insn1", ")", ",", "expr", ")", ")", ";", "set_unique_reg_note", "(", "insn1", ",", "REG_FRAME_RELATED_EXPR", ",", "expr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn1", ")", "=", "1", ";", "}", "PATTERN", "(", "insn1", ")", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "PATTERN", "(", "insn1", ")", ",", "PATTERN", "(", "insn2", ")", ")", ")", ";", "INSN_CODE", "(", "insn1", ")", "=", "-", "1", ";", "}", "</s>" ]

[ "Merge", "instructions", "INSN1", "and", "INSN2", "using", "a", "PARALLEL", ".", "Store", "the", "new", "pattern", "in", "INSN1", ";", "INSN2", "will", "be", "deleted", "by", "the", "caller", "." ]

[ "mep", "2", "1", "2", "1" ]

[]

[ "<s>", "bool", "sh_lshrsi_clobbers_t_reg_p", "(", "rtx", "shift_amount", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "shift_amount", ")", ")", ";", "const", "int", "shift_amount_i", "=", "std", "::", "abs", "(", "INTVAL", "(", "shift_amount", ")", ")", "&", "31", ";", "if", "(", "shift_amount_i", "==", "31", ")", "return", "true", ";", "return", "(", "ashl_lshr_seq", "[", "shift_amount_i", "]", ".", "clobbers_t", "&", "LSHR_CLOBBERS_T", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "logical", "right", "shift", "consisting", "of", "1/2/8/16", "shift", "instructions", "will", "clobber", "the", "T", "bit", "." ]

[ "sh", "31", "31", "0" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasCMov", "(", "false", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasPOPCNT", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAVX", "(", "false", ")", ",", "HasAES", "(", "false", ")", ",", "HasCLMUL", "(", "false", ")", ",", "HasFMA3", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "IsUAMemFast", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "stackAlignment", "(", "8", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Is64Bit", "(", "is64Bit", ")", "{", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "std", "::", "string", "CPU", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "if", "(", "HasAVX", ")", "X86SSELevel", "=", "NoMMXSSE", ";", "}", "else", "{", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "Is64Bit", "&&", "!", "HasAVX", "&&", "X86SSELevel", "<", "SSE2", ")", "X86SSELevel", "=", "SSE2", ";", "}", "if", "(", "Is64Bit", ")", "{", "HasX86_64", "=", "true", ";", "HasCMov", "=", "true", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "Is64Bit", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "isTargetDarwin", "(", ")", "||", "isTargetFreeBSD", "(", ")", "||", "isTargetLinux", "(", ")", "||", "isTargetSolaris", "(", ")", "||", "Is64Bit", ")", "stackAlignment", "=", "16", ";", "if", "(", "StackAlignment", ")", "stackAlignment", "=", "StackAlignment", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "8", "128", "X86", "X86", "X86", "X86", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "16" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC_LO", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC_HI", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "FLAT_SCR", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "FLAT_SCR_LO", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "FLAT_SCR_HI", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "VGPR255", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "VGPR254", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "R600", "SI" ]

[]

[ "<s>", "void", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isAAPCS_ABI", "(", ")", ")", "{", "StaticCtorSection", "=", "getELFSection", "(", "\".init_array\"", ",", "MCSectionELF", "::", "SHT_INIT_ARRAY", ",", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "StaticDtorSection", "=", "getELFSection", "(", "\".fini_array\"", ",", "MCSectionELF", "::", "SHT_FINI_ARRAY", ",", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\".init_array\"", "\".fini_array\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "WebAssemblyFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "assert", "(", "!", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "&&", "hasFP", "(", "MF", ")", "&&", "\"Call frame pseudos should only be used for dynamic stack adjustment\"", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", "&&", "needsSPWriteback", "(", "MF", ",", "MF", ".", "getFrameInfo", "(", ")", ")", ")", "{", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "writeSPToMemory", "(", "WebAssembly", "::", "SP32", ",", "MF", ",", "MBB", ",", "I", ",", "I", ",", "DL", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "\"Call frame pseudos should only be used for dynamic stack adjustment\"", "WebAssembly", "WebAssembly::SP32" ]

[]

[ "<s>", "bool", "pdp11_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "FLOAT_MODE_P", "(", "from", ")", "!=", "FLOAT_MODE_P", "(", "to", ")", ")", "return", "true", ";", "return", "reg_classes_intersect_p", "(", "FPU_REGS", ",", "rclass", ")", ";", "}", "</s>" ]

[ "Implement", "CANNOT_CHANGE_MODE_CLASS", "." ]

[ "pdp11" ]

[]

[ "<s>", "bool", "Z80InstPrinter", "::", "applyTargetSpecificCLOption", "(", "StringRef", "Opt", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Customize", "the", "printer", "according", "to", "a", "command", "line", "option", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "static", "void", "bpf_asm_init_sections", "(", "void", ")", "{", "if", "(", "TARGET_BPF_CORE", ")", "btf_ext_init", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_INIT_SECTIONS", "." ]

[ "bpf" ]

[]

[ "<s>", "static", "bool", "originalTypeIsF128", "(", "Type", "*", "Ty", ",", "const", "SDNode", "*", "CallNode", ")", "{", "if", "(", "Ty", "->", "isFP128Ty", "(", ")", ")", "return", "true", ";", "if", "(", "Ty", "->", "isStructTy", "(", ")", "&&", "Ty", "->", "getStructNumElements", "(", ")", "==", "1", "&&", "Ty", "->", "getStructElementType", "(", "0", ")", "->", "isFP128Ty", "(", ")", ")", "return", "true", ";", "const", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast_or_null", "<", "const", "ExternalSymbolSDNode", ">", "(", "CallNode", ")", ";", "return", "(", "ES", "&&", "Ty", "->", "isIntegerTy", "(", "128", ")", "&&", "isF128SoftLibCall", "(", "ES", "->", "getSymbol", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "Ty", "is", "fp128", ",", "{", "f128", "}", "or", "i128", "which", "was", "originally", "a", "fp128", "." ]

[ "Mips", "1", "0", "128" ]

[]

[ "<s>", "bool", "TeeRISCPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createTeeRISCISelDag", "(", "getTeeRISCTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC", "TeeRISC", "TeeRISC" ]

[]

[ "<s>", "void", "changingInstr", "(", "MachineInstr", "&", "MI", ")", "override", "{", "}", "</s>" ]

[ "This", "instruction", "is", "about", "to", "be", "mutated", "in", "some", "way", "." ]

[ "Mips" ]

[]

[ "<s>", "int", "regs_used", "(", "rtx", "x", ",", "int", "is_dest", ")", "{", "enum", "rtx_code", "code", ";", "const", "char", "*", "fmt", ";", "int", "i", ",", "used", "=", "0", ";", "if", "(", "!", "x", ")", "return", "used", ";", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "x", ")", "<", "16", ")", "return", "(", "(", "(", "1", "<<", "HARD_REGNO_NREGS", "(", "0", ",", "GET_MODE", "(", "x", ")", ")", ")", "-", "1", ")", "<<", "(", "REGNO", "(", "x", ")", "+", "is_dest", ")", ")", ";", "return", "0", ";", "case", "SUBREG", ":", "{", "rtx", "y", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "!", "REG_P", "(", "y", ")", ")", "break", ";", "if", "(", "REGNO", "(", "y", ")", "<", "16", ")", "return", "(", "(", "(", "1", "<<", "HARD_REGNO_NREGS", "(", "0", ",", "GET_MODE", "(", "x", ")", ")", ")", "-", "1", ")", "<<", "(", "REGNO", "(", "y", ")", "+", "subreg_regno_offset", "(", "REGNO", "(", "y", ")", ",", "GET_MODE", "(", "y", ")", ",", "SUBREG_BYTE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ")", "+", "is_dest", ")", ")", ";", "return", "0", ";", "}", "case", "SET", ":", "return", "regs_used", "(", "SET_SRC", "(", "x", ")", ",", "0", ")", "|", "regs_used", "(", "SET_DEST", "(", "x", ")", ",", "16", ")", ";", "case", "RETURN", ":", "return", "0x00ffff00", ";", "case", "CLOBBER", ":", "is_dest", "=", "1", ";", "break", ";", "case", "MEM", ":", "is_dest", "=", "0", ";", "break", ";", "case", "CALL", ":", "used", "|=", "0x00ff00f0", ";", "break", ";", "default", ":", "break", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "used", "|=", "regs_used", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ",", "is_dest", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "used", "|=", "regs_used", "(", "XEXP", "(", "x", ",", "i", ")", ",", "is_dest", ")", ";", "}", "return", "used", ";", "}", "</s>" ]

[ "Given", "a", "X", ",", "a", "pattern", "of", "an", "insn", "or", "a", "part", "of", "it", ",", "return", "a", "mask", "of", "used", "general", "registers", ".", "Bits", "0", "..", "15", "mean", "that", "the", "respective", "registers", "are", "used", "as", "inputs", "in", "the", "instruction", ".", "Bits", "16", "..", "31", "mean", "that", "the", "registers", "0", "..", "15", ",", "respectively", ",", "are", "used", "as", "outputs", ",", "or", "are", "clobbered", ".", "IS_DEST", "should", "be", "set", "to", "16", "if", "X", "is", "the", "destination", "of", "a", "SET", ",", "else", "to", "0", "." ]

[ "sh", "0", "16", "1", "0", "1", "0", "16", "1", "0", "1", "0", "0", "16", "0x00ffff00", "1", "0", "0x00ff00f0", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "aarch64_copy_one_block_and_progress_pointers", "(", "rtx", "*", "src", ",", "rtx", "*", "dst", ",", "machine_mode", "mode", ")", "{", "if", "(", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "256", ")", ")", "{", "mode", "=", "V4SImode", ";", "rtx", "reg1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "reg2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "*", "src", "=", "adjust_address", "(", "*", "src", ",", "mode", ",", "0", ")", ";", "*", "dst", "=", "adjust_address", "(", "*", "dst", ",", "mode", ",", "0", ")", ";", "emit_insn", "(", "aarch64_gen_load_pair", "(", "mode", ",", "reg1", ",", "*", "src", ",", "reg2", ",", "aarch64_progress_pointer", "(", "*", "src", ")", ")", ")", ";", "emit_insn", "(", "aarch64_gen_store_pair", "(", "mode", ",", "*", "dst", ",", "reg1", ",", "aarch64_progress_pointer", "(", "*", "dst", ")", ",", "reg2", ")", ")", ";", "*", "src", "=", "aarch64_move_pointer", "(", "*", "src", ",", "32", ")", ";", "*", "dst", "=", "aarch64_move_pointer", "(", "*", "dst", ",", "32", ")", ";", "return", ";", "}", "rtx", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "*", "src", "=", "adjust_address", "(", "*", "src", ",", "mode", ",", "0", ")", ";", "*", "dst", "=", "adjust_address", "(", "*", "dst", ",", "mode", ",", "0", ")", ";", "emit_move_insn", "(", "reg", ",", "*", "src", ")", ";", "emit_move_insn", "(", "*", "dst", ",", "reg", ")", ";", "*", "src", "=", "aarch64_progress_pointer", "(", "*", "src", ")", ";", "*", "dst", "=", "aarch64_progress_pointer", "(", "*", "dst", ")", ";", "}", "</s>" ]

[ "Copy", "one", "MODE", "sized", "block", "from", "SRC", "to", "DST", ",", "then", "progress", "SRC", "and", "DST", "by", "MODE", "bytes", "." ]

[ "aarch64", "256", "0", "0", "32", "32", "0", "0" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "assert", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", "&&", "\"shouldAssumeDSOLocal gave inconsistent answer\"", ")", ";", "return", "X86II", "::", "MO_DLLIMPORT", ";", "}", "const", "Function", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "isTargetELF", "(", ")", ")", "{", "if", "(", "is64Bit", "(", ")", "&&", "F", "&&", "(", "CallingConv", "::", "X86_RegCall", "==", "F", "->", "getCallingConv", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_PLT", ";", "}", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "\"shouldAssumeDSOLocal gave inconsistent answer\"", "X86II::MO_DLLIMPORT", "X86", "X86II::MO_GOTPCREL", "X86II::MO_PLT", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

[]

[ "<s>", "static", "bool", "sparc_can_output_mi_thunk", "(", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "vcall_offset", ">=", "-", "32768", "||", "!", "fixed_regs", "[", "5", "]", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "sparc_output_mi_thunk", "would", "be", "able", "to", "output", "the", "assembler", "code", "for", "the", "thunk", "function", "specified", "by", "the", "arguments", "it", "is", "passed", ",", "and", "false", "otherwise", "." ]

[ "sparc", "32768", "5" ]

[]

[ "<s>", "static", "scalar_int_mode", "sparc_cstore_mode", "(", "enum", "insn_code", "icode", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "TARGET_ARCH64", "?", "DImode", ":", "SImode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CSTORE_MODE", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "bool", "has_inlined_assembly", "(", "function", "*", "fn", ")", "{", "basic_block", "bb", ";", "gimple_stmt_iterator", "gsi", ";", "if", "(", "fn", "->", "cfg", "==", "NULL", ")", "return", "true", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "fn", ")", "for", "(", "gsi", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "gsi", ")", ";", "gsi_next", "(", "&", "gsi", ")", ")", "if", "(", "gimple_code", "(", "gsi_stmt", "(", "gsi", ")", ")", "==", "GIMPLE_ASM", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "function", "has", "inline", "assembly", "code", "or", "if", "we", "can", "not", "be", "certain", "that", "it", "does", "not", ".", "False", "if", "we", "know", "that", "there", "is", "no", "inline", "assembly", "." ]

[ "mips" ]

[]