Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "avr_popcount_each_byte", "(", "rtx", "xval", ",", "int", "n_bytes", ",", "int", "pop_mask", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xval", ")", ";", "if", "(", "VOIDmode", "==", "mode", ")", "mode", "=", "SImode", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_bytes", ";", "i", "++", ")", "{", "rtx", "xval8", "=", "simplify_gen_subreg", "(", "QImode", ",", "xval", ",", "mode", ",", "i", ")", ";", "unsigned", "int", "val8", "=", "UINTVAL", "(", "xval8", ")", "&", "GET_MODE_MASK", "(", "QImode", ")", ";", "if", "(", "(", "pop_mask", "&", "(", "1", "<<", "popcount_hwi", "(", "val8", ")", ")", ")", "==", "0", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Constraint", "helper", "function", ".", "XVAL", "is", "a", "CONST_INT", "or", "a", "CONST_DOUBLE", ".", "Return", "true", "if", "the", "least", "significant", "N_BYTES", "bytes", "of", "XVAL", "all", "have", "a", "popcount", "in", "POP_MASK", "and", "false", ",", "otherwise", ".", "POP_MASK", "represents", "a", "subset", "of", "integers", "which", "contains", "an", "integer", "N", "iff", "bit", "N", "of", "POP_MASK", "is", "set", "." ]

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

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "split", "(", "MachineInstr", "&", "MI", ",", "std", "::", "set", "<", "unsigned", ">", "&", "UpdRegs", ")", "{", "if", "(", "TfrLimitActive", ")", "{", "if", "(", "TfrCounter", ">=", "TfrLimit", ")", "return", "false", ";", "TfrCounter", "++", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nsplitting BB#\"", "<<", "MI", ".", "getParent", "(", ")", "->", "getNumber", "(", ")", "<<", "\": \"", "<<", "MI", ")", ";", "MachineOperand", "&", "MD", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "MP", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "MD", ".", "isDef", "(", ")", ")", ";", "unsigned", "DR", "=", "MD", ".", "getReg", "(", ")", ",", "DSR", "=", "MD", ".", "getSubReg", "(", ")", ";", "bool", "ReadUndef", "=", "MD", ".", "isUndef", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "At", "=", "MI", ";", "auto", "updateRegs", "=", "[", "&", "UpdRegs", "]", "(", "const", "MachineInstr", "&", "MI", ")", "->", "void", "{", "for", "(", "auto", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "Op", ".", "isReg", "(", ")", ")", "UpdRegs", ".", "insert", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", ";", "MachineOperand", "&", "ST", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "MachineOperand", "&", "SF", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "if", "(", "ST", ".", "isReg", "(", ")", "&&", "SF", ".", "isReg", "(", ")", ")", "{", "RegisterRef", "RT", "(", "ST", ")", ";", "if", "(", "RT", "==", "RegisterRef", "(", "SF", ")", ")", "{", "updateRegs", "(", "MI", ")", ";", "MI", ".", "setDesc", "(", "HII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ";", "unsigned", "S", "=", "getRegState", "(", "ST", ")", ";", "while", "(", "MI", ".", "getNumOperands", "(", ")", ">", "1", ")", "MI", ".", "RemoveOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "1", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstrBuilder", "(", "MF", ",", "MI", ")", ".", "addReg", "(", "RT", ".", "Reg", ",", "S", ",", "RT", ".", "Sub", ")", ";", "return", "true", ";", "}", "}", "MachineInstr", "*", "TfrT", "=", "genCondTfrFor", "(", "ST", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "true", ",", "ReadUndef", ",", "false", ")", ";", "MachineInstr", "*", "TfrF", "=", "genCondTfrFor", "(", "SF", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "false", ",", "ReadUndef", ",", "true", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrT", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrF", ")", ";", "updateRegs", "(", "MI", ")", ";", "removeInstr", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Split", "into", "substrings", "around", "the", "occurrences", "of", "a", "separator", "character", "." ]

[ "Hexagon", "Hexagon", "\"\\nsplitting BB#\"", "\": \"", "0", "1", "2", "3", "1", "1" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFreeAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DestAS", ")", "const", "{", "if", "(", "SrcAS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "true", ";", "const", "GCNTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "GCNTargetMachine", "&", ">", "(", "getTargetMachine", "(", ")", ")", ";", "return", "TM", ".", "isNoopAddrSpaceCast", "(", "SrcAS", ",", "DestAS", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "cast", "from", "SrcAS", "to", "DestAS", "is", "``", "cheap", "''", ",", "such", "that", "e.g", "." ]

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

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "const", "MCObjectFileInfo", "::", "Environment", "Format", "=", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getObjectFileType", "(", ")", ";", "bool", "IsMachO", "=", "Format", "==", "MCObjectFileInfo", "::", "IsMachO", ";", "bool", "IsCOFF", "=", "Format", "==", "MCObjectFileInfo", "::", "IsCOFF", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "SMLoc", "Loc", "=", "DirectiveID", ".", "getLoc", "(", ")", ";", "if", "(", "IDVal", "==", "\".cpu\"", ")", "return", "parseDirectiveCPU", "(", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".hword\"", ")", "return", "parseDirectiveWord", "(", "2", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "parseDirectiveWord", "(", "4", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".xword\"", ")", "return", "parseDirectiveWord", "(", "8", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".tlsdesccall\"", ")", "return", "parseDirectiveTLSDescCall", "(", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".ltorg\"", "||", "IDVal", "==", "\".pool\"", ")", "return", "parseDirectiveLtorg", "(", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".unreq\"", ")", "return", "parseDirectiveUnreq", "(", "Loc", ")", ";", "if", "(", "!", "IsMachO", "&&", "!", "IsCOFF", ")", "{", "if", "(", "IDVal", "==", "\".inst\"", ")", "return", "parseDirectiveInst", "(", "Loc", ")", ";", "}", "return", "parseDirectiveLOH", "(", "IDVal", ",", "Loc", ")", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "AArch64", "AArch64", "\".cpu\"", "\".hword\"", "2", "\".word\"", "4", "\".xword\"", "8", "\".tlsdesccall\"", "\".ltorg\"", "\".pool\"", "\".unreq\"", "\".inst\"" ]

[]

[ "<s>", "static", "void", "cris_conditional_register_usage", "(", "void", ")", "{", "if", "(", "TARGET_HAS_MUL_INSNS", ")", "fixed_regs", "[", "CRIS_MOF_REGNUM", "]", "=", "0", ";", "if", "(", "cris_cpu_version", "<", "8", ")", "reg_names", "[", "CRIS_CC0_REGNUM", "]", "=", "\"ccr\"", ";", "}", "</s>" ]

[ "The", "CONDITIONAL_REGISTER_USAGE", "worker", "." ]

[ "cris", "0", "8", "\"ccr\"" ]

[]

[ "<s>", "bool", "GBZ80PreEmit", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB" ]

[]

[ "<s>", "static", "int", "shiftr_zero", "(", "HOST_WIDE_INT", "*", "v", ")", "{", "unsigned", "HOST_WIDE_INT", "tmp", "=", "*", "v", ";", "unsigned", "HOST_WIDE_INT", "sgn", ";", "int", "n", "=", "0", ";", "if", "(", "tmp", "==", "0", ")", "return", "0", ";", "sgn", "=", "tmp", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "(", "HOST_BITS_PER_WIDE_INT", "-", "1", ")", ")", ";", "while", "(", "(", "tmp", "&", "0x1", ")", "==", "0", "&&", "n", "<=", "32", ")", "{", "tmp", "=", "(", "tmp", ">>", "1", ")", "|", "sgn", ";", "n", "++", ";", "}", "*", "v", "=", "tmp", ";", "return", "n", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "consecutive", "least", "significant", "zeros", "in", "the", "binary", "representation", "of", "*", "V.", "We", "modify", "*", "V", "to", "contain", "the", "original", "value", "arithmetically", "shifted", "right", "by", "the", "number", "of", "zeroes", "." ]

[ "bfin", "0", "0", "0", "1", "1", "0x1", "0", "32", "1" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createMicroMipsSizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", ")", ")", ";", "addPass", "(", "createMipsHazardSchedule", "(", ")", ")", ";", "addPass", "(", "createMipsLongBranchPass", "(", ")", ")", ";", "addPass", "(", "createMipsConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "int", "h8300_length_from_table", "(", "rtx", "op1", ",", "rtx", "op2", ",", "const", "h8300_length_table", "*", "table", ")", "{", "enum", "h8300_operand_class", "op1_class", ",", "op2_class", ";", "unsigned", "int", "size", ",", "immediate_length", ";", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op1", ")", ")", ";", "immediate_length", "=", "(", "h8300_classify_operand", "(", "op1", ",", "size", ",", "&", "op1_class", ")", "+", "h8300_classify_operand", "(", "op2", ",", "size", ",", "&", "op2_class", ")", ")", ";", "return", "immediate_length", "+", "(", "*", "table", ")", "[", "op1_class", "-", "1", "]", "[", "op2_class", "]", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "the", "instruction", "described", "by", "TABLE", "given", "that", "its", "operands", "are", "OP1", "and", "OP2", ".", "OP1", "must", "be", "an", "h8300_dst_operand", "and", "OP2", "must", "be", "an", "h8300_src_operand", "." ]

[ "h8300", "1" ]

[]

[ "<s>", "const", "MCExpr", "*", "M680x0TargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "const", "MachineFunction", "*", "MF", ",", "unsigned", "JTI", ",", "MCContext", "&", "Ctx", ")", "const", "{", "return", "MCSymbolRefExpr", "::", "create", "(", "MF", "->", "getJTISymbol", "(", "JTI", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "</s>" ]

[ "This", "returns", "the", "relocation", "base", "for", "the", "given", "PIC", "jumptable", ",", "the", "same", "as", "getPICJumpTableRelocBase", ",", "but", "as", "an", "MCExpr", "." ]

[ "M680x0", "M680x0" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "GCNSubtarget", "*", "CallerST", "=", "static_cast", "<", "const", "GCNSubtarget", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", ")", ";", "const", "GCNSubtarget", "*", "CalleeST", "=", "static_cast", "<", "const", "GCNSubtarget", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "CallerST", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "CalleeST", "->", "getFeatureBits", "(", ")", ";", "FeatureBitset", "RealCallerBits", "=", "CallerBits", "&", "~", "InlineFeatureIgnoreList", ";", "FeatureBitset", "RealCalleeBits", "=", "CalleeBits", "&", "~", "InlineFeatureIgnoreList", ";", "if", "(", "(", "RealCallerBits", "&", "RealCalleeBits", ")", "!=", "RealCalleeBits", ")", "return", "false", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CallerMode", "(", "*", "Caller", ",", "*", "CallerST", ")", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CalleeMode", "(", "*", "Callee", ",", "*", "CalleeST", ")", ";", "return", "CallerMode", ".", "isInlineCompatible", "(", "CalleeMode", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "AMDGPU", "AMDGPU::SIModeRegisterDefaults", "AMDGPU::SIModeRegisterDefaults" ]

[]

[ "<s>", "unsigned", "char", "ARM64Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "bool", "isDecl", "=", "GV", "->", "hasAvailableExternallyLinkage", "(", ")", ";", "if", "(", "GV", "->", "isDeclaration", "(", ")", "&&", "!", "GV", "->", "isMaterializable", "(", ")", ")", "isDecl", "=", "true", ";", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "isTargetMachO", "(", ")", ")", "return", "ARM64II", "::", "MO_GOT", ";", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "&&", "GV", "->", "isWeakForLinker", "(", ")", "&&", "isDecl", ")", "return", "ARM64II", "::", "MO_GOT", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", "&&", "GV", "->", "hasDefaultVisibility", "(", ")", ")", "{", "if", "(", "isTargetMachO", "(", ")", ")", "return", "(", "isDecl", "||", "GV", "->", "isWeakForLinker", "(", ")", ")", "?", "ARM64II", "::", "MO_GOT", ":", "ARM64II", "::", "MO_NO_FLAG", ";", "else", "return", "GV", "->", "hasLocalLinkage", "(", ")", "?", "ARM64II", "::", "MO_NO_FLAG", ":", "ARM64II", "::", "MO_GOT", ";", "}", "return", "ARM64II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "ARM64", "ARM64", "ARM64II::MO_GOT", "ARM64II::MO_GOT", "ARM64II::MO_GOT", "ARM64II::MO_NO_FLAG", "ARM64II::MO_NO_FLAG", "ARM64II::MO_GOT", "ARM64II::MO_NO_FLAG" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_uzp", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "odd", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out", ",", "in0", ",", "in1", ",", "x", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "vmode", ")", ">", "8", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "0", ")", "odd", "=", "0", ";", "else", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "1", ")", "odd", "=", "1", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "(", "i", "*", "2", "+", "odd", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "elt", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "odd", "=", "!", "odd", ";", "}", "out", "=", "d", "->", "target", ";", "if", "(", "odd", ")", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_uzp2v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_uzp2v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_uzp2v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_uzp2v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_uzp2v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_uzp2v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_uzp2v2di", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_aarch64_uzp2v4hf", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_aarch64_uzp2v8hf", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_uzp2v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_uzp2v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_uzp2v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "else", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_uzp1v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_uzp1v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_uzp1v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_uzp1v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_uzp1v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_uzp1v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_uzp1v2di", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_aarch64_uzp1v4hf", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_aarch64_uzp1v8hf", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_uzp1v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_uzp1v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_uzp1v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "emit_insn", "(", "gen", "(", "out", ",", "in0", ",", "in1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "suitable", "for", "the", "UZP", "instructions", "." ]

[ "aarch64", "8", "0", "0", "0", "0", "1", "1", "1", "2", "1", "0", "2" ]

[]

[ "<s>", "static", "void", "ia64_emit_insn_before", "(", "rtx", "insn", ",", "rtx_insn", "*", "before", ")", "{", "emit_insn_before", "(", "insn", ",", "before", ")", ";", "}", "</s>" ]

[ "Like", "emit_insn_before", ",", "but", "skip", "cycle_display", "insns", ".", "This", "makes", "the", "assembly", "output", "a", "bit", "prettier", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "GCNUpwardRPTracker", "::", "recede", "(", "const", "MachineInstr", "&", "MI", ")", "{", "assert", "(", "MRI", "&&", "\"call reset first\"", ")", ";", "LastTrackedMI", "=", "&", "MI", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "return", ";", "auto", "const", "RegUses", "=", "collectVirtualRegUses", "(", "MI", ",", "LIS", ",", "*", "MRI", ")", ";", "auto", "AtMIPressure", "=", "CurPressure", ";", "for", "(", "const", "auto", "&", "U", ":", "RegUses", ")", "{", "auto", "LiveMask", "=", "LiveRegs", "[", "U", ".", "RegUnit", "]", ";", "AtMIPressure", ".", "inc", "(", "U", ".", "RegUnit", ",", "LiveMask", ",", "LiveMask", "|", "U", ".", "LaneMask", ",", "*", "MRI", ")", ";", "}", "MaxPressure", "=", "max", "(", "AtMIPressure", ",", "MaxPressure", ")", ";", "for", "(", "const", "auto", "&", "MO", ":", "MI", ".", "defs", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", "||", "MO", ".", "isDead", "(", ")", ")", "continue", ";", "auto", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "auto", "I", "=", "LiveRegs", ".", "find", "(", "Reg", ")", ";", "if", "(", "I", "==", "LiveRegs", ".", "end", "(", ")", ")", "continue", ";", "auto", "&", "LiveMask", "=", "I", "->", "second", ";", "auto", "PrevMask", "=", "LiveMask", ";", "LiveMask", "&=", "~", "getDefRegMask", "(", "MO", ",", "*", "MRI", ")", ";", "CurPressure", ".", "inc", "(", "Reg", ",", "PrevMask", ",", "LiveMask", ",", "*", "MRI", ")", ";", "if", "(", "LiveMask", ".", "none", "(", ")", ")", "LiveRegs", ".", "erase", "(", "I", ")", ";", "}", "for", "(", "const", "auto", "&", "U", ":", "RegUses", ")", "{", "auto", "&", "LiveMask", "=", "LiveRegs", "[", "U", ".", "RegUnit", "]", ";", "auto", "PrevMask", "=", "LiveMask", ";", "LiveMask", "|=", "U", ".", "LaneMask", ";", "CurPressure", ".", "inc", "(", "U", ".", "RegUnit", ",", "PrevMask", ",", "LiveMask", ",", "*", "MRI", ")", ";", "}", "assert", "(", "CurPressure", "==", "getRegPressure", "(", "*", "MRI", ",", "LiveRegs", ")", ")", ";", "}", "</s>" ]

[ "Recede", "across", "the", "previous", "instruction", "." ]

[ "AMDGPU", "\"call reset first\"" ]

[]

[ "<s>", "static", "rtx", "nvptx_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", ")", "{", "if", "(", "!", "cfun", "||", "!", "cfun", "->", "machine", "->", "doing_call", ")", "return", "gen_rtx_REG", "(", "mode", ",", "NVPTX_RETURN_REGNUM", ")", ";", "return", "gen_reg_rtx", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBCALL_VALUE", "." ]

[ "nvptx" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_PCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<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>", "SDValue", "AGCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "report_fatal_error", "(", "\"unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "IsVarArg", ")", "report_fatal_error", "(", "\"vararg not yet supported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_AGC", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "report_fatal_error", "(", "\"stack arguments not yet supported\"", ")", ";", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "RegVT", "!=", "MVT", "::", "i32", "&&", "RegVT", "!=", "MVT", "::", "i16", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ")", ";", "report_fatal_error", "(", "\"unhandled argument type\"", ")", ";", "}", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "RegVT", "==", "MVT", "::", "i32", "?", "&", "AGC", "::", "MMD10RegClass", ":", "&", "AGC", "::", "MM10RegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgIn", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgIn", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "ISD::InputArg", "\"unsupported calling convention\"", "\"vararg not yet supported\"", "16", "AGC", "\"stack arguments not yet supported\"", "MVT::i32", "MVT::i16", "\"LowerFormalArguments Unhandled argument type: \"", "\"\\n\"", "\"unhandled argument type\"", "MVT::i32", "AGC::MMD10RegClass", "AGC::MM10RegClass" ]

[]

[ "<s>", "static", "void", "mmix_print_operand_address", "(", "FILE", "*", "stream", ",", "rtx", "x", ")", "{", "if", "(", "REG_P", "(", "x", ")", ")", "{", "fprintf", "(", "stream", ",", "\"%s,0\"", ",", "reg_names", "[", "MMIX_OUTPUT_REGNO", "(", "REGNO", "(", "x", ")", ")", "]", ")", ";", "return", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "x1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "x2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "REG_P", "(", "x1", ")", ")", "{", "fprintf", "(", "stream", ",", "\"%s,\"", ",", "reg_names", "[", "MMIX_OUTPUT_REGNO", "(", "REGNO", "(", "x1", ")", ")", "]", ")", ";", "if", "(", "REG_P", "(", "x2", ")", ")", "{", "fprintf", "(", "stream", ",", "\"%s\"", ",", "reg_names", "[", "MMIX_OUTPUT_REGNO", "(", "REGNO", "(", "x2", ")", ")", "]", ")", ";", "return", ";", "}", "else", "if", "(", "satisfies_constraint_I", "(", "x2", ")", ")", "{", "output_addr_const", "(", "stream", ",", "x2", ")", ";", "return", ";", "}", "}", "}", "if", "(", "TARGET_BASE_ADDRESSES", "&&", "mmix_legitimate_constant_p", "(", "Pmode", ",", "x", ")", ")", "{", "output_addr_const", "(", "stream", ",", "x", ")", ";", "return", ";", "}", "fatal_insn", "(", "\"MMIX Internal: This is not a recognized address\"", ",", "x", ")", ";", "}", "</s>" ]

[ "PRINT_OPERAND_ADDRESS", "." ]

[ "mmix", "\"%s,0\"", "0", "1", "\"%s,\"", "\"%s\"", "\"MMIX Internal: This is not a recognized address\"" ]

[]

[ "<s>", "static", "X86Operand", "CreateMem", "(", "unsigned", "SegReg", ",", "MCValue", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "X86Operand", "Res", ";", "Res", ".", "Kind", "=", "Memory", ";", "Res", ".", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", ".", "Mem", ".", "Disp", "=", "Disp", ";", "Res", ".", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", ".", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", ".", "Mem", ".", "Scale", "=", "Scale", ";", "return", "Res", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "X86", "X86", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86" ]

[]

[ "<s>", "rtx", "mt_function_value", "(", "tree", "valtype", ",", "enum", "machine_mode", "mode", ",", "tree", "func_decl", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "(", "mode", ")", "==", "DImode", "||", "(", "mode", ")", "==", "DFmode", ")", "return", "gen_rtx_MEM", "(", "mode", ",", "gen_rtx_REG", "(", "mode", ",", "RETURN_VALUE_REGNUM", ")", ")", ";", "if", "(", "valtype", ")", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "RETURN_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Handle", "FUNCTION_VALUE", ",", "FUNCTION_OUTGOING_VALUE", ",", "and", "LIBCALL_VALUE", "macros", "." ]

[ "mt" ]

[]

[ "<s>", "M68kSubtarget", "::", "M68kSubtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "M68kTargetMachine", "&", "TM", ")", ":", "M68kGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "UserReservedRegister", "(", "M68k", "::", "NUM_TARGET_REGS", ")", ",", "TM", "(", "TM", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "TT", ",", "FS", ",", "TM", ")", ")", ",", "FrameLowering", "(", "*", "this", ",", "this", "->", "getStackAlignment", "(", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "TargetTriple", "(", "TT", ")", "{", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "M68k", "M68k", "M68k::NUM_TARGET_REGS" ]

[]

[ "<s>", "void", "MSP430AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Asm", ".", "getContext", "(", ")", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "alignTo", "(", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ",", "8", ")", "/", "8", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "8", "8", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "static", "rtx", "ix86_erase_embedded_rounding", "(", "rtx", "pat", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "INSN", ")", "pat", "=", "PATTERN", "(", "pat", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "gcc_assert", "(", "XVECLEN", "(", "src", ",", "0", ")", "==", "2", ")", ";", "rtx", "p0", "=", "XVECEXP", "(", "src", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "src", ")", "==", "UNSPEC", "&&", "XINT", "(", "src", ",", "1", ")", "==", "UNSPEC_EMBEDDED_ROUNDING", ")", ";", "rtx", "res", "=", "gen_rtx_SET", "(", "SET_DEST", "(", "pat", ")", ",", "p0", ")", ";", "return", "res", ";", "}", "</s>" ]

[ "Transform", "pattern", "of", "following", "layout", ":", "(", "parallel", "[", "set", "(", "A", "B", ")", "(", "unspec", "[", "C", "]", "UNSPEC_EMBEDDED_ROUNDING", ")", "]", ")", "]", ")", "into", ":", "(", "set", "(", "A", "B", ")", ")", "Or", ":", "(", "parallel", "[", "A", "B", "...", "(", "unspec", "[", "C", "]", "UNSPEC_EMBEDDED_ROUNDING", ")", "...", "]", ")", "into", ":", "(", "parallel", "[", "A", "B", "...", "]", ")" ]

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

[]

[ "<s>", "void", "func_fma_steering", "::", "analyze", "(", ")", "{", "int", "i", ",", "n_blocks", ",", "*", "bb_dfs_preorder", ";", "basic_block", "bb", ";", "rtx_insn", "*", "insn", ";", "bb_dfs_preorder", "=", "XNEWVEC", "(", "int", ",", "last_basic_block_for_fn", "(", "cfun", ")", ")", ";", "n_blocks", "=", "pre_and_rev_post_order_compute", "(", "bb_dfs_preorder", ",", "NULL", ",", "false", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_blocks", ";", "i", "++", ")", "{", "bb", "=", "BASIC_BLOCK_FOR_FN", "(", "cfun", ",", "bb_dfs_preorder", "[", "i", "]", ")", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "operand_rr_info", "*", "dest_op_info", ";", "struct", "du_chain", "*", "chain", "=", "NULL", ";", "unsigned", "dest_regno", ";", "fma_forest", "*", "forest", "=", "NULL", ";", "du_head_p", "head", "=", "NULL", ";", "int", "i", ";", "if", "(", "!", "is_fmul_fmac_insn", "(", "insn", ",", "true", ")", ")", "continue", ";", "dest_op_info", "=", "insn_rr", "[", "INSN_UID", "(", "insn", ")", "]", ".", "op_info", ";", "dest_regno", "=", "REGNO", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "dest_op_info", "->", "n_chains", ";", "i", "++", ")", "{", "if", "(", "dest_op_info", "->", "heads", "[", "i", "]", "->", "regno", "!=", "dest_regno", ")", "continue", ";", "head", "=", "dest_op_info", "->", "heads", "[", "i", "]", ";", "if", "(", "!", "head", "->", "first", ")", "head", "=", "regrename_chain_from_id", "(", "head", "->", "id", ")", ";", "forest", "=", "NULL", ";", "for", "(", "chain", "=", "head", "->", "first", ";", "chain", ";", "chain", "=", "chain", "->", "next_use", ")", "{", "fma_node", "*", "*", "fma_slot", ";", "if", "(", "!", "is_fmul_fmac_insn", "(", "chain", "->", "insn", ",", "true", ")", ")", "continue", ";", "if", "(", "chain", "->", "loc", "!=", "&", "SET_DEST", "(", "PATTERN", "(", "chain", "->", "insn", ")", ")", ")", "continue", ";", "if", "(", "chain", "->", "insn", "==", "insn", ")", "break", ";", "fma_slot", "=", "this", "->", "m_insn_fma_head_map", "->", "get", "(", "chain", "->", "insn", ")", ";", "if", "(", "fma_slot", "&&", "(", "*", "fma_slot", ")", "->", "get_children", "(", ")", ")", "forest", "=", "(", "*", "fma_slot", ")", "->", "get_forest", "(", ")", ";", "}", "if", "(", "chain", ")", "break", ";", "}", "if", "(", "i", "<", "dest_op_info", "->", "n_chains", ")", "this", "->", "analyze_fma_fmul_insn", "(", "forest", ",", "chain", ",", "head", ")", ";", "}", "}", "free", "(", "bb_dfs_preorder", ")", ";", "if", "(", "dump_file", ")", "this", "->", "dfs", "(", "dump_forest_info", ",", "dump_tree_root_info", ",", "dump_tree_node_info", ",", "false", ")", ";", "}", "</s>" ]

[ "Count", "how", "many", "times", "each", "regno", "is", "referenced", "as", "base", "address", "for", "a", "memory", "access", "." ]

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

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "createVR", "(", "MachineFunction", "*", "MF", ",", "MVT", "VT", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", ";", "if", "(", "VT", "==", "MVT", "::", "i1", ")", "{", "TRC", "=", "&", "Hexagon", "::", "PredRegsRegClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "{", "TRC", "=", "&", "Hexagon", "::", "IntRegsRegClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i64", "||", "VT", "==", "MVT", "::", "f64", ")", "{", "TRC", "=", "&", "Hexagon", "::", "DoubleRegsRegClass", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot handle this register class\"", ")", ";", "}", "unsigned", "NewReg", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "return", "NewReg", ";", "}", "</s>" ]

[ "HexagonInstrInfo", "specifics", "." ]

[ "Hexagon", "Hexagon", "MVT::i1", "Hexagon::PredRegsRegClass", "MVT::i32", "MVT::f32", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "Hexagon::DoubleRegsRegClass", "\"Cannot handle this register class\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "auto", "E", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "E", ")", "return", "false", ";", "while", "(", "I", "!=", "E", "&&", "!", "I", "->", "isBranch", "(", ")", "&&", "!", "I", "->", "isReturn", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_MASK_BRANCH", ":", "case", "AMDGPU", "::", "S_MOV_B64_term", ":", "case", "AMDGPU", "::", "S_XOR_B64_term", ":", "case", "AMDGPU", "::", "S_ANDN2_B64_term", ":", "case", "AMDGPU", "::", "S_MOV_B32_term", ":", "case", "AMDGPU", "::", "S_XOR_B32_term", ":", "case", "AMDGPU", "::", "S_OR_B32_term", ":", "case", "AMDGPU", "::", "S_ANDN2_B32_term", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "case", "AMDGPU", "::", "SI_ELSE", ":", "case", "AMDGPU", "::", "SI_KILL_I1_TERMINATOR", ":", "case", "AMDGPU", "::", "SI_KILL_F32_COND_IMM_TERMINATOR", ":", "return", "true", ";", "default", ":", "llvm_unreachable", "(", "\"unexpected non-branch terminator inst\"", ")", ";", "}", "++", "I", ";", "}", "if", "(", "I", "==", "E", ")", "return", "false", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "return", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ";", "++", "I", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "true", ";", "if", "(", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ")", "return", "true", ";", "MachineBasicBlock", "*", "MaskBrDest", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "if", "(", "TBB", "!=", "MaskBrDest", "||", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "auto", "Pred", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "return", "(", "Pred", "!=", "EXECZ", "&&", "Pred", "!=", "EXECNZ", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_MASK_BRANCH", "AMDGPU::SI_MASK_BRANCH", "AMDGPU::S_MOV_B64_term", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_ANDN2_B64_term", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_XOR_B32_term", "AMDGPU::S_OR_B32_term", "AMDGPU::S_ANDN2_B32_term", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_KILL_I1_TERMINATOR", "AMDGPU::SI_KILL_F32_COND_IMM_TERMINATOR", "\"unexpected non-branch terminator inst\"", "AMDGPU::SI_MASK_BRANCH", "0", "0" ]

[]

[ "<s>", "static", "int", "frv_check_constant_argument", "(", "enum", "insn_code", "icode", ",", "int", "opnum", ",", "rtx", "opval", ")", "{", "if", "(", "GET_CODE", "(", "opval", ")", "!=", "CONST_INT", ")", "{", "error", "(", "\"%qs expects a constant argument\"", ",", "insn_data", "[", "icode", "]", ".", "name", ")", ";", "return", "FALSE", ";", "}", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "opval", ",", "VOIDmode", ")", ")", "{", "error", "(", "\"constant argument out of range for %qs\"", ",", "insn_data", "[", "icode", "]", ".", "name", ")", ";", "return", "FALSE", ";", "}", "return", "TRUE", ";", "}", "</s>" ]

[ "Return", "true", "if", "OPVAL", "can", "be", "used", "for", "operand", "OPNUM", "of", "instruction", "ICODE", ".", "The", "instruction", "should", "require", "a", "constant", "operand", "of", "some", "sort", ".", "The", "function", "prints", "an", "error", "if", "OPVAL", "is", "not", "valid", "." ]

[ "frv", "\"%qs expects a constant argument\"", "\"constant argument out of range for %qs\"" ]

[]

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

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

[ "X86", "\"X86 Intel-Style Assembly Printer\"" ]

[]

[ "<s>", "rtx", "gen_df_reg", "(", "rtx", "reg", ",", "int", "low", ")", "{", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "(", "WORDS_BIG_ENDIAN", "==", "0", ")", "^", "(", "low", "!=", "0", ")", ")", "regno", "+=", "(", "TARGET_ARCH64", "&&", "regno", "<", "32", ")", "?", "1", ":", "2", ";", "return", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Generate", "a", "DFmode", "part", "of", "a", "hard", "TFmode", "register", ".", "REG", "is", "the", "TFmode", "hard", "register", ",", "LOW", "is", "1", "for", "the", "low", "64bit", "of", "the", "register", "and", "0", "otherwise", "." ]

[ "sparc", "0", "0", "32", "1", "2" ]

[]

[ "<s>", "bool", "AMDGPUSimplifyLibCalls", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "auto", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AMDIC: process function \"", ";", "F", ".", "printAsOperand", "(", "dbgs", "(", ")", ",", "false", ",", "F", ".", "getParent", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", ")", ";", "if", "(", "!", "EnablePreLink", ")", "Changed", "|=", "setFastFlags", "(", "F", ",", "Options", ")", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "!", "CI", ")", "continue", ";", "Function", "*", "Callee", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "Callee", "==", "0", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AMDIC: try folding \"", "<<", "*", "CI", "<<", "\"\\n\"", ";", "dbgs", "(", ")", ".", "flush", "(", ")", ")", ";", "if", "(", "Simplifier", ".", "fold", "(", "CI", ",", "AA", ")", ")", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"AMDIC: process function \"", "0", "\"AMDIC: try folding \"", "\"\\n\"" ]

[]

[ "<s>", "static", "rtx", "sched_get_operand", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ")", "{", "int", "i", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "gcc_unreachable", "(", ")", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "if", "(", "opx_p", ")", "i", "=", "get_attr_opx", "(", "insn", ")", ";", "else", "i", "=", "get_attr_opy", "(", "insn", ")", ";", "if", "(", "i", ">=", "recog_data", ".", "n_operands", ")", "return", "NULL", ";", "return", "recog_data", ".", "operand", "[", "i", "]", ";", "}", "</s>" ]

[ "Return", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "operand", "of", "INSN", "." ]

[ "m68k", "0" ]

[]

[ "<s>", "static", "rtx_insn", "*", "rs6000_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "machine_mode", ">", "&", ",", "vec", "<", "const", "char", "*", ">", "&", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "SImode", ",", "CA_REGNO", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "CA_REGNO", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_MD_ASM_ADJUST", ".", "All", "asm", "statements", "are", "considered", "to", "clobber", "the", "XER", "[", "CA", "]", "bit", "because", "clobbering", "that", "bit", "without", "telling", "the", "compiler", "worked", "just", "fine", "with", "versions", "of", "GCC", "before", "GCC", "5", ",", "and", "breaking", "a", "lot", "of", "older", "code", "in", "ways", "that", "are", "hard", "to", "track", "down", "is", "not", "such", "a", "great", "idea", "." ]

[ "rs6000" ]

[]

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

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

[ "AArch64", "\"AArch64 Assembly Printer\"" ]

[]

[ "<s>", "char", "*", "construct_save_jarl", "(", "rtx", "op", ")", "{", "int", "count", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "int", "stack_bytes", ";", "unsigned", "long", "int", "mask", ";", "unsigned", "long", "int", "first", ";", "unsigned", "long", "int", "last", ";", "int", "i", ";", "static", "char", "buff", "[", "100", "]", ";", "if", "(", "count", "<=", "(", "TARGET_LONG_CALLS", "?", "3", ":", "2", ")", ")", "{", "error", "(", "\"bogus JARL construction: %d\"", ",", "count", ")", ";", "return", "NULL", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "0", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "stack_bytes", "=", "INTVAL", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "1", ")", ")", ";", "stack_bytes", "+=", "(", "count", "-", "(", "TARGET_LONG_CALLS", "?", "3", ":", "2", ")", ")", "*", "4", ";", "if", "(", "stack_bytes", "!=", "0", ")", "{", "error", "(", "\"bad amount of stack space removal: %d\"", ",", "stack_bytes", ")", ";", "return", "NULL", ";", "}", "mask", "=", "0", ";", "for", "(", "i", "=", "1", ";", "i", "<", "count", "-", "(", "TARGET_LONG_CALLS", "?", "2", ":", "1", ")", ";", "i", "++", ")", "{", "rtx", "vector_element", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "vector_element", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "vector_element", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "register_is_ok_for_epilogue", "(", "SET_SRC", "(", "vector_element", ")", ",", "SImode", ")", ")", ";", "mask", "|=", "1", "<<", "REGNO", "(", "SET_SRC", "(", "vector_element", ")", ")", ";", "}", "for", "(", "first", "=", "0", ";", "first", "<", "32", ";", "first", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "first", ")", ")", "break", ";", "}", "gcc_assert", "(", "first", "<", "32", ")", ";", "if", "(", "mask", "&", "(", "1", "<<", "LINK_POINTER_REGNUM", ")", ")", "{", "last", "=", "LINK_POINTER_REGNUM", ";", "}", "else", "{", "gcc_assert", "(", "!", "stack_bytes", ")", ";", "gcc_assert", "(", "mask", "&", "(", "1", "<<", "29", ")", ")", ";", "last", "=", "29", ";", "}", "if", "(", "TARGET_LONG_CALLS", ")", "{", "char", "name", "[", "40", "]", ";", "if", "(", "first", "==", "last", ")", "sprintf", "(", "name", ",", "\"__save_%s\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "name", ",", "\"__save_%s_%s\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "if", "(", "TARGET_V850E3V5_UP", ")", "sprintf", "(", "buff", ",", "\"mov hilo(%s), r11\\n\\tjarl [r11], r10\"", ",", "name", ")", ";", "else", "sprintf", "(", "buff", ",", "\"movhi hi(%s), r0, r11\\n\\tmovea lo(%s), r11, r11\\n\\tjarl .+4, r10\\n\\tadd 4, r10\\n\\tjmp r11\"", ",", "name", ",", "name", ")", ";", "}", "else", "{", "if", "(", "first", "==", "last", ")", "sprintf", "(", "buff", ",", "\"jarl __save_%s, r10\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "buff", ",", "\"jarl __save_%s_%s, r10\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "}", "return", "buff", ";", "}", "</s>" ]

[ "Construct", "a", "JARL", "instruction", "to", "a", "routine", "that", "will", "perform", "the", "equivalent", "of", "the", "RTL", "passed", "as", "a", "parameter", ".", "This", "RTL", "is", "a", "function", "prologue", "that", "saves", "some", "of", "the", "registers", "r20", "-", "r31", "onto", "the", "stack", ",", "and", "possibly", "acquires", "some", "stack", "space", "as", "well", ".", "The", "code", "has", "already", "verified", "that", "the", "RTL", "matches", "these", "requirements", "." ]

[ "v850", "0", "100", "3", "2", "\"bogus JARL construction: %d\"", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "1", "3", "2", "4", "0", "\"bad amount of stack space removal: %d\"", "0", "1", "2", "1", "0", "1", "0", "32", "1", "32", "1", "1", "29", "29", "40", "\"__save_%s\"", "\"__save_%s_%s\"", "\"mov hilo(%s), r11\\n\\tjarl [r11], r10\"", "\"movhi hi(%s), r0, r11\\n\\tmovea lo(%s), r11, r11\\n\\tjarl .+4, r10\\n\\tadd 4, r10\\n\\tjmp r11\"", "\"jarl __save_%s, r10\"", "\"jarl __save_%s_%s, r10\"" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "Imm", ">=", "-", "512", "&&", "Imm", "<=", "511", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "Hexagon", "Hexagon", "512", "511" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "setExecutionDomain", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Domain", ")", "const", "{", "assert", "(", "Domain", ">", "0", "&&", "Domain", "<", "4", "&&", "\"Invalid execution domain\"", ")", ";", "uint16_t", "dom", "=", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "assert", "(", "dom", "&&", "\"Not an SSE instruction\"", ")", ";", "const", "unsigned", "*", "table", "=", "lookup", "(", "MI", "->", "getOpcode", "(", ")", ",", "dom", ")", ";", "assert", "(", "table", "&&", "\"Cannot change domain\"", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "table", "[", "Domain", "-", "1", "]", ")", ")", ";", "}", "</s>" ]

[ "Change", "the", "opcode", "of", "MI", "to", "execute", "in", "Domain", "." ]

[ "X86", "X86", "0", "4", "\"Invalid execution domain\"", "X86II::SSEDomainShift", "3", "\"Not an SSE instruction\"", "\"Cannot change domain\"", "1" ]

[]

[ "<s>", "virtual", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCInstFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "R600" ]

[]

[ "<s>", "SDValue", "HexagonSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "bool", "MustPreserveCheriCapabilities", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "AlwaysInline", "||", "Alignment", "<", "Align", "(", "4", ")", "||", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "uint64_t", "SizeVal", "=", "ConstantSize", "->", "getZExtValue", "(", ")", ";", "if", "(", "SizeVal", "<", "32", "||", "(", "SizeVal", "%", "8", ")", "!=", "0", ")", "return", "SDValue", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "const", "char", "*", "SpecialMemcpyName", "=", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", ";", "const", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "bool", "LongCalls", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "useLongCalls", "(", ")", ";", "unsigned", "Flags", "=", "LongCalls", "?", "HexagonII", "::", "HMOTF_ConstExtended", ":", "0", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setLibCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getTargetExternalFunctionSymbol", "(", "SpecialMemcpyName", ",", "Flags", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "4", "32", "8", "0", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", "Hexagon", "HexagonII::HMOTF_ConstExtended", "0" ]

[]

[ "<s>", "void", "M680x0InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ";", "if", "(", "M680x0", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "M680x0", "::", "MOV32rr", ";", "else", "if", "(", "M680x0", "::", "XR16RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "M680x0", "::", "MOV16rr", ";", "else", "if", "(", "M680x0", "::", "DR8RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "M680x0", "::", "MOV8dd", ";", "}", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "MachineInstrBuilder", "MIB", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "MI", ")", ";", "if", "(", "M680x0", "::", "DR8RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "M680x0", "::", "XR16RegClass", ".", "contains", "(", "DstReg", ")", ")", "{", "Opc", "=", "M680x0", "::", "MOVXd16d8", ";", "}", "else", "if", "(", "M680x0", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ")", ")", "{", "Opc", "=", "M680x0", "::", "MOVXd32d8", ";", "}", "}", "else", "if", "(", "M680x0", "::", "XR16RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "M680x0", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ")", ")", "{", "Opc", "=", "M680x0", "::", "MOVXd32d16", ";", "}", "}", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "bool", "FromCCR", "=", "SrcReg", "==", "M680x0", "::", "CCR", ";", "bool", "FromSR", "=", "SrcReg", "==", "M680x0", "::", "SR", ";", "bool", "ToCCR", "=", "DstReg", "==", "M680x0", "::", "CCR", ";", "bool", "ToSR", "=", "DstReg", "==", "M680x0", "::", "SR", ";", "if", "(", "FromCCR", ")", "{", "assert", "(", "M680x0", "::", "DR8RegClass", ".", "contains", "(", "DstReg", ")", "&&", "\"Need DR8 register to copy CCR\"", ")", ";", "Opc", "=", "M680x0", "::", "MOV8dc", ";", "}", "else", "if", "(", "ToCCR", ")", "{", "assert", "(", "M680x0", "::", "DR8RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "\"Need DR8 register to copy CCR\"", ")", ";", "Opc", "=", "M680x0", "::", "MOV8cd", ";", "}", "else", "if", "(", "FromSR", "||", "ToSR", ")", "{", "llvm_unreachable", "(", "\"Cannot emit SR copy instruction\"", ")", ";", "}", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cannot copy \"", "<<", "RI", ".", "getName", "(", "SrcReg", ")", "<<", "\" to \"", "<<", "RI", ".", "getName", "(", "DstReg", ")", "<<", "'\\n'", ")", ";", "llvm_unreachable", "(", "\"Cannot emit physreg copy instruction\"", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "0", "M680x0::XR32RegClass", "M680x0::MOV32rr", "M680x0::XR16RegClass", "M680x0::MOV16rr", "M680x0::DR8RegClass", "M680x0::MOV8dd", "M680x0::DR8RegClass", "M680x0::XR16RegClass", "M680x0::MOVXd16d8", "M680x0::XR32RegClass", "M680x0::MOVXd32d8", "M680x0::XR16RegClass", "M680x0::XR32RegClass", "M680x0::MOVXd32d16", "M680x0::CCR", "M680x0::SR", "M680x0::CCR", "M680x0::SR", "M680x0::DR8RegClass", "\"Need DR8 register to copy CCR\"", "M680x0::MOV8dc", "M680x0::DR8RegClass", "\"Need DR8 register to copy CCR\"", "M680x0::MOV8cd", "\"Cannot emit SR copy instruction\"", "\"Cannot copy \"", "\" to \"", "\"Cannot emit physreg copy instruction\"" ]

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getIRStackGuard", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "hasStackGuardSlotTLS", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ")", ")", "{", "if", "(", "Subtarget", ".", "isTargetFuchsia", "(", ")", ")", "{", "return", "SegmentOffset", "(", "IRB", ",", "0x10", ",", "getAddressSpace", "(", ")", ")", ";", "}", "else", "{", "unsigned", "AddressSpace", "=", "getAddressSpace", "(", ")", ";", "unsigned", "Offset", "=", "getTargetMachine", "(", ")", ".", "Options", ".", "StackProtectorGuardOffset", ";", "if", "(", "Offset", "==", "(", "unsigned", ")", "-", "1", ")", "Offset", "=", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "?", "0x28", ":", "0x14", ";", "const", "auto", "&", "GuardReg", "=", "getTargetMachine", "(", ")", ".", "Options", ".", "StackProtectorGuardReg", ";", "if", "(", "GuardReg", "==", "\"fs\"", ")", "AddressSpace", "=", "X86AS", "::", "FS", ";", "else", "if", "(", "GuardReg", "==", "\"gs\"", ")", "AddressSpace", "=", "X86AS", "::", "GS", ";", "return", "SegmentOffset", "(", "IRB", ",", "Offset", ",", "AddressSpace", ")", ";", "}", "}", "return", "TargetLowering", "::", "getIRStackGuard", "(", "IRB", ")", ";", "}", "</s>" ]

[ "If", "the", "target", "has", "a", "standard", "location", "for", "the", "stack", "protector", "cookie", ",", "returns", "the", "address", "of", "that", "location", "." ]

[ "X86", "X86", "0x10", "1", "0x28", "0x14", "\"fs\"", "X86AS::FS", "\"gs\"", "X86AS::GS" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerDynamicAlloc", "(", "MachineBasicBlock", "::", "iterator", "II", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "LP64", "=", "TM", ".", "isPPC64", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "maxCallFrameSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "Align", "MaxAlign", "=", "MFI", ".", "getMaxAlign", "(", ")", ";", "assert", "(", "isAligned", "(", "MaxAlign", ",", "maxCallFrameSize", ")", "&&", "\"Maximum call-frame size not sufficiently aligned\"", ")", ";", "(", "void", ")", "MaxAlign", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "Register", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "bool", "KillNegSizeReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "Register", "NegSizeReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "prepareDynamicAlloca", "(", "II", ",", "NegSizeReg", ",", "KillNegSizeReg", ",", "Reg", ")", ";", "if", "(", "LP64", ")", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STDUX", ")", ",", "PPC", "::", "X1", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ".", "addReg", "(", "NegSizeReg", ",", "getKillRegState", "(", "KillNegSizeReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI8", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ".", "addImm", "(", "maxCallFrameSize", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STWUX", ")", ",", "PPC", "::", "R1", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ".", "addReg", "(", "NegSizeReg", ",", "getKillRegState", "(", "KillNegSizeReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ".", "addImm", "(", "maxCallFrameSize", ")", ";", "}", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerDynamicAlloc", "-", "Generate", "the", "code", "for", "allocating", "an", "object", "in", "the", "current", "frame", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "\"Maximum call-frame size not sufficiently aligned\"", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "1", "1", "PPC::STDUX", "PPC::X1", "PPC::X1", "PPC::ADDI8", "0", "PPC::X1", "PPC::STWUX", "PPC::R1", "PPC::R1", "PPC::ADDI", "0", "PPC::R1" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", ")", "const", "override", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "PowerPC", "MVT::i32" ]

[]

[ "<s>", "bool", "TVMLowerIntrinsics", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isDeclaration", "(", ")", ")", "continue", ";", "switch", "(", "F", ".", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "memcpy", ":", "case", "Intrinsic", "::", "memmove", ":", "case", "Intrinsic", "::", "memset", ":", "if", "(", "expandMemIntrinsicUses", "(", "F", ")", ")", "Changed", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "Intrinsic::memcpy", "Intrinsic::memmove", "Intrinsic::memset" ]

[]

[ "<s>", "DFAPacketizer", "*", "R600InstrInfo", "::", "CreateTargetScheduleState", "(", "const", "TargetSubtargetInfo", "&", "STI", ")", "const", "{", "const", "InstrItineraryData", "*", "II", "=", "STI", ".", "getInstrItineraryData", "(", ")", ";", "return", "static_cast", "<", "const", "R600Subtarget", "&", ">", "(", "STI", ")", ".", "createDFAPacketizer", "(", "II", ")", ";", "}", "</s>" ]

[ "Create", "machine", "specific", "model", "for", "scheduling", "." ]

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

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "computeDefaultCPU", "(", "TT", ",", "CPU", ")", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveAArch64CodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "if", "(", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", "&&", "TT", ".", "getArch", "(", ")", "!=", "Triple", "::", "aarch64_32", "&&", "TT", ".", "getArchName", "(", ")", "!=", "\"arm64e\"", "&&", "!", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", ")", "{", "setGlobalISel", "(", "true", ")", ";", "setGlobalISelAbort", "(", "GlobalISelAbortMode", "::", "Disable", ")", ";", "}", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDefaultOutlining", "(", "true", ")", ";", "setSupportsDebugEntryValues", "(", "true", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "\"arm64e\"" ]

[]

[ "<s>", "static", "int", "out_adj_frame_ptr", "(", "FILE", "*", "file", ",", "int", "adj", ")", "{", "int", "size", "=", "0", ";", "if", "(", "adj", ")", "{", "if", "(", "TARGET_TINY_STACK", ")", "{", "if", "(", "adj", "<", "-", "63", "||", "adj", ">", "63", ")", "warning", "(", "0", ",", "\"large frame pointer change (%d) with -mtiny-stack\"", ",", "adj", ")", ";", "fprintf", "(", "file", ",", "(", "AS2", "(", "subi", ",", "r28", ",", "%", "d", ")", "CR_TAB", ")", ",", "adj", ")", ";", "size", "++", ";", "}", "else", "if", "(", "adj", "<", "-", "63", "||", "adj", ">", "63", ")", "{", "fprintf", "(", "file", ",", "(", "AS2", "(", "subi", ",", "r28", ",", "lo8", "(", "%", "d", ")", ")", "CR_TAB", "AS2", "(", "sbci", ",", "r29", ",", "hi8", "(", "%", "d", ")", ")", "CR_TAB", ")", ",", "adj", ",", "adj", ")", ";", "size", "+=", "2", ";", "}", "else", "if", "(", "adj", "<", "0", ")", "{", "fprintf", "(", "file", ",", "(", "AS2", "(", "adiw", ",", "r28", ",", "%", "d", ")", "CR_TAB", ")", ",", "-", "adj", ")", ";", "size", "++", ";", "}", "else", "{", "fprintf", "(", "file", ",", "(", "AS2", "(", "sbiw", ",", "r28", ",", "%", "d", ")", "CR_TAB", ")", ",", "adj", ")", ";", "size", "++", ";", "}", "}", "return", "size", ";", "}", "</s>" ]

[ "Output", "to", "FILE", "the", "asm", "instructions", "to", "adjust", "the", "frame", "pointer", "by", "ADJ", "(", "r29", ":", "r28", "-=", "ADJ", ";", ")", "which", "can", "be", "positive", "(", "prologue", ")", "or", "negative", "(", "epilogue", ")", ".", "Returns", "the", "number", "of", "instructions", "generated", "." ]

[ "avr", "0", "63", "63", "0", "\"large frame pointer change (%d) with -mtiny-stack\"", "63", "63", "2", "0" ]

[]

[ "<s>", "static", "void", "frv_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "second_time", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", "&&", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\\n\"", ",", "*", "cum", ",", "GET_MODE_NAME", "(", "arg", ".", "mode", ")", ",", "*", "pretend_size", ",", "second_time", ")", ";", "}", "</s>" ]

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

[ "frv", "\"setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\\n\"" ]

[]

[ "<s>", "const", "TVMImmStringMCExpr", "*", "TVMImmStringMCExpr", "::", "create", "(", "const", "StringRef", "&", "Data", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "TVMImmStringMCExpr", "(", "Data", ")", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "TVM", "TVM" ]

[]

[ "<s>", "MVT", "getFenceOperandTy", "(", "const", "DataLayout", "&", "DL", ")", "const", "override", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "type", "for", "operands", "of", "fence", "." ]

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

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createRISCVExpandSDMAPass", "(", ")", ")", ";", "addPass", "(", "createRISCVExpandSSRPass", "(", ")", ")", ";", "addPass", "(", "createSNITCHFrepLoopsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createRISCVMergeBaseOffsetOptPass", "(", ")", ")", ";", "addPass", "(", "createRISCVCleanupVSETVLIPass", "(", ")", ")", ";", "addPass", "(", "createPULPHardwareLoops", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "int", "mingw32_gt_pch_use_address", "(", "void", "*", "&", "addr", ",", "size_t", "size", ",", "int", "fd", ",", "size_t", "offset", ")", "{", "void", "*", "mmap_addr", ";", "HANDLE", "mmap_handle", ";", "char", "*", "object_name", "=", "NULL", ";", "OSVERSIONINFO", "version_info", ";", "int", "r", ";", "version_info", ".", "dwOSVersionInfoSize", "=", "sizeof", "(", "version_info", ")", ";", "if", "(", "size", "==", "0", ")", "return", "0", ";", "if", "(", "(", "offset", "&", "(", "va_granularity", "-", "1", ")", ")", "!=", "0", "||", "size", ">", "pch_VA_max_size", ")", "return", "-", "1", ";", "GetVersionEx", "(", "&", "version_info", ")", ";", "char", "local_object_name", "[", "sizeof", "(", "OBJECT_NAME_FMT", ")", "+", "sizeof", "(", "DWORD", ")", "*", "2", "]", ";", "if", "(", "version_info", ".", "dwMajorVersion", ">", "4", ")", "{", "snprintf", "(", "local_object_name", ",", "sizeof", "(", "local_object_name", ")", ",", "OBJECT_NAME_FMT", "\"%lx\"", ",", "GetCurrentProcessId", "(", ")", ")", ";", "object_name", "=", "local_object_name", ";", "}", "mmap_handle", "=", "CreateFileMappingA", "(", "(", "HANDLE", ")", "_get_osfhandle", "(", "fd", ")", ",", "NULL", ",", "PAGE_WRITECOPY", "|", "SEC_COMMIT", ",", "0", ",", "0", ",", "object_name", ")", ";", "if", "(", "mmap_handle", "==", "NULL", ")", "{", "w32_error", "(", "__FUNCTION__", ",", "__FILE__", ",", "__LINE__", ",", "\"CreateFileMapping\"", ")", ";", "return", "-", "1", ";", "}", "for", "(", "r", "=", "0", ";", "r", "<", "5", ";", "r", "++", ")", "{", "mmap_addr", "=", "MapViewOfFileEx", "(", "mmap_handle", ",", "FILE_MAP_COPY", ",", "0", ",", "offset", ",", "size", ",", "addr", ")", ";", "if", "(", "mmap_addr", "==", "addr", ")", "break", ";", "if", "(", "r", "!=", "4", ")", "Sleep", "(", "500", ")", ";", "}", "if", "(", "mmap_addr", "!=", "addr", ")", "{", "w32_error", "(", "__FUNCTION__", ",", "__FILE__", ",", "__LINE__", ",", "\"MapViewOfFileEx\"", ")", ";", "CloseHandle", "(", "mmap_handle", ")", ";", "return", "-", "1", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "ADDR", "is", "an", "address", "returned", "by", "gt_pch_get_address", ".", "Attempt", "to", "allocate", "SIZE", "bytes", "at", "the", "same", "address", "and", "load", "it", "with", "the", "data", "from", "FD", "at", "OFFSET", ".", "Return", "-1", "if", "we", "could", "n't", "allocate", "memory", "at", "ADDR", ",", "return", "0", "if", "the", "memory", "is", "allocated", "but", "the", "data", "not", "loaded", ",", "return", "1", "if", "done", "." ]

[ "i386", "0", "0", "1", "0", "1", "2", "4", "\"%lx\"", "0", "0", "\"CreateFileMapping\"", "1", "0", "5", "0", "4", "500", "\"MapViewOfFileEx\"", "1", "1" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "getRegAllocationHints", "(", "Register", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "std", "::", "pair", "<", "Register", ",", "Register", ">", "Hint", "=", "MRI", ".", "getRegAllocationHint", "(", "VirtReg", ")", ";", "unsigned", "Odd", ";", "switch", "(", "Hint", ".", "first", ")", "{", "case", "ARMRI", "::", "RegPairEven", ":", "Odd", "=", "0", ";", "break", ";", "case", "ARMRI", "::", "RegPairOdd", ":", "Odd", "=", "1", ";", "break", ";", "case", "ARMRI", "::", "RegLR", ":", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "VirtReg", ")", "->", "contains", "(", "ARM", "::", "LR", ")", ")", "Hints", ".", "push_back", "(", "ARM", "::", "LR", ")", ";", "return", "false", ";", "default", ":", "return", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ")", ";", "}", "Register", "Paired", "=", "Hint", ".", "second", ";", "if", "(", "!", "Paired", ")", "return", "false", ";", "Register", "PairedPhys", ";", "if", "(", "Paired", ".", "isPhysical", "(", ")", ")", "{", "PairedPhys", "=", "Paired", ";", "}", "else", "if", "(", "VRM", "&&", "VRM", "->", "hasPhys", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "getPairedGPR", "(", "VRM", "->", "getPhys", "(", "Paired", ")", ",", "Odd", ",", "this", ")", ";", "}", "if", "(", "PairedPhys", "&&", "is_contained", "(", "Order", ",", "PairedPhys", ")", ")", "Hints", ".", "push_back", "(", "PairedPhys", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "Order", ")", "{", "if", "(", "Reg", "==", "PairedPhys", "||", "(", "getEncodingValue", "(", "Reg", ")", "&", "1", ")", "!=", "Odd", ")", "continue", ";", "MCPhysReg", "Paired", "=", "getPairedGPR", "(", "Reg", ",", "!", "Odd", ",", "this", ")", ";", "if", "(", "!", "Paired", "||", "MRI", ".", "isReserved", "(", "Paired", ")", ")", "continue", ";", "Hints", ".", "push_back", "(", "Reg", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "ISD", "::", "NodeType", "getExtendForAtomicCmpSwapArg", "(", ")", "const", "override", "{", "return", "ISD", "::", "ZERO_EXTEND", ";", "}", "</s>" ]

[ "Returns", "how", "the", "platform", "'s", "atomic", "compare", "and", "swap", "expects", "its", "comparison", "value", "to", "be", "extended", "(", "ZERO_EXTEND", ",", "SIGN_EXTEND", ",", "or", "ANY_EXTEND", ")", "." ]

[ "SystemZ", "ISD::NodeType", "ISD::ZERO_EXTEND" ]

[]

[ "<s>", "void", "mmix_asm_output_align", "(", "FILE", "*", "stream", ",", "int", "power", ")", "{", "fprintf", "(", "stream", ",", "\"\\t.p2align %d\\n\"", ",", "power", ")", ";", "fprintf", "(", "stream", ",", "\"\\tLOC @+(%d-@)&%d\\n\"", ",", "1", "<<", "power", ",", "(", "1", "<<", "power", ")", "-", "1", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_ALIGN", "." ]

[ "mmix", "\"\\t.p2align %d\\n\"", "\"\\tLOC @+(%d-@)&%d\\n\"", "1", "1", "1" ]

[]

[ "<s>", "static", "rtx", "microblaze_function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "LIBCALL_VALUE", "(", "TYPE_MODE", "(", "valtype", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", "." ]

[ "microblaze" ]

[]

[ "<s>", "void", "BPFRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "MOV_rr", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "unsigned", "reg", "=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "II", ",", "DL", ",", "TII", ".", "get", "(", "BPF", "::", "ADD_ri", ")", ",", "reg", ")", ".", "addReg", "(", "reg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "Offset", ")", ")", "llvm_unreachable", "(", "\"bug in frame offset\"", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "BPF", "BPF", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "BPF::MOV_rr", "1", "BPF::ADD_ri", "1", "32", "\"bug in frame offset\"", "1" ]

[]

[ "<s>", "void", "LanaiInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "Position", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestinationRegister", ",", "unsigned", "SourceRegister", ",", "bool", "KillSource", ")", "const", "{", "if", "(", "!", "Lanai", "::", "GPRRegClass", ".", "contains", "(", "DestinationRegister", ",", "SourceRegister", ")", ")", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "Position", ",", "DL", ",", "get", "(", "Lanai", "::", "OR_I_LO", ")", ",", "DestinationRegister", ")", ".", "addReg", "(", "SourceRegister", ",", "getKillRegState", "(", "KillSource", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::GPRRegClass", "\"Impossible reg-to-reg copy\"", "Lanai::OR_I_LO", "0" ]

[]

[ "<s>", "const", "char", "*", "output_cbranch", "(", "rtx", "label", ",", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "cc_mode", ",", "int", "reversed", ",", "rtx_insn", "*", "insn", ")", "{", "const", "char", "*", "cond", ";", "if", "(", "reversed", ")", "{", "if", "(", "cc_mode", "==", "CCFPmode", "||", "cc_mode", "==", "CCFPEmode", ")", "code", "=", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "else", "code", "=", "reverse_condition", "(", "code", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "NE", ":", "if", "(", "cc_mode", "==", "CCCmode", ")", "cond", "=", "\"cs\"", ";", "else", "if", "(", "cc_mode", "==", "CCVmode", ")", "cond", "=", "\"os\"", ";", "else", "cond", "=", "\"ne\"", ";", "break", ";", "case", "EQ", ":", "if", "(", "cc_mode", "==", "CCCmode", ")", "cond", "=", "\"cc\"", ";", "else", "if", "(", "cc_mode", "==", "CCVmode", ")", "cond", "=", "\"oc\"", ";", "else", "cond", "=", "\"eq\"", ";", "break", ";", "case", "GE", ":", "if", "(", "cc_mode", "==", "CCNZmode", ")", "cond", "=", "\"nc\"", ";", "else", "cond", "=", "\"ge\"", ";", "break", ";", "case", "GT", ":", "cond", "=", "\"gt\"", ";", "break", ";", "case", "LE", ":", "if", "(", "cc_mode", "==", "CCFPmode", "||", "cc_mode", "==", "CCFPEmode", ")", "cond", "=", "\"ls\"", ";", "else", "cond", "=", "\"le\"", ";", "break", ";", "case", "LT", ":", "if", "(", "cc_mode", "==", "CCFPmode", "||", "cc_mode", "==", "CCFPEmode", ")", "cond", "=", "\"cs\"", ";", "else", "if", "(", "cc_mode", "==", "CCNZmode", ")", "cond", "=", "\"ns\"", ";", "else", "cond", "=", "\"lt\"", ";", "break", ";", "case", "GEU", ":", "cond", "=", "\"cc\"", ";", "break", ";", "case", "GTU", ":", "cond", "=", "\"hi\"", ";", "break", ";", "case", "LEU", ":", "cond", "=", "\"ls\"", ";", "break", ";", "case", "LTU", ":", "cond", "=", "\"cs\"", ";", "break", ";", "case", "UNORDERED", ":", "cond", "=", "\"os\"", ";", "break", ";", "case", "ORDERED", ":", "cond", "=", "\"oc\"", ";", "break", ";", "case", "UNGE", ":", "cond", "=", "\"cc\"", ";", "break", ";", "case", "UNGT", ":", "cond", "=", "\"hi\"", ";", "break", ";", "case", "UNLE", ":", "cond", "=", "\"le\"", ";", "break", ";", "case", "UNLT", ":", "cond", "=", "\"lt\"", ";", "break", ";", "case", "UNEQ", ":", "case", "LTGT", ":", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "output_branch", "(", "label", ",", "cond", ",", "insn", ")", ";", "}", "</s>" ]

[ "Output", "a", "conditional", "branch", "to", "LABEL", ".", "CODE", "is", "the", "comparison", "code", ".", "CC_MODE", "is", "the", "mode", "of", "the", "CC", "register", ".", "REVERSED", "is", "non-zero", "if", "we", "should", "reverse", "the", "sense", "of", "the", "comparison", ".", "INSN", "is", "the", "instruction", "." ]

[ "visium", "\"cs\"", "\"os\"", "\"ne\"", "\"cc\"", "\"oc\"", "\"eq\"", "\"nc\"", "\"ge\"", "\"gt\"", "\"ls\"", "\"le\"", "\"cs\"", "\"ns\"", "\"lt\"", "\"cc\"", "\"hi\"", "\"ls\"", "\"cs\"", "\"os\"", "\"oc\"", "\"cc\"", "\"hi\"", "\"le\"", "\"lt\"" ]

[]

[ "<s>", "static", "void", "ix86_pad_returns", "(", "void", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "preds", ")", "{", "basic_block", "bb", "=", "e", "->", "src", ";", "rtx_insn", "*", "ret", "=", "BB_END", "(", "bb", ")", ";", "rtx_insn", "*", "prev", ";", "bool", "replace", "=", "false", ";", "if", "(", "!", "JUMP_P", "(", "ret", ")", "||", "!", "ANY_RETURN_P", "(", "PATTERN", "(", "ret", ")", ")", "||", "optimize_bb_for_size_p", "(", "bb", ")", ")", "continue", ";", "for", "(", "prev", "=", "PREV_INSN", "(", "ret", ")", ";", "prev", ";", "prev", "=", "PREV_INSN", "(", "prev", ")", ")", "if", "(", "active_insn_p", "(", "prev", ")", "||", "LABEL_P", "(", "prev", ")", ")", "break", ";", "if", "(", "prev", "&&", "LABEL_P", "(", "prev", ")", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "EDGE_FREQUENCY", "(", "e", ")", "&&", "e", "->", "src", "->", "index", ">=", "0", "&&", "!", "(", "e", "->", "flags", "&", "EDGE_FALLTHRU", ")", ")", "{", "replace", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "replace", ")", "{", "prev", "=", "prev_active_insn", "(", "ret", ")", ";", "if", "(", "prev", "&&", "(", "(", "JUMP_P", "(", "prev", ")", "&&", "any_condjump_p", "(", "prev", ")", ")", "||", "CALL_P", "(", "prev", ")", ")", ")", "replace", "=", "true", ";", "if", "(", "!", "prev", "&&", "!", "optimize_function_for_size_p", "(", "cfun", ")", ")", "replace", "=", "true", ";", "}", "if", "(", "replace", ")", "{", "emit_jump_insn_before", "(", "gen_simple_return_internal_long", "(", ")", ",", "ret", ")", ";", "delete_insn", "(", "ret", ")", ";", "}", "}", "}", "</s>" ]

[ "AMD", "Athlon", "works", "faster", "when", "RET", "is", "not", "destination", "of", "conditional", "jump", "or", "directly", "preceded", "by", "other", "jump", "instruction", ".", "We", "avoid", "the", "penalty", "by", "inserting", "NOP", "just", "before", "the", "RET", "instructions", "in", "such", "cases", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "frv_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "frv_insn_packing_flag", ">=", "0", ")", "{", "frv_insn_operands", "=", "opvec", ";", "frv_insn_packing_flag", "=", "PACKING_FLAG_P", "(", "insn", ")", ";", "}", "else", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "get_attr_acc_group", "(", "insn", ")", "==", "ACC_GROUP_ODD", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tmnop.p\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Set", "up", "the", "packing", "bit", "for", "the", "current", "output", "insn", ".", "Note", "that", "this", "function", "is", "not", "called", "for", "asm", "insns", "." ]

[ "frv", "0", "0", "\"\\tmnop.p\\n\"" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMipsModuleISelDagPass", "(", ")", ")", ";", "addPass", "(", "createMips16ISelDag", "(", "getMipsTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createMipsSEISelDag", "(", "getMipsTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "aarch64_bit_representation", "(", "rtx", "x", ")", "{", "if", "(", "CONST_DOUBLE_P", "(", "x", ")", ")", "x", "=", "gen_lowpart", "(", "int_mode_for_mode", "(", "GET_MODE", "(", "x", ")", ")", ".", "require", "(", ")", ",", "x", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "If", "X", "is", "a", "CONST_DOUBLE", ",", "return", "its", "bit", "representation", "as", "a", "constant", "integer", ",", "otherwise", "return", "X", "unmodified", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "unsigned", "*", "SystemZRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "SystemZ", "::", "R6D", ",", "SystemZ", "::", "R7D", ",", "SystemZ", "::", "R8D", ",", "SystemZ", "::", "R9D", ",", "SystemZ", "::", "R10D", ",", "SystemZ", "::", "R11D", ",", "SystemZ", "::", "R12D", ",", "SystemZ", "::", "R13D", ",", "SystemZ", "::", "R14D", ",", "SystemZ", "::", "R15D", ",", "SystemZ", "::", "F8L", ",", "SystemZ", "::", "F9L", ",", "SystemZ", "::", "F10L", ",", "SystemZ", "::", "F11L", ",", "SystemZ", "::", "F12L", ",", "SystemZ", "::", "F13L", ",", "SystemZ", "::", "F14L", ",", "SystemZ", "::", "F15L", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::R6D", "SystemZ::R7D", "SystemZ::R8D", "SystemZ::R9D", "SystemZ::R10D", "SystemZ::R11D", "SystemZ::R12D", "SystemZ::R13D", "SystemZ::R14D", "SystemZ::R15D", "SystemZ::F8L", "SystemZ::F9L", "SystemZ::F10L", "SystemZ::F11L", "SystemZ::F12L", "SystemZ::F13L", "SystemZ::F14L", "SystemZ::F15L", "0" ]

[]

[ "<s>", "static", "bool", "shadow_or_blockage_p", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_type", "type", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "false", ";", "type", "=", "get_attr_type", "(", "insn", ")", ";", "return", "shadow_type_p", "(", "type", ")", "||", "type", "==", "TYPE_BLOCKAGE", ";", "}", "</s>" ]

[ "Return", "true", "iff", "INSN", "is", "a", "shadow", "or", "blockage", "pattern", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "static", "inline", "bool", "is_naked_func", "(", "void", ")", "{", "return", "is_attr_func", "(", "\"naked\"", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "``", "naked", "''", "attribute", "." ]

[ "msp430", "\"naked\"" ]

[]

[ "<s>", "void", "AMDGPUTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "UP", ".", "Threshold", "=", "300", ";", "UP", ".", "Count", "=", "UINT_MAX", ";", "UP", ".", "Partial", "=", "true", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", "||", "GEP", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "continue", ";", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ")", ")", ";", "if", "(", "Alloca", ")", "{", "UP", ".", "Threshold", "=", "800", ";", "}", "}", "}", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "R600", "300", "AMDGPUAS::PRIVATE_ADDRESS", "800" ]

[]

[ "<s>", "static", "bool", "pdp11_modes_tieable_p", "(", "machine_mode", ",", "machine_mode", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "pdp11" ]

[]

[ "<s>", "bool", "XCoreTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "Ty", "->", "getTypeID", "(", ")", "==", "Type", "::", "VoidTyID", ")", "return", "AM", ".", "Scale", "==", "0", "&&", "isImmUs", "(", "AM", ".", "BaseOffs", ")", "&&", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "unsigned", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "Ty", ")", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "return", "Size", ">=", "4", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "AM", ".", "BaseOffs", "%", "4", "==", "0", ";", "}", "switch", "(", "Size", ")", "{", "case", "1", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "case", "2", ":", "case", "3", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs2", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "2", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "default", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "4", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "}", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "XCore", "XCore", "0", "4", "0", "4", "0", "1", "0", "1", "0", "2", "3", "0", "2", "0", "0", "4", "0" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "csky_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "machine", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "machine", "->", "func_type", "=", "CSKY_FT_UNKNOWN", ";", "return", "machine", ";", "}", "</s>" ]

[ "Functions", "to", "save", "and", "restore", "machine-specific", "function", "data", "." ]

[ "csky" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "ARM64", "ARM64" ]

[]

[ "<s>", "std", "::", "string", "AMDGPUSubtarget", "::", "getDataLayout", "(", ")", "const", "{", "std", "::", "string", "DataLayout", "=", "std", "::", "string", "(", "\"e\"", "\"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128\"", "\"-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048\"", "\"-n32:64\"", ")", ";", "if", "(", "hasHWFP64", "(", ")", ")", "{", "DataLayout", ".", "append", "(", "\"-f64:64:64\"", ")", ";", "}", "if", "(", "is64bit", "(", ")", ")", "{", "DataLayout", ".", "append", "(", "\"-p:64:64:64\"", ")", ";", "}", "else", "{", "DataLayout", ".", "append", "(", "\"-p:32:32:32\"", ")", ";", "}", "return", "DataLayout", ";", "}", "</s>" ]

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

[ "R600", "\"e\"", "\"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128\"", "\"-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048\"", "\"-n32:64\"", "\"-f64:64:64\"", "\"-p:64:64:64\"", "\"-p:32:32:32\"" ]

[]

[ "<s>", "int", "attr_length_call", "(", "rtx", "insn", ",", "int", "sibcall", ")", "{", "int", "local_call", ";", "rtx", "call_dest", ";", "tree", "call_decl", ";", "int", "length", "=", "0", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "unsigned", "long", "distance", "=", "-", "1", ";", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "unsigned", "long", "total", ";", "total", "=", "IN_NAMED_SECTION_P", "(", "cfun", "->", "decl", ")", "?", "0", ":", "total_code_bytes", ";", "distance", "=", "(", "total", "+", "insn_current_reference_address", "(", "insn", ")", ")", ";", "if", "(", "distance", "<", "total", ")", "distance", "=", "-", "1", ";", "}", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "CALL", ")", "call_dest", "=", "XEXP", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ",", "0", ")", ";", "else", "call_dest", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", ",", "0", ")", ",", "0", ")", ";", "call_decl", "=", "SYMBOL_REF_DECL", "(", "call_dest", ")", ";", "local_call", "=", "call_decl", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "call_decl", ")", ";", "if", "(", "!", "TARGET_LONG_CALLS", "&&", "(", "(", "TARGET_PA_20", "&&", "!", "sibcall", "&&", "distance", "<", "7600000", ")", "||", "distance", "<", "240000", ")", ")", "length", "+=", "8", ";", "else", "if", "(", "TARGET_64BIT", "&&", "!", "local_call", ")", "length", "+=", "sibcall", "?", "28", ":", "24", ";", "else", "if", "(", "(", "TARGET_LONG_ABS_CALL", "||", "local_call", ")", "&&", "!", "flag_pic", ")", "length", "+=", "12", ";", "else", "if", "(", "(", "TARGET_SOM", "&&", "TARGET_LONG_PIC_SDIFF_CALL", ")", "||", "(", "TARGET_64BIT", "&&", "!", "TARGET_GAS", ")", "||", "(", "TARGET_GAS", "&&", "(", "TARGET_LONG_PIC_PCREL_CALL", "||", "local_call", ")", ")", ")", "{", "length", "+=", "20", ";", "if", "(", "!", "TARGET_PA_20", "&&", "!", "TARGET_NO_SPACE_REGS", ")", "length", "+=", "8", ";", "}", "else", "{", "length", "+=", "32", ";", "if", "(", "TARGET_SOM", ")", "length", "+=", "length_fp_args", "(", "insn", ")", ";", "if", "(", "flag_pic", ")", "length", "+=", "4", ";", "if", "(", "!", "TARGET_PA_20", ")", "{", "if", "(", "!", "sibcall", ")", "length", "+=", "8", ";", "if", "(", "!", "TARGET_NO_SPACE_REGS", ")", "length", "+=", "8", ";", "}", "}", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "attribute", "length", "of", "the", "call", "instruction", "INSN", ".", "The", "SIBCALL", "flag", "indicates", "whether", "INSN", "is", "a", "regular", "call", "or", "a", "sibling", "call", ".", "The", "length", "returned", "must", "be", "longer", "than", "the", "code", "actually", "generated", "by", "output_call", ".", "Since", "branch", "shortening", "is", "done", "before", "delay", "branch", "sequencing", ",", "there", "is", "no", "way", "to", "determine", "whether", "or", "not", "the", "delay", "slot", "will", "be", "filled", "during", "branch", "shortening", ".", "Even", "when", "the", "delay", "slot", "is", "filled", ",", "we", "may", "have", "to", "add", "a", "nop", "if", "the", "delay", "slot", "contains", "a", "branch", "that", "ca", "n't", "reach", "its", "target", ".", "Thus", ",", "we", "always", "have", "to", "include", "the", "delay", "slot", "in", "the", "length", "estimate", ".", "This", "used", "to", "be", "done", "in", "pa_adjust_insn_length", "but", "we", "do", "it", "here", "now", "as", "some", "sequences", "always", "fill", "the", "delay", "slot", "and", "we", "can", "save", "four", "bytes", "in", "the", "estimate", "for", "these", "sequences", "." ]

[ "pa", "0", "1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "7600000", "240000", "8", "28", "24", "12", "20", "8", "32", "4", "8", "8" ]

[]

[ "<s>", "static", "bool", "pru_can_use_doloop_p", "(", "const", "widest_int", "&", ",", "const", "widest_int", "&", "iterations_max", ",", "unsigned", "int", "loop_depth", ",", "bool", ")", "{", "if", "(", "loop_depth", ">", "1", ")", "return", "false", ";", "if", "(", "iterations_max", "==", "0", "||", "wi", "::", "geu_p", "(", "iterations_max", ",", "0xffff", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_USE_DOLOOP_P", "." ]

[ "pru", "1", "0", "0xffff" ]

[]

[ "<s>", "int", "sh_media_register_for_return", "(", ")", "{", "int", "regno", ";", "int", "tr0_used", ";", "if", "(", "!", "current_function_is_leaf", ")", "return", "-", "1", ";", "tr0_used", "=", "flag_pic", "&&", "regs_ever_live", "[", "PIC_OFFSET_TABLE_REGNUM", "]", ";", "for", "(", "regno", "=", "FIRST_TARGET_REG", "+", "tr0_used", ";", "regno", "<=", "LAST_TARGET_REG", ";", "regno", "++", ")", "if", "(", "call_used_regs", "[", "regno", "]", "&&", "!", "regs_ever_live", "[", "regno", "]", ")", "return", "regno", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Choose", "a", "call-clobbered", "target-branch", "register", "that", "remains", "unchanged", "along", "the", "whole", "function", ".", "We", "set", "it", "up", "as", "the", "return", "value", "in", "the", "prologue", "." ]

[ "sh", "1", "1" ]

[]

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

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

[ "Z80", "Z80" ]

[]

[ "<s>", "bool", "WebAssemblyTargetMachine", "::", "parseMachineFunctionInfo", "(", "const", "yaml", "::", "MachineFunctionInfo", "&", "MFI", ",", "PerFunctionMIParsingState", "&", "PFS", ",", "SMDiagnostic", "&", "Error", ",", "SMRange", "&", "SourceRange", ")", "const", "{", "const", "auto", "&", "YamlMFI", "=", "reinterpret_cast", "<", "const", "yaml", "::", "WebAssemblyFunctionInfo", "&", ">", "(", "MFI", ")", ";", "MachineFunction", "&", "MF", "=", "PFS", ".", "MF", ";", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", "->", "initializeBaseYamlFields", "(", "YamlMFI", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZERO_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "combineSIGN_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "combineSIGN_EXTEND_INREG", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "MERGE_HIGH", ":", "case", "SystemZISD", "::", "MERGE_LOW", ":", "return", "combineMERGE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "combineSTORE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "combineEXTRACT_VECTOR_ELT", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "JOIN_DWORDS", ":", "return", "combineJOIN_DWORDS", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "combineFP_ROUND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BSWAP", ":", "return", "combineBSWAP", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ROTL", ":", "return", "combineSHIFTROT", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "BR_CCMASK", ":", "return", "combineBR_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "SELECT_CCMASK", ":", "return", "combineSELECT_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "GET_CCMASK", ":", "return", "combineGET_CCMASK", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::SIGN_EXTEND_INREG", "SystemZISD::MERGE_HIGH", "SystemZISD::MERGE_LOW", "ISD::STORE", "ISD::EXTRACT_VECTOR_ELT", "SystemZISD::JOIN_DWORDS", "ISD::FP_ROUND", "ISD::BSWAP", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ROTL", "SystemZISD::BR_CCMASK", "SystemZISD::SELECT_CCMASK", "SystemZISD::GET_CCMASK" ]

[]

[ "<s>", "void", "TPCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "int", "LoadOpCode", "=", "0", ";", "uint8_t", "StackID", "=", "0", ";", "if", "(", "TPC", "::", "SRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "LoadOpCode", "=", "TPC", "::", "SPILL_SRF_RESTORE", ";", "StackID", "=", "TPCStackID", "::", "SLM_SPILL", ";", "}", "else", "if", "(", "TPC", "::", "SPRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "LoadOpCode", "=", "TPC", "::", "SPILL_SPRF_RESTORE", ";", "StackID", "=", "TPCStackID", "::", "SLM_SPILL", ";", "}", "else", "if", "(", "TPC", "::", "VRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "LoadOpCode", "=", "TPC", "::", "SPILL_VRF_RESTORE", ";", "StackID", "=", "TPCStackID", "::", "VLM_SPILL", ";", "}", "else", "if", "(", "TPC", "::", "VPRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "LoadOpCode", "=", "TPC", "::", "SPILL_VPRF_RESTORE", ";", "StackID", "=", "TPCStackID", "::", "VLM_SPILL", ";", "}", "else", "if", "(", "TPC", "::", "ARFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "LoadOpCode", "=", "TPC", "::", "SPILL_ARF_RESTORE", ";", "StackID", "=", "TPCStackID", "::", "VLM_SPILL", ";", "}", "else", "if", "(", "TPC", "::", "DRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "LoadOpCode", "=", "TPC", "::", "SPILL_DRF_RESTORE", ";", "StackID", "=", "TPCStackID", "::", "VLM_SPILL", ";", "}", "else", "if", "(", "TPC", "::", "ZRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "LoadOpCode", "=", "TPC", "::", "SPILL_ZRF_RESTORE", ";", "StackID", "=", "TPCStackID", "::", "SLM_SPILL", ";", "}", "else", "if", "(", "TPC", "::", "IRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "getTargetMachine", "(", ")", ".", "Options", ".", "LongIRF", ")", "report_fatal_error", "(", "\"IRF registers are not spillable if -long-irf is specified\"", ")", ";", "LoadOpCode", "=", "TPC", "::", "SPILL_IRF_RESTORE", ";", "StackID", "=", "TPCStackID", "::", "SLM_SPILL", ";", "}", "else", "{", "report_fatal_error", "(", "\"Unsupported register class in loadFromStack\"", ")", ";", "}", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "StackID", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "LoadOpCode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "TPC", "TPC", "0", "0", "TPC::SRFRegClass", "TPC::SPILL_SRF_RESTORE", "TPCStackID::SLM_SPILL", "TPC::SPRFRegClass", "TPC::SPILL_SPRF_RESTORE", "TPCStackID::SLM_SPILL", "TPC::VRFRegClass", "TPC::SPILL_VRF_RESTORE", "TPCStackID::VLM_SPILL", "TPC::VPRFRegClass", "TPC::SPILL_VPRF_RESTORE", "TPCStackID::VLM_SPILL", "TPC::ARFRegClass", "TPC::SPILL_ARF_RESTORE", "TPCStackID::VLM_SPILL", "TPC::DRFRegClass", "TPC::SPILL_DRF_RESTORE", "TPCStackID::VLM_SPILL", "TPC::ZRFRegClass", "TPC::SPILL_ZRF_RESTORE", "TPCStackID::SLM_SPILL", "TPC::IRFRegClass", "\"IRF registers are not spillable if -long-irf is specified\"", "TPC::SPILL_IRF_RESTORE", "TPCStackID::SLM_SPILL", "\"Unsupported register class in loadFromStack\"" ]

[]

[ "<s>", "static", "rtx", "arc_expand_builtin_aligned", "(", "tree", "exp", ")", "{", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "fold", "(", "arg1", ")", ";", "rtx", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", ")", "{", "if", "(", "optimize", ")", "warning", "(", "0", ",", "\"%<__builtin_arc_aligned%> with non-constant alignment\"", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "alignTest", "=", "INTVAL", "(", "op1", ")", ";", "if", "(", "alignTest", "<=", "0", "||", "alignTest", "!=", "(", "alignTest", "&", "-", "alignTest", ")", ")", "{", "error", "(", "\"invalid alignment value for %<__builtin_arc_aligned%>\"", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "CONST_INT_P", "(", "op0", ")", ")", "{", "HOST_WIDE_INT", "pnt", "=", "INTVAL", "(", "op0", ")", ";", "if", "(", "(", "pnt", "&", "(", "alignTest", "-", "1", ")", ")", "==", "0", ")", "return", "const1_rtx", ";", "}", "else", "{", "unsigned", "align", "=", "get_pointer_alignment", "(", "arg0", ")", ";", "unsigned", "numBits", "=", "alignTest", "*", "BITS_PER_UNIT", ";", "if", "(", "align", "&&", "align", ">=", "numBits", ")", "return", "const1_rtx", ";", "if", "(", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "arg0", ")", ")", "&&", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ">=", "numBits", ")", "return", "const1_rtx", ";", "}", "}", "return", "const0_rtx", ";", "}", "</s>" ]

[ "Helper", "to", "expand", "__builtin_arc_aligned", "(", "void", "*", "val", ",", "int", "alignval", ")", "." ]

[ "arc", "0", "1", "0", "\"%<__builtin_arc_aligned%> with non-constant alignment\"", "0", "\"invalid alignment value for %<__builtin_arc_aligned%>\"", "1", "0" ]

[]

[ "<s>", "static", "void", "single_move_for_strmov", "(", "rtx", "dst", ",", "rtx", "src", ",", "enum", "machine_mode", "mode", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "scratch", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "srcmem", ",", "dstmem", ";", "srcmem", "=", "adjust_address_nv", "(", "src", ",", "mode", ",", "offset", ")", ";", "dstmem", "=", "adjust_address_nv", "(", "dst", ",", "mode", ",", "offset", ")", ";", "emit_move_insn", "(", "scratch", ",", "srcmem", ")", ";", "emit_move_insn", "(", "dstmem", ",", "scratch", ")", ";", "}", "</s>" ]

[ "Adjust", "DST", "and", "SRC", "by", "OFFSET", "bytes", ",", "and", "generate", "one", "move", "in", "mode", "MODE", "." ]

[ "bfin" ]

[]

[ "<s>", "unsigned", "Mips16InstrInfo", "::", "getInlineAsmLength", "(", "const", "char", "*", "Str", ",", "const", "MCAsmInfo", "&", "MAI", ")", "const", "{", "bool", "atInsnStart", "=", "true", ";", "unsigned", "Length", "=", "0", ";", "for", "(", ";", "*", "Str", ";", "++", "Str", ")", "{", "if", "(", "*", "Str", "==", "'\\n'", "||", "strncmp", "(", "Str", ",", "MAI", ".", "getSeparatorString", "(", ")", ",", "strlen", "(", "MAI", ".", "getSeparatorString", "(", ")", ")", ")", "==", "0", ")", "atInsnStart", "=", "true", ";", "if", "(", "atInsnStart", "&&", "!", "std", "::", "isspace", "(", "static_cast", "<", "unsigned", "char", ">", "(", "*", "Str", ")", ")", ")", "{", "if", "(", "strncmp", "(", "Str", ",", "\".space\"", ",", "6", ")", "==", "0", ")", "{", "char", "*", "EStr", ";", "int", "Sz", ";", "Sz", "=", "strtol", "(", "Str", "+", "6", ",", "&", "EStr", ",", "10", ")", ";", "while", "(", "isspace", "(", "*", "EStr", ")", ")", "++", "EStr", ";", "if", "(", "*", "EStr", "==", "'\\0'", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"parsed .space \"", "<<", "Sz", "<<", "'\\n'", ")", ";", "return", "Sz", ";", "}", "}", "Length", "+=", "MAI", ".", "getMaxInstLength", "(", ")", ";", "atInsnStart", "=", "false", ";", "}", "if", "(", "atInsnStart", "&&", "strncmp", "(", "Str", ",", "MAI", ".", "getCommentString", "(", ")", ",", "strlen", "(", "MAI", ".", "getCommentString", "(", ")", ")", ")", "==", "0", ")", "atInsnStart", "=", "false", ";", "}", "return", "Length", ";", "}", "</s>" ]

[ "Measure", "the", "specified", "inline", "asm", "to", "determine", "an", "approximation", "of", "its", "length", "." ]

[ "Mips", "Mips", "0", "0", "\".space\"", "6", "0", "6", "10", "\"parsed .space \"", "0" ]

[]

[ "<s>", "void", "X86LowerTileCopy", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "ia64_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "unsigned", "char", "perm", "[", "MAX_VECT_LEN", "]", ";", "unsigned", "int", "i", ",", "nelt", ",", "which", ";", "d", ".", "target", "=", "target", ";", "if", "(", "op0", ")", "{", "rtx", "nop0", "=", "force_reg", "(", "vmode", ",", "op0", ")", ";", "if", "(", "op0", "==", "op1", ")", "op1", "=", "nop0", ";", "op0", "=", "nop0", ";", "}", "if", "(", "op1", ")", "op1", "=", "force_reg", "(", "vmode", ",", "op1", ")", ";", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "vmode", "=", "vmode", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "d", ".", "vmode", ")", ")", ";", "d", ".", "nelt", "=", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "d", ".", "testing_p", "=", "!", "target", ";", "gcc_assert", "(", "sel", ".", "length", "(", ")", "==", "nelt", ")", ";", "gcc_checking_assert", "(", "sizeof", "(", "d", ".", "perm", ")", "==", "sizeof", "(", "perm", ")", ")", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "int", "ei", "=", "sel", "[", "i", "]", "&", "(", "2", "*", "nelt", "-", "1", ")", ";", "which", "|=", "(", "ei", "<", "nelt", "?", "1", ":", "2", ")", ";", "d", ".", "perm", "[", "i", "]", "=", "ei", ";", "perm", "[", "i", "]", "=", "ei", ";", "}", "switch", "(", "which", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "3", ":", "if", "(", "d", ".", "testing_p", "||", "!", "rtx_equal_p", "(", "d", ".", "op0", ",", "d", ".", "op1", ")", ")", "{", "d", ".", "one_operand_p", "=", "false", ";", "break", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "if", "(", "d", ".", "perm", "[", "i", "]", ">=", "nelt", ")", "d", ".", "perm", "[", "i", "]", "-=", "nelt", ";", "case", "1", ":", "d", ".", "op1", "=", "d", ".", "op0", ";", "d", ".", "one_operand_p", "=", "true", ";", "break", ";", "case", "2", ":", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", ".", "perm", "[", "i", "]", "-=", "nelt", ";", "d", ".", "op0", "=", "d", ".", "op1", ";", "d", ".", "one_operand_p", "=", "true", ";", "break", ";", "}", "if", "(", "d", ".", "testing_p", ")", "{", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "if", "(", "!", "d", ".", "one_operand_p", ")", "d", ".", "op1", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "3", ")", ";", "start_sequence", "(", ")", ";", "bool", "ret", "=", "ia64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "if", "(", "ia64_expand_vec_perm_const_1", "(", "&", "d", ")", ")", "return", "true", ";", "if", "(", "which", "==", "3", "&&", "d", ".", "one_operand_p", ")", "{", "memcpy", "(", "d", ".", "perm", ",", "perm", ",", "sizeof", "(", "perm", ")", ")", ";", "d", ".", "one_operand_p", "=", "false", ";", "return", "ia64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

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

[]

[ "<s>", "bool", "TeakRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "Teak", "Teak" ]

[]

[ "<s>", "StackOffset", "SystemZFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "StackOffset", "Offset", "=", "TargetFrameLowering", "::", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "return", "Offset", "+", "StackOffset", "::", "getFixed", "(", "SystemZMC", "::", "ELFCallFrameSize", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "SystemZ", "SystemZ", "SystemZMC::ELFCallFrameSize" ]

[]

[ "<s>", "const", "char", "*", "iq2000_fill_delay_slot", "(", "const", "char", "*", "ret", ",", "enum", "delay_type", "type", ",", "rtx", "operands", "[", "]", ",", "rtx", "cur_insn", ")", "{", "rtx", "set_reg", ";", "enum", "machine_mode", "mode", ";", "rtx", "next_insn", "=", "cur_insn", "?", "NEXT_INSN", "(", "cur_insn", ")", ":", "NULL_RTX", ";", "int", "num_nops", ";", "if", "(", "type", "==", "DELAY_LOAD", "||", "type", "==", "DELAY_FCMP", ")", "num_nops", "=", "1", ";", "else", "num_nops", "=", "0", ";", "next_insn", "=", "NEXT_INSN", "(", "cur_insn", ")", ";", "while", "(", "next_insn", "!=", "0", "&&", "(", "GET_CODE", "(", "next_insn", ")", "==", "NOTE", "||", "GET_CODE", "(", "next_insn", ")", "==", "CODE_LABEL", ")", ")", "next_insn", "=", "NEXT_INSN", "(", "next_insn", ")", ";", "dslots_load_total", "+=", "num_nops", ";", "if", "(", "TARGET_DEBUG_C_MODE", "||", "type", "==", "DELAY_NONE", "||", "operands", "==", "0", "||", "cur_insn", "==", "0", "||", "next_insn", "==", "0", "||", "GET_CODE", "(", "next_insn", ")", "==", "CODE_LABEL", "||", "(", "set_reg", "=", "operands", "[", "0", "]", ")", "==", "0", ")", "{", "dslots_number_nops", "=", "0", ";", "iq2000_load_reg", "=", "0", ";", "iq2000_load_reg2", "=", "0", ";", "iq2000_load_reg3", "=", "0", ";", "iq2000_load_reg4", "=", "0", ";", "return", "ret", ";", "}", "set_reg", "=", "operands", "[", "0", "]", ";", "if", "(", "set_reg", "==", "0", ")", "return", "ret", ";", "while", "(", "GET_CODE", "(", "set_reg", ")", "==", "SUBREG", ")", "set_reg", "=", "SUBREG_REG", "(", "set_reg", ")", ";", "mode", "=", "GET_MODE", "(", "set_reg", ")", ";", "dslots_number_nops", "=", "num_nops", ";", "iq2000_load_reg", "=", "set_reg", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "(", "unsigned", ")", "(", "UNITS_PER_WORD", ")", ")", "iq2000_load_reg2", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "set_reg", ")", "+", "1", ")", ";", "else", "iq2000_load_reg2", "=", "0", ";", "return", "ret", ";", "}", "</s>" ]

[ "Returns", "an", "operand", "string", "for", "the", "given", "instruction", "'s", "delay", "slot", ",", "after", "updating", "filled", "delay", "slot", "statistics", ".", "We", "assume", "that", "operands", "[", "0", "]", "is", "the", "target", "register", "that", "is", "set", ".", "In", "order", "to", "check", "the", "next", "insn", ",", "most", "of", "this", "functionality", "is", "moved", "to", "FINAL_PRESCAN_INSN", ",", "and", "we", "just", "set", "the", "global", "variables", "that", "it", "needs", "." ]

[ "iq2000", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "MCExpr", "const", "*", "HexagonMCExpr", "::", "getExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "Implementation", "of", "the", "SCEVPredicate", "interface", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "SIAtomicScope", "getScope", "(", ")", "const", "{", "return", "Scope", ";", "}", "</s>" ]

[ "Get", "the", "local", "scope", "for", "this", "variable", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSIMemoryLegalizerPass", "(", ")", ")", ";", "addPass", "(", "createSIInsertWaitcntsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSIModeRegisterPass", "(", ")", ")", ";", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "&", "SIRemoveShortExecBranchesID", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "pru_asm_regname", "(", "rtx", "op", ")", "{", "static", "char", "canon_reg_names", "[", "3", "]", "[", "LAST_GP_REGNUM", "]", "[", "8", "]", ";", "int", "speci", ",", "regi", ";", "gcc_assert", "(", "REG_P", "(", "op", ")", ")", ";", "if", "(", "!", "canon_reg_names", "[", "0", "]", "[", "0", "]", "[", "0", "]", ")", "{", "for", "(", "regi", "=", "0", ";", "regi", "<", "LAST_GP_REGNUM", ";", "regi", "++", ")", "for", "(", "speci", "=", "0", ";", "speci", "<", "3", ";", "speci", "++", ")", "{", "const", "int", "sz", "=", "(", "speci", "==", "0", ")", "?", "1", ":", "(", "(", "speci", "==", "1", ")", "?", "2", ":", "4", ")", ";", "if", "(", "(", "regi", "+", "sz", ")", ">", "(", "32", "*", "4", ")", ")", "continue", ";", "const", "char", "*", "suffix", "=", "\"\"", ";", "switch", "(", "(", "sz", "<<", "8", ")", "|", "(", "regi", "%", "4", ")", ")", "{", "case", "(", "1", "<<", "8", ")", "|", "0", ":", "suffix", "=", "\".b0\"", ";", "break", ";", "case", "(", "1", "<<", "8", ")", "|", "1", ":", "suffix", "=", "\".b1\"", ";", "break", ";", "case", "(", "1", "<<", "8", ")", "|", "2", ":", "suffix", "=", "\".b2\"", ";", "break", ";", "case", "(", "1", "<<", "8", ")", "|", "3", ":", "suffix", "=", "\".b3\"", ";", "break", ";", "case", "(", "2", "<<", "8", ")", "|", "0", ":", "suffix", "=", "\".w0\"", ";", "break", ";", "case", "(", "2", "<<", "8", ")", "|", "1", ":", "suffix", "=", "\".w1\"", ";", "break", ";", "case", "(", "2", "<<", "8", ")", "|", "2", ":", "suffix", "=", "\".w2\"", ";", "break", ";", "case", "(", "4", "<<", "8", ")", "|", "0", ":", "suffix", "=", "\"\"", ";", "break", ";", "default", ":", "continue", ";", "}", "sprintf", "(", "&", "canon_reg_names", "[", "speci", "]", "[", "regi", "]", "[", "0", "]", ",", "\"r%d%s\"", ",", "regi", "/", "4", ",", "suffix", ")", ";", "}", "}", "switch", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ")", "{", "case", "1", ":", "speci", "=", "0", ";", "break", ";", "case", "2", ":", "speci", "=", "1", ";", "break", ";", "case", "4", ":", "speci", "=", "2", ";", "break", ";", "case", "8", ":", "speci", "=", "2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "regi", "=", "REGNO", "(", "op", ")", ";", "gcc_assert", "(", "regi", "<", "LAST_GP_REGNUM", ")", ";", "gcc_assert", "(", "canon_reg_names", "[", "speci", "]", "[", "regi", "]", "[", "0", "]", ")", ";", "return", "&", "canon_reg_names", "[", "speci", "]", "[", "regi", "]", "[", "0", "]", ";", "}", "</s>" ]

[ "Translate", "between", "the", "MachineDescription", "notion", "of", "8-bit", "consecutive", "registers", ",", "to", "the", "PRU", "assembler", "syntax", "of", "REGWORD", "[", ".SUBREG", "]", "." ]

[ "pru", "3", "8", "0", "0", "0", "0", "0", "3", "0", "1", "1", "2", "4", "32", "4", "\"\"", "8", "4", "1", "8", "0", "\".b0\"", "1", "8", "1", "\".b1\"", "1", "8", "2", "\".b2\"", "1", "8", "3", "\".b3\"", "2", "8", "0", "\".w0\"", "2", "8", "1", "\".w1\"", "2", "8", "2", "\".w2\"", "4", "8", "0", "\"\"", "0", "\"r%d%s\"", "4", "1", "0", "2", "1", "4", "2", "8", "2", "0", "0" ]

[]

[ "<s>", "bool", "hasSMRDReadVALUDefHazard", "(", ")", "const", "{", "return", "getGeneration", "(", ")", "==", "SOUTHERN_ISLANDS", ";", "}", "</s>" ]

[ "A", "read", "of", "an", "SGPR", "by", "SMRD", "instruction", "requires", "4", "wait", "states", "when", "the", "SGPR", "was", "written", "by", "a", "VALU", "instruction", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "Z80FrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "hasFP", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Z80RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "unsigned", "MaxStackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MFI", ".", "getMaxAlignment", "(", ")", ")", ";", "FrameSize", "+=", "(", "MaxStackAlign", "-", "StackAlign", ")", ";", "StackAlign", "=", "MaxStackAlign", ";", "}", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "if", "(", "hasFP", ")", "{", "auto", "TMDL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "uint64_t", "ptr_size", "=", "TMDL", ".", "getPointerSizeInBits", "(", ")", "/", "8", ";", "FrameSize", "+=", "ptr_size", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Z80FrameLowering::determineFrameLayout] MF: '\"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"' has frame pointer, incrementing stack frame size by ptr_size.\\n\"", ")", ";", "}", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80", "8", "\"[Z80FrameLowering::determineFrameLayout] MF: '\"", "\"' has frame pointer, incrementing stack frame size by ptr_size.\\n\"" ]

[]

[ "<s>", "void", "SystemZHazardRecognizer", "::", "emitInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "TakenBranch", ")", "{", "SUnit", "SU", "(", "MI", ",", "0", ")", ";", "SU", ".", "isCall", "=", "MI", "->", "isCall", "(", ")", ";", "const", "MCSchedClassDesc", "*", "SC", "=", "SchedModel", "->", "resolveSchedClass", "(", "MI", ")", ";", "for", "(", "const", "MCWriteProcResEntry", "&", "PRE", ":", "make_range", "(", "SchedModel", "->", "getWriteProcResBegin", "(", "SC", ")", ",", "SchedModel", "->", "getWriteProcResEnd", "(", "SC", ")", ")", ")", "{", "switch", "(", "SchedModel", "->", "getProcResource", "(", "PRE", ".", "ProcResourceIdx", ")", "->", "BufferSize", ")", "{", "case", "0", ":", "SU", ".", "hasReservedResource", "=", "true", ";", "break", ";", "case", "1", ":", "SU", ".", "isUnbuffered", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "unsigned", "GroupSizeBeforeEmit", "=", "CurrGroupSize", ";", "EmitInstruction", "(", "&", "SU", ")", ";", "if", "(", "!", "TakenBranch", "&&", "isBranchRetTrap", "(", "MI", ")", ")", "{", "if", "(", "GroupSizeBeforeEmit", "==", "1", ")", "nextGroup", "(", ")", ";", "}", "if", "(", "TakenBranch", "&&", "CurrGroupSize", ">", "0", ")", "nextGroup", "(", ")", ";", "assert", "(", "(", "!", "MI", "->", "isTerminator", "(", ")", "||", "isBranchRetTrap", "(", "MI", ")", ")", "&&", "\"Scheduler: unhandled terminator!\"", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "0", "1", "1", "0", "\"Scheduler: unhandled terminator!\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "unsigned", "ExtraPredCycles", ",", "BranchProbability", "Probability", ")", "const", "{", "if", "(", "!", "NumCycles", ")", "return", "false", ";", "if", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "optForSize", "(", ")", ")", "{", "MachineBasicBlock", "*", "Pred", "=", "*", "MBB", ".", "pred_begin", "(", ")", ";", "if", "(", "!", "Pred", "->", "empty", "(", ")", ")", "{", "MachineInstr", "*", "LastMI", "=", "&", "*", "Pred", "->", "rbegin", "(", ")", ";", "if", "(", "LastMI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2Bcc", ")", "{", "MachineBasicBlock", "::", "iterator", "CmpMI", "=", "LastMI", ";", "if", "(", "CmpMI", "!=", "Pred", "->", "begin", "(", ")", ")", "{", "--", "CmpMI", ";", "if", "(", "CmpMI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tCMPi8", "||", "CmpMI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2CMPri", ")", "{", "unsigned", "Reg", "=", "CmpMI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "PredReg", "=", "0", ";", "ARMCC", "::", "CondCodes", "P", "=", "getInstrPredicate", "(", "CmpMI", ",", "PredReg", ")", ";", "if", "(", "P", "==", "ARMCC", "::", "AL", "&&", "CmpMI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", "&&", "isARMLowRegister", "(", "Reg", ")", ")", "return", "false", ";", "}", "}", "}", "}", "}", "const", "unsigned", "ScalingUpFactor", "=", "1024", ";", "unsigned", "UnpredCost", "=", "Probability", ".", "scale", "(", "NumCycles", "*", "ScalingUpFactor", ")", ";", "UnpredCost", "+=", "ScalingUpFactor", ";", "UnpredCost", "+=", "Subtarget", ".", "getMispredictionPenalty", "(", ")", "*", "ScalingUpFactor", "/", "10", ";", "return", "(", "NumCycles", "+", "ExtraPredCycles", ")", "*", "ScalingUpFactor", "<=", "UnpredCost", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "ARM", "ARM", "ARM::t2Bcc", "ARM::tCMPi8", "ARM::t2CMPri", "0", "0", "ARMCC::CondCodes", "ARMCC::AL", "1", "0", "ARM", "1024", "10" ]

[]