Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "TVMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createTVMContinuationsHoist", "(", ")", ")", ";", "TargetPassConfig", "::", "addPreRegAlloc", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "!", "VRegs", ".", "empty", "(", ")", ")", "||", "(", "!", "Val", "&&", "VRegs", ".", "empty", "(", ")", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "Val", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "const", "X86TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "X86TargetLowering", ">", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitEVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "Val", "->", "getType", "(", ")", ",", "SplitEVTs", ")", ";", "assert", "(", "VRegs", ".", "size", "(", ")", "==", "SplitEVTs", ".", "size", "(", ")", "&&", "\"For each split Type there should be exactly one VReg.\"", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SplitEVTs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "ArgInfo", "CurArgInfo", "=", "ArgInfo", "{", "VRegs", "[", "i", "]", ",", "SplitEVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", "}", ";", "setArgFlags", "(", "CurArgInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "if", "(", "!", "splitToValueTypes", "(", "CurArgInfo", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildUnmerge", "(", "Regs", ",", "VRegs", "[", "i", "]", ")", ";", "}", ")", ")", "return", "false", ";", "}", "OutgoingValueHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetCC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "X86", "X86", "\"Return value without a vreg\"", "X86::RET", "0", "X86", "X86", "4", "\"For each split Type there should be exactly one VReg.\"", "8", "0", "X86" ]

[]

[ "<s>", "const", "AArch64Subtarget", "*", "AArch64TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "TuneAttr", "=", "F", ".", "getFnAttribute", "(", "\"tune-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "TuneCPU", "=", "TuneAttr", ".", "isValid", "(", ")", "?", "TuneAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "CPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "unsigned", "MinSVEVectorSize", "=", "0", ";", "unsigned", "MaxSVEVectorSize", "=", "0", ";", "Attribute", "VScaleRangeAttr", "=", "F", ".", "getFnAttribute", "(", "Attribute", "::", "VScaleRange", ")", ";", "if", "(", "VScaleRangeAttr", ".", "isValid", "(", ")", ")", "{", "std", "::", "tie", "(", "MinSVEVectorSize", ",", "MaxSVEVectorSize", ")", "=", "VScaleRangeAttr", ".", "getVScaleRangeArgs", "(", ")", ";", "MinSVEVectorSize", "*=", "128", ";", "MaxSVEVectorSize", "*=", "128", ";", "}", "else", "{", "MinSVEVectorSize", "=", "SVEVectorBitsMinOpt", ";", "MaxSVEVectorSize", "=", "SVEVectorBitsMaxOpt", ";", "}", "assert", "(", "MinSVEVectorSize", "%", "128", "==", "0", "&&", "\"SVE requires vector length in multiples of 128!\"", ")", ";", "assert", "(", "MaxSVEVectorSize", "%", "128", "==", "0", "&&", "\"SVE requires vector length in multiples of 128!\"", ")", ";", "assert", "(", "(", "MaxSVEVectorSize", ">=", "MinSVEVectorSize", "||", "MaxSVEVectorSize", "==", "0", ")", "&&", "\"Minimum SVE vector size should not be larger than its maximum!\"", ")", ";", "if", "(", "MaxSVEVectorSize", "==", "0", ")", "MinSVEVectorSize", "=", "(", "MinSVEVectorSize", "/", "128", ")", "*", "128", ";", "else", "{", "MinSVEVectorSize", "=", "(", "std", "::", "min", "(", "MinSVEVectorSize", ",", "MaxSVEVectorSize", ")", "/", "128", ")", "*", "128", ";", "MaxSVEVectorSize", "=", "(", "std", "::", "max", "(", "MinSVEVectorSize", ",", "MaxSVEVectorSize", ")", "/", "128", ")", "*", "128", ";", "}", "Key", "+=", "\"SVEMin\"", ";", "Key", "+=", "std", "::", "to_string", "(", "MinSVEVectorSize", ")", ";", "Key", "+=", "\"SVEMax\"", ";", "Key", "+=", "std", "::", "to_string", "(", "MaxSVEVectorSize", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "TuneCPU", ";", "Key", "+=", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "AArch64Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "TuneCPU", ",", "FS", ",", "*", "this", ",", "isLittle", ",", "MinSVEVectorSize", ",", "MaxSVEVectorSize", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"target-cpu\"", "\"tune-cpu\"", "\"target-features\"", "512", "0", "0", "128", "128", "128", "0", "\"SVE requires vector length in multiples of 128!\"", "128", "0", "\"SVE requires vector length in multiples of 128!\"", "0", "\"Minimum SVE vector size should not be larger than its maximum!\"", "0", "128", "128", "128", "128", "128", "128", "\"SVEMin\"", "\"SVEMax\"", "AArch64" ]

[]

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

[ "This", "is", "just", "a", "placeholder", "to", "make", "linking", "work", "without", "having", "to", "add", "this", "to", "the", "generic", "Darwin", "EXTRA_SECTIONS", ".", "If", "-mcall-aix", "is", "ever", "needed", "for", "Darwin", "(", "not", "too", "likely", "!", ")", "this", "would", "have", "to", "get", "a", "real", "definition", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "usesConstantBus", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineOperand", "&", "MO", ",", "unsigned", "OpSize", ")", "const", "{", "if", "(", "isLiteralConstant", "(", "MO", ",", "OpSize", ")", ")", "return", "true", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isUse", "(", ")", ")", "return", "false", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "return", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "FLAT_SCR", ")", ")", "return", "true", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "EXEC", ")", "return", "true", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "M0", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", "||", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "SGPR_64RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "bool", "isStack", "(", ")", "const", "{", "return", "type", "==", "RAInfo", "::", "LocType", "::", "Stack", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "stack", "slot", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "arm_output_multireg_pop", "(", "rtx", "*", "operands", ",", "bool", "return_pc", ",", "rtx", "cond", ",", "bool", "reverse", ",", "bool", "update", ")", "{", "int", "i", ";", "char", "pattern", "[", "100", "]", ";", "int", "offset", ";", "const", "char", "*", "conditional", ";", "int", "num_saves", "=", "XVECLEN", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "unsigned", "int", "regno", ";", "unsigned", "int", "regno_base", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "offset", "=", "0", ";", "offset", "+=", "update", "?", "1", ":", "0", ";", "offset", "+=", "return_pc", "?", "1", ":", "0", ";", "for", "(", "i", "=", "offset", ";", "i", "<", "num_saves", ";", "i", "++", ")", "{", "regno", "=", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "operands", "[", "0", "]", ",", "0", ",", "i", ")", ",", "0", ")", ")", ";", "gcc_assert", "(", "(", "regno", "!=", "SP_REGNUM", ")", "||", "(", "regno_base", "==", "SP_REGNUM", ")", ")", ";", "if", "(", "regno", "==", "regno_base", ")", "gcc_assert", "(", "!", "update", ")", ";", "}", "conditional", "=", "reverse", "?", "\"%?%D0\"", ":", "\"%?%d0\"", ";", "if", "(", "(", "regno_base", "==", "SP_REGNUM", ")", "&&", "update", ")", "{", "sprintf", "(", "pattern", ",", "\"pop%s\\t{\"", ",", "conditional", ")", ";", "}", "else", "{", "if", "(", "regno_base", "==", "SP_REGNUM", ")", "sprintf", "(", "pattern", ",", "\"ldmfd%s\"", ",", "conditional", ")", ";", "if", "(", "update", ")", "sprintf", "(", "pattern", ",", "\"ldmia%s\\t\"", ",", "conditional", ")", ";", "else", "sprintf", "(", "pattern", ",", "\"ldm%s\\t\"", ",", "conditional", ")", ";", "strcat", "(", "pattern", ",", "reg_names", "[", "regno_base", "]", ")", ";", "if", "(", "update", ")", "strcat", "(", "pattern", ",", "\"!, {\"", ")", ";", "else", "strcat", "(", "pattern", ",", "\", {\"", ")", ";", "}", "strcat", "(", "pattern", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "operands", "[", "0", "]", ",", "0", ",", "offset", ")", ",", "0", ")", ")", "]", ")", ";", "for", "(", "i", "=", "offset", "+", "1", ";", "i", "<", "num_saves", ";", "i", "++", ")", "{", "strcat", "(", "pattern", ",", "\", \"", ")", ";", "strcat", "(", "pattern", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "operands", "[", "0", "]", ",", "0", ",", "i", ")", ",", "0", ")", ")", "]", ")", ";", "}", "strcat", "(", "pattern", ",", "\"}\"", ")", ";", "if", "(", "IS_INTERRUPT", "(", "arm_current_func_type", "(", ")", ")", "&&", "return_pc", ")", "strcat", "(", "pattern", ",", "\"^\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "&", "cond", ")", ";", "}", "</s>" ]

[ "OPERANDS", "[", "0", "]", "is", "the", "entire", "list", "of", "insns", "that", "constitute", "pop", ",", "OPERANDS", "[", "1", "]", "is", "the", "base", "register", ",", "RETURN_PC", "is", "true", "iff", "return", "insn", "is", "in", "the", "list", ",", "UPDATE", "is", "true", "iff", "the", "list", "contains", "explicit", "update", "of", "base", "register", "." ]

[ "arm", "100", "0", "0", "1", "0", "1", "0", "1", "0", "0", "0", "0", "\"%?%D0\"", "\"%?%d0\"", "\"pop%s\\t{\"", "\"ldmfd%s\"", "\"ldmia%s\\t\"", "\"ldm%s\\t\"", "\"!, {\"", "\", {\"", "0", "0", "0", "1", "\", \"", "0", "0", "0", "\"}\"", "\"^\"" ]

[]

[ "<s>", "static", "void", "arm_add_cfa_adjust_cfa_note", "(", "rtx", "insn", ",", "int", "size", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "rtx", "dwarf", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "dwarf", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "plus_constant", "(", "Pmode", ",", "src", ",", "size", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "dwarf", ")", ";", "}", "</s>" ]

[ "Add", "a", "REG_CFA_ADJUST_CFA", "REG", "note", "to", "INSN", ".", "SIZE", "is", "the", "offset", "to", "be", "adjusted", ".", "DEST", "and", "SRC", "might", "be", "stack_pointer_rtx", "or", "hard_frame_pointer_rtx", "." ]

[ "arm", "1" ]

[]

[ "<s>", "InstructionCost", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", "=", "TTI", "::", "TCK_RecipThroughput", ",", "TTI", "::", "OperandValueKind", "Opd1Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueKind", "Opd2Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", "=", "TTI", "::", "OP_None", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", "=", "TTI", "::", "OP_None", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", "=", "ArrayRef", "<", "const", "Value", "*", ">", "(", ")", ",", "const", "Instruction", "*", "CxtI", "=", "nullptr", ")", "{", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "if", "(", "ISD", "==", "ISD", "::", "ADD", "&&", "CostKind", "==", "TTI", "::", "TCK_RecipThroughput", ")", "return", "SCEVCheapExpansionBudget", ".", "getValue", "(", ")", "+", "1", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "BPF", "ISD::ADD", "1" ]

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "CPUString", "=", "Hexagon_MC", "::", "selectHexagonCPU", "(", "getTargetTriple", "(", ")", ",", "CPU", ")", ";", "static", "std", "::", "map", "<", "StringRef", ",", "HexagonArchEnum", ">", "CpuTable", "{", "{", "\"hexagonv4\"", ",", "V4", "}", ",", "{", "\"hexagonv5\"", ",", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "V60", "}", ",", "}", ";", "auto", "foundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "foundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "foundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVXOps", "=", "false", ";", "UseHVXDblOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "EnableHexagonHVX", ".", "getPosition", "(", ")", ")", "UseHVXOps", "=", "EnableHexagonHVX", ";", "if", "(", "EnableHexagonHVXDouble", ".", "getPosition", "(", ")", ")", "UseHVXDblOps", "=", "EnableHexagonHVXDouble", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"hexagonv4\"", "\"hexagonv5\"", "\"hexagonv55\"", "\"hexagonv60\"", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getVaListSizeInBits", "(", "const", "DataLayout", "&", "DL", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", "||", "Subtarget", "->", "isTargetWindows", "(", ")", ")", "return", "getPointerTy", "(", "DL", ")", ".", "getSizeInBits", "(", ")", ";", "return", "3", "*", "getPointerTy", "(", "DL", ")", ".", "getSizeInBits", "(", ")", "+", "2", "*", "32", ";", "}", "</s>" ]

[ "Returns", "the", "size", "of", "the", "platform", "'s", "va_list", "object", "." ]

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

[]

[ "<s>", "unsigned", "SNESRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "return", "SNES", "::", "Y", ";", "}", "return", "SNES", "::", "SP", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES::Y", "SNES::SP" ]

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* Hexagon Hardware Loops *********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "TM", "=", "static_cast", "<", "const", "HexagonTargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "TM", "->", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "HexagonRegisterInfo", "*", ">", "(", "TM", "->", "getRegisterInfo", "(", ")", ")", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "I", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineLoop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "Changed", "|=", "convertToHardwareLoop", "(", "L", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"********* Hexagon Hardware Loops *********\\n\"", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", "&", "TM", ")", ")", ";", "addPass", "(", "createStructurizeCFGPass", "(", "true", ")", ")", ";", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createSITypeRewriter", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "rs6000_emit_prologue_move_from_cr", "(", "rtx", "reg", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "TARGET_MFCRF", ")", "{", "int", "i", ",", "cr_reg", "[", "8", "]", ",", "count", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "cr_reg", "[", "count", "++", "]", "=", "i", ";", "if", "(", "count", "==", "1", ")", "{", "rtvec", "p", "=", "rtvec_alloc", "(", "1", ")", ";", "rtvec", "r", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "r", ",", "0", ")", "=", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "cr_reg", "[", "0", "]", ")", ";", "RTVEC_ELT", "(", "r", ",", "1", ")", "=", "GEN_INT", "(", "1", "<<", "(", "7", "-", "cr_reg", "[", "0", "]", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "0", ")", "=", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_UNSPEC", "(", "SImode", ",", "r", ",", "UNSPEC_MOVESI_FROM_CR", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ";", "return", ";", "}", "}", "emit_insn", "(", "gen_prologue_movesi_from_cr", "(", "reg", ")", ")", ";", "}", "</s>" ]

[ "Emit", "prologue", "code", "to", "store", "CR", "fields", "that", "need", "to", "be", "saved", "into", "REG", ".", "This", "function", "should", "only", "be", "called", "when", "moving", "the", "non-volatile", "CRs", "to", "REG", ",", "it", "is", "not", "a", "general", "purpose", "routine", "to", "move", "the", "entire", "set", "of", "CRs", "to", "REG", ".", "Specifically", ",", "gen_prologue_movesi_from_cr", "(", ")", "does", "not", "contain", "uses", "of", "the", "volatile", "CRs", "." ]

[ "rs6000", "8", "0", "0", "8", "1", "1", "2", "0", "0", "1", "1", "7", "0", "0" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "VectorComponents", "=", "0", ";", "if", "(", "(", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "DestReg", ")", "||", "AMDGPU", "::", "R600_Reg128VerticalRegClass", ".", "contains", "(", "DestReg", ")", ")", "&&", "(", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "R600_Reg128VerticalRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "VectorComponents", "=", "4", ";", "}", "else", "if", "(", "(", "AMDGPU", "::", "R600_Reg64RegClass", ".", "contains", "(", "DestReg", ")", "||", "AMDGPU", "::", "R600_Reg64VerticalRegClass", ".", "contains", "(", "DestReg", ")", ")", "&&", "(", "AMDGPU", "::", "R600_Reg64RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "R600_Reg64VerticalRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "VectorComponents", "=", "2", ";", "}", "if", "(", "VectorComponents", ">", "0", ")", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "VectorComponents", ";", "I", "++", ")", "{", "unsigned", "SubRegIndex", "=", "RI", ".", "getSubRegFromChannel", "(", "I", ")", ";", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SubRegIndex", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SubRegIndex", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "}", "}", "else", "{", "MachineInstr", "*", "NewMI", "=", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "DestReg", ",", "SrcReg", ")", ";", "NewMI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "NewMI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ".", "setIsKill", "(", "KillSrc", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600", "0", "AMDGPU::R600_Reg128RegClass", "AMDGPU::R600_Reg128VerticalRegClass", "AMDGPU::R600_Reg128RegClass", "AMDGPU::R600_Reg128VerticalRegClass", "4", "AMDGPU::R600_Reg64RegClass", "AMDGPU::R600_Reg64VerticalRegClass", "AMDGPU::R600_Reg64RegClass", "AMDGPU::R600_Reg64VerticalRegClass", "2", "0", "0", "AMDGPU::MOV", "AMDGPU::MOV", "AMDGPU::OpName" ]

[]

[ "<s>", "static", "void", "emit_load_locked", "(", "machine_mode", "mode", ",", "rtx", "reg", ",", "rtx", "mem", ")", "{", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "emit_insn", "(", "gen_load_locked_si", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]

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

[ "or1k" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "ForCodeSize", "=", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "OptimizeForSize", ")", "||", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "MinSize", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tLDRspi", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLD1q64Pseudo", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::LDRrs", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::LDRi12", "ARM::t2LDRi12", "ARM::tLDRspi", "ARM::VLDRD", "ARM::VLDRS", "1", "2", "2", "0", "1", "0", "ARM::VLD1q64Pseudo", "1", "0", "0", "1", "0", "ARM::VLDMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "arm_slowmul_rtx_costs", "(", "rtx", "x", ",", "enum", "rtx_code", "code", ",", "enum", "rtx_code", "outer_code", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "TARGET_THUMB", ")", "{", "*", "total", "=", "thumb1_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "}", "switch", "(", "code", ")", "{", "case", "MULT", ":", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "mode", "==", "DImode", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "20", ")", ";", "return", "false", ";", "}", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "unsigned", "HOST_WIDE_INT", "i", "=", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffff", ")", ";", "int", "cost", ",", "const_ok", "=", "const_ok_for_arm", "(", "i", ")", ";", "int", "j", ",", "booth_unit_size", ";", "cost", "=", "const_ok", "?", "4", ":", "8", ";", "booth_unit_size", "=", "2", ";", "for", "(", "j", "=", "0", ";", "i", "&&", "j", "<", "32", ";", "j", "+=", "booth_unit_size", ")", "{", "i", ">>=", "booth_unit_size", ";", "cost", "++", ";", "}", "*", "total", "=", "COSTS_N_INSNS", "(", "cost", ")", ";", "*", "total", "+=", "rtx_cost", "(", "XEXP", "(", "x", ",", "0", ")", ",", "code", ",", "0", ",", "speed", ")", ";", "return", "true", ";", "}", "*", "total", "=", "COSTS_N_INSNS", "(", "20", ")", ";", "return", "false", ";", "default", ":", "return", "arm_rtx_costs_1", "(", "x", ",", "outer_code", ",", "total", ",", "speed", ")", ";", ";", "}", "}", "</s>" ]

[ "RTX", "costs", "for", "cores", "with", "a", "slow", "MUL", "implementation", ".", "Thumb-2", "is", "not", "supported", "on", "any", "``", "slowmul", "''", "cores", ",", "so", "it", "can", "be", "ignored", "." ]

[ "arm", "20", "1", "1", "0xffffffff", "4", "8", "2", "0", "32", "0", "0", "20" ]

[]

[ "<s>", "static", "void", "replace_insns", "(", "rtx_insn", "*", "old_insn", ",", "rtx_insn", "*", "new_insns", ")", "{", "if", "(", "new_insns", ")", "emit_insn_before", "(", "new_insns", ",", "old_insn", ")", ";", "delete_insn", "(", "old_insn", ")", ";", "}", "</s>" ]

[ "Replace", "OLD_INSN", "with", "NEW_INSN", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "TargetInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", "||", "MI", ".", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "&", "RI", ")", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_SETREG_IMM32_B32", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_SETREG_B32", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_DENORM_MODE", "||", "changesVGPRIndexingMode", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::S_SETREG_IMM32_B32", "AMDGPU::S_SETREG_B32", "AMDGPU::S_DENORM_MODE" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasV8_1aOps", "(", "false", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "HasCRC", "(", "false", ")", ",", "HasPerfMon", "(", "false", ")", ",", "HasZeroCycleRegMove", "(", "false", ")", ",", "HasZeroCycleZeroing", "(", "false", ")", ",", "StrictAlign", "(", "false", ")", ",", "ReserveX18", "(", "TT", ".", "isOSDarwin", "(", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "alpha_canonicalize_comparison", "(", "int", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "bool", "op0_preserve_value", ")", "{", "if", "(", "!", "op0_preserve_value", "&&", "(", "*", "code", "==", "GE", "||", "*", "code", "==", "GT", "||", "*", "code", "==", "GEU", "||", "*", "code", "==", "GTU", ")", "&&", "(", "REG_P", "(", "*", "op1", ")", "||", "*", "op1", "==", "const0_rtx", ")", ")", "{", "std", "::", "swap", "(", "*", "op0", ",", "*", "op1", ")", ";", "*", "code", "=", "(", "int", ")", "swap_condition", "(", "(", "enum", "rtx_code", ")", "*", "code", ")", ";", "}", "if", "(", "(", "*", "code", "==", "LT", "||", "*", "code", "==", "LTU", ")", "&&", "CONST_INT_P", "(", "*", "op1", ")", "&&", "INTVAL", "(", "*", "op1", ")", "==", "256", ")", "{", "*", "code", "=", "*", "code", "==", "LT", "?", "LE", ":", "LEU", ";", "*", "op1", "=", "GEN_INT", "(", "255", ")", ";", "}", "}", "</s>" ]

[ "Canonicalize", "a", "comparison", "from", "one", "we", "do", "n't", "have", "to", "one", "we", "do", "have", "." ]

[ "alpha", "256", "255" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AttributeSet", "&", "FnAttrs", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "if", "(", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "||", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ")", "{", "return", "false", ";", "}", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", "if", "(", "!", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "MF", ".", "begin", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "0", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

[ "<s>", "enum", "nds32_16bit_address_type", "nds32_mem_format", "(", "rtx", "op", ")", "{", "machine_mode", "mode_test", ";", "int", "val", ";", "int", "regno", ";", "if", "(", "!", "TARGET_16_BIT", ")", "return", "ADDRESS_NOT_16BIT_FORMAT", ";", "mode_test", "=", "GET_MODE", "(", "op", ")", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", "&&", "(", "mode_test", "==", "SImode", ")", ")", "return", "ADDRESS_REG", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", "&&", "(", "REGNO", "(", "op", ")", "<", "R8_REGNUM", ")", ")", "return", "ADDRESS_LO_REG_IMM3U", ";", "if", "(", "(", "GET_CODE", "(", "op", ")", "==", "POST_INC", ")", "&&", "(", "mode_test", "==", "SImode", ")", ")", "{", "regno", "=", "REGNO", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "if", "(", "regno", "<", "8", ")", "return", "ADDRESS_POST_INC_LO_REG_IMM3U", ";", "}", "if", "(", "(", "GET_CODE", "(", "op", ")", "==", "POST_MODIFY", ")", "&&", "(", "mode_test", "==", "SImode", ")", "&&", "(", "REG_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "1", ")", ",", "0", ")", ")", ")", "&&", "(", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "1", ")", ",", "1", ")", ")", ")", ")", "{", "regno", "=", "REGNO", "(", "XEXP", "(", "XEXP", "(", "op", ",", "1", ")", ",", "0", ")", ")", ";", "val", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "1", ")", ",", "1", ")", ")", ";", "if", "(", "regno", "<", "8", "&&", "val", "<", "32", ")", "return", "ADDRESS_POST_INC_LO_REG_IMM3U", ";", "}", "if", "(", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "REG", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "CONST_INT", ")", ")", "{", "val", "=", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ";", "regno", "=", "REGNO", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "if", "(", "regno", ">", "7", "&&", "regno", "!=", "SP_REGNUM", "&&", "regno", "!=", "FP_REGNUM", ")", "return", "ADDRESS_NOT_16BIT_FORMAT", ";", "switch", "(", "mode_test", ")", "{", "case", "QImode", ":", "if", "(", "val", ">=", "0", "&&", "val", "<", "8", "&&", "regno", "<", "8", ")", "return", "ADDRESS_LO_REG_IMM3U", ";", "break", ";", "case", "HImode", ":", "if", "(", "val", ">=", "0", "&&", "val", "<", "16", "&&", "(", "val", "%", "2", "==", "0", ")", "&&", "regno", "<", "8", ")", "return", "ADDRESS_LO_REG_IMM3U", ";", "break", ";", "case", "SImode", ":", "case", "SFmode", ":", "case", "DFmode", ":", "if", "(", "(", "regno", "==", "FP_REGNUM", ")", "&&", "(", "val", ">=", "0", "&&", "val", "<", "512", "&&", "(", "val", "%", "4", "==", "0", ")", ")", ")", "return", "ADDRESS_FP_IMM7U", ";", "else", "if", "(", "(", "regno", "==", "SP_REGNUM", ")", "&&", "(", "val", ">=", "0", "&&", "val", "<", "512", "&&", "(", "val", "%", "4", "==", "0", ")", ")", ")", "return", "ADDRESS_SP_IMM7U", ";", "else", "if", "(", "val", ">=", "0", "&&", "val", "<", "32", "&&", "(", "val", "%", "4", "==", "0", ")", "&&", "regno", "<", "8", ")", "return", "ADDRESS_LO_REG_IMM3U", ";", "break", ";", "default", ":", "break", ";", "}", "}", "return", "ADDRESS_NOT_16BIT_FORMAT", ";", "}", "</s>" ]

[ "A", "helper", "function", "to", "return", "memory", "format", "." ]

[ "nds32", "0", "0", "8", "1", "0", "1", "1", "1", "0", "1", "1", "8", "32", "0", "1", "1", "0", "7", "0", "8", "8", "0", "16", "2", "0", "8", "0", "512", "4", "0", "0", "512", "4", "0", "0", "32", "4", "0", "8" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "RISCV", "::", "GPRRegClass", ";", "for", "(", "int", "FI", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ",", "EFI", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "FI", "<", "EFI", ";", "FI", "++", ")", "{", "if", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "RISCVVector", "&&", "!", "MFI", ".", "isDeadObjectIndex", "(", "FI", ")", ")", "RVFI", "->", "setHasSpillVRs", "(", ")", ";", "}", "if", "(", "!", "isInt", "<", "11", ">", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ")", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlign", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "aarch64_expand_subvti", "(", "rtx", "op0", ",", "rtx", "low_dest", ",", "rtx", "low_in1", ",", "rtx", "low_in2", ",", "rtx", "high_dest", ",", "rtx", "high_in1", ",", "rtx", "high_in2", ",", "bool", "unsigned_p", ")", "{", "if", "(", "low_in2", "==", "const0_rtx", ")", "{", "low_dest", "=", "low_in1", ";", "high_in2", "=", "force_reg", "(", "DImode", ",", "high_in2", ")", ";", "if", "(", "unsigned_p", ")", "emit_insn", "(", "gen_subdi3_compare1", "(", "high_dest", ",", "high_in1", ",", "high_in2", ")", ")", ";", "else", "emit_insn", "(", "gen_subvdi_insn", "(", "high_dest", ",", "high_in1", ",", "high_in2", ")", ")", ";", "}", "else", "{", "if", "(", "CONST_INT_P", "(", "low_in2", ")", ")", "{", "high_in2", "=", "force_reg", "(", "DImode", ",", "high_in2", ")", ";", "emit_insn", "(", "gen_subdi3_compare1_imm", "(", "low_dest", ",", "low_in1", ",", "low_in2", ",", "GEN_INT", "(", "-", "INTVAL", "(", "low_in2", ")", ")", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_subdi3_compare1", "(", "low_dest", ",", "low_in1", ",", "low_in2", ")", ")", ";", "if", "(", "unsigned_p", ")", "emit_insn", "(", "gen_usubdi3_carryinC", "(", "high_dest", ",", "high_in1", ",", "high_in2", ")", ")", ";", "else", "emit_insn", "(", "gen_subdi3_carryinV", "(", "high_dest", ",", "high_in1", ",", "high_in2", ")", ")", ";", "}", "emit_move_insn", "(", "gen_lowpart", "(", "DImode", ",", "op0", ")", ",", "low_dest", ")", ";", "emit_move_insn", "(", "gen_highpart", "(", "DImode", ",", "op0", ")", ",", "high_dest", ")", ";", "}", "</s>" ]

[ "Generate", "RTL", "for", "128-bit", "(", "TImode", ")", "subtraction", "with", "overflow", ".", "OP0", "represents", "the", "TImode", "destination", "operand", "0", "LOW_DEST", "represents", "the", "low", "half", "(", "DImode", ")", "of", "TImode", "operand", "0", "LOW_IN1", "represents", "the", "low", "half", "(", "DImode", ")", "of", "TImode", "operand", "1", "LOW_IN2", "represents", "the", "low", "half", "(", "DImode", ")", "of", "TImode", "operand", "2", "HIGH_DEST", "represents", "the", "high", "half", "(", "DImode", ")", "of", "TImode", "operand", "0", "HIGH_IN1", "represents", "the", "high", "half", "(", "DImode", ")", "of", "TImode", "operand", "1", "HIGH_IN2", "represents", "the", "high", "half", "(", "DImode", ")", "of", "TImode", "operand", "2", "UNSIGNED_P", "is", "true", "if", "the", "operation", "is", "being", "performed", "on", "unsigned", "values", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "mips_order_regs_for_local_alloc", "(", ")", "{", "register", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "reg_alloc_order", "[", "i", "]", "=", "i", ";", "if", "(", "TARGET_MIPS16", ")", "{", "reg_alloc_order", "[", "0", "]", "=", "24", ";", "reg_alloc_order", "[", "24", "]", "=", "0", ";", "}", "}", "</s>" ]

[ "On", "the", "mips16", ",", "we", "want", "to", "allocate", "$", "24", "(", "T_REG", ")", "before", "other", "registers", "for", "instructions", "for", "which", "it", "is", "possible", ".", "This", "helps", "avoid", "shuffling", "registers", "around", "in", "order", "to", "set", "up", "for", "an", "xor", ",", "encouraging", "the", "compiler", "to", "use", "a", "cmp", "instead", "." ]

[ "mips", "0", "0", "24", "24", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "csky_mangle_type", "(", "const_tree", "type", ")", "{", "if", "(", "TYPE_NAME", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_NAME", "(", "type", ")", ")", "==", "TYPE_DECL", "&&", "DECL_NAME", "(", "TYPE_NAME", "(", "type", ")", ")", "&&", "!", "strcmp", "(", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "TYPE_NAME", "(", "type", ")", ")", ")", ",", "\"__fp16\"", ")", ")", "return", "\"__fp16\"", ";", "return", "NULL", ";", "}", "</s>" ]

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

[ "csky", "\"__fp16\"", "\"__fp16\"" ]

[]

[ "<s>", "void", "rs6000_call_darwin_1", "(", "rtx", "value", ",", "rtx", "func_desc", ",", "rtx", "tlsarg", ",", "rtx", "cookie", ",", "bool", "sibcall", ")", "{", "rtx", "func", "=", "func_desc", ";", "rtx", "func_addr", ";", "rtx", "call", "[", "3", "]", ";", "rtx", "insn", ";", "int", "cookie_val", "=", "INTVAL", "(", "cookie", ")", ";", "bool", "make_island", "=", "false", ";", "if", "(", "(", "cookie_val", "&", "CALL_LONG", ")", "!=", "0", "&&", "GET_CODE", "(", "func_desc", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "darwin_symbol_stubs", "&&", "TARGET_32BIT", ")", "make_island", "=", "true", ";", "else", "{", "func", "=", "rs6000_longcall_ref", "(", "func_desc", ",", "NULL_RTX", ")", ";", "cookie_val", "&=", "~", "CALL_LONG", ";", "}", "}", "if", "(", "GET_CODE", "(", "func", ")", "!=", "SYMBOL_REF", ")", "{", "func", "=", "force_reg", "(", "Pmode", ",", "func", ")", ";", "func_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "CTR_REGNO", ")", ";", "emit_move_insn", "(", "func_addr", ",", "func", ")", ";", "}", "else", "func_addr", "=", "func", ";", "call", "[", "0", "]", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "func_addr", ")", ",", "tlsarg", ")", ";", "if", "(", "value", "!=", "NULL_RTX", ")", "call", "[", "0", "]", "=", "gen_rtx_SET", "(", "value", ",", "call", "[", "0", "]", ")", ";", "call", "[", "1", "]", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "GEN_INT", "(", "cookie_val", ")", ")", ";", "if", "(", "sibcall", ")", "call", "[", "2", "]", "=", "simple_return_rtx", ";", "else", "call", "[", "2", "]", "=", "gen_hard_reg_clobber", "(", "Pmode", ",", "LR_REGNO", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "3", ",", "call", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "insn", ")", ";", "if", "(", "make_island", ")", "{", "tree", "funname", "=", "get_identifier", "(", "XSTR", "(", "func_desc", ",", "0", ")", ")", ";", "if", "(", "no_previous_def", "(", "funname", ")", ")", "{", "rtx", "label_rtx", "=", "gen_label_rtx", "(", ")", ";", "char", "*", "label_buf", ",", "temp_buf", "[", "256", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "temp_buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "label_rtx", ")", ")", ";", "label_buf", "=", "temp_buf", "[", "0", "]", "==", "'*'", "?", "temp_buf", "+", "1", ":", "temp_buf", ";", "tree", "labelname", "=", "get_identifier", "(", "label_buf", ")", ";", "add_compiler_branch_island", "(", "labelname", ",", "funname", ",", "insn_line", "(", "(", "const", "rtx_insn", "*", ")", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "code", "to", "perform", "a", "call", "under", "the", "Darwin", "ABI", ".", "Modulo", "handling", "of", "mlongcall", ",", "this", "is", "much", "the", "same", "as", "sysv", ".", "if/when", "the", "longcall", "optimisation", "is", "removed", ",", "we", "could", "drop", "this", "code", "and", "use", "the", "sysv", "case", "(", "taking", "care", "to", "avoid", "the", "tls", "stuff", ")", ".", "We", "can", "use", "this", "for", "sibcalls", "too", ",", "if", "needed", "." ]

[ "rs6000", "3", "0", "0", "0", "0", "1", "2", "2", "3", "0", "256", "\"L\"", "0", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "bool", "UseSplitPush", "=", "STI", ".", "splitFramePushPop", "(", "*", "MF", ")", ";", "const", "MCPhysReg", "*", "RegList", "=", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_SaveList", ":", "(", "UseSplitPush", "?", "CSR_AAPCS_SplitPush_SaveList", ":", "CSR_AAPCS_SaveList", ")", ";", "const", "Function", "&", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "else", "if", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CFGuard_Check", ")", "{", "return", "CSR_Win_AAPCS_CFGuard_Check_SaveList", ";", "}", "else", "if", "(", "F", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "isMClass", "(", ")", ")", "{", "return", "UseSplitPush", "?", "CSR_AAPCS_SplitPush_SaveList", ":", "CSR_AAPCS_SaveList", ";", "}", "else", "if", "(", "F", ".", "getFnAttribute", "(", "\"interrupt\"", ")", ".", "getValueAsString", "(", ")", "==", "\"FIQ\"", ")", "{", "return", "CSR_FIQ_SaveList", ";", "}", "else", "{", "return", "CSR_GenericInt_SaveList", ";", "}", "}", "if", "(", "STI", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "{", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "return", "CSR_iOS_SwiftError_SaveList", ";", "return", "UseSplitPush", "?", "CSR_AAPCS_SplitPush_SwiftError_SaveList", ":", "CSR_AAPCS_SwiftError_SaveList", ";", "}", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "&&", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_iOS_CXX_TLS_PE_SaveList", ":", "CSR_iOS_CXX_TLS_SaveList", ";", "return", "RegList", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"interrupt\"", "\"interrupt\"", "\"FIQ\"", "ARM" ]

[]

[ "<s>", "bool", "TMS320C64XScheduler", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "AliasAnalysis", "*", "AA", "=", "&", "getAnalysis", "<", "AliasAnalysis", ">", "(", ")", ";", "TMS320C64XMachineFunctionInfo", "*", "MFI", "=", "Fn", ".", "getInfo", "<", "TMS320C64XMachineFunctionInfo", ">", "(", ")", ";", "const", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "ScheduleHazardRecognizer", "*", "HR", "=", "TMS320C64XInstrInfo", "::", "CreatePostRAHazardRecognizer", "(", "&", "TM", ")", ";", "assert", "(", "TM", ".", "getInstrItineraryData", "(", ")", "&&", "!", "TM", ".", "getInstrItineraryData", "(", ")", "->", "isEmpty", "(", ")", ")", ";", "unsigned", "NumCycles", "=", "0", ";", "CustomListScheduler", "*", "Scheduler", "=", "new", "CustomListScheduler", "(", "Fn", ",", "MLI", ",", "MDT", ",", "HR", ",", "AA", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "unsigned", "BlockCycles", "=", "0", ";", "addTerminatorInstr", "(", "MBB", ")", ";", "bool", "BlockHasTerm", "=", "prior", "(", "MBB", "->", "end", "(", ")", ")", "->", "getOpcode", "(", ")", "==", "TMS320C64X", "::", "BR_OCCURS", ";", "Scheduler", "->", "StartBlock", "(", "MBB", ")", ";", "MachineBasicBlock", "::", "iterator", "Current", "=", "MBB", "->", "end", "(", ")", ";", "unsigned", "Count", "=", "MBB", "->", "size", "(", ")", ",", "CurrentCount", "=", "Count", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "Current", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", ")", "{", "MachineInstr", "*", "MI", "=", "prior", "(", "I", ")", ";", "if", "(", "isSchedulingBoundary", "(", "MI", ",", "Fn", ")", ")", "{", "Scheduler", "->", "Run", "(", "MBB", ",", "I", ",", "Current", ",", "CurrentCount", ")", ";", "BlockCycles", "+=", "Scheduler", "->", "getCycles", "(", ")", ";", "Scheduler", "->", "EmitSchedule", "(", ")", ";", "Current", "=", "MI", ";", "CurrentCount", "=", "Count", "-", "1", ";", "Scheduler", "->", "Observe", "(", "MI", ",", "CurrentCount", ")", ";", "}", "I", "=", "MI", ";", "--", "Count", ";", "}", "assert", "(", "Count", "==", "0", "&&", "\"Instruction count mismatch!\"", ")", ";", "assert", "(", "(", "MBB", "->", "begin", "(", ")", "==", "Current", "||", "CurrentCount", "!=", "0", ")", "&&", "\"Instruction count mismatch!\"", ")", ";", "Scheduler", "->", "Run", "(", "MBB", ",", "MBB", "->", "begin", "(", ")", ",", "Current", ",", "CurrentCount", ")", ";", "BlockCycles", "+=", "Scheduler", "->", "getCycles", "(", ")", ";", "Scheduler", "->", "EmitSchedule", "(", ")", ";", "if", "(", "BlockHasTerm", ")", "{", "MachineBasicBlock", "::", "iterator", "LastMI", "=", "MBB", "->", "end", "(", ")", ";", "do", "{", "LastMI", "=", "prior", "(", "LastMI", ")", ";", "}", "while", "(", "LastMI", "->", "getOpcode", "(", ")", "==", "TMS320C64X", "::", "BUNDLE_END", ")", ";", "assert", "(", "LastMI", "->", "getOpcode", "(", ")", "==", "TMS320C64X", "::", "BR_OCCURS", "&&", "\"scheduler moved pseudo-terminator instruction\"", ")", ";", "}", "Scheduler", "->", "FinishBlock", "(", ")", ";", "Scheduler", "->", "FixupKills", "(", "MBB", ")", ";", "NumCycles", "+=", "BlockCycles", ";", "MFI", "->", "setScheduledCycles", "(", "MBB", ",", "BlockCycles", ")", ";", "}", "delete", "Scheduler", ";", "delete", "HR", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "TMS320C64X", "TMS320C64X", "TMS320C64X", "0", "0", "TMS320C64X::BR_OCCURS", "1", "0", "\"Instruction count mismatch!\"", "0", "\"Instruction count mismatch!\"", "TMS320C64X::BUNDLE_END", "TMS320C64X::BR_OCCURS", "\"scheduler moved pseudo-terminator instruction\"" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation lowering\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "case", "ISD", "::", "BRIND", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented computed gotos\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented __builtin_return_address\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "return", "LowerCopyToReg", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerAccessVectorElement", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerIntrinsic", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerShift", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"unimplemented operation lowering\"", "ISD::FrameIndex", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::JumpTable", "ISD::BR_JT", "ISD::VASTART", "ISD::BlockAddress", "ISD::BRIND", "\"WebAssembly hasn't implemented computed gotos\"", "ISD::RETURNADDR", "\"WebAssembly hasn't implemented __builtin_return_address\"", "ISD::FRAMEADDR", "ISD::CopyToReg", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::SIGN_EXTEND_INREG", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SHL", "ISD::SRA", "ISD::SRL" ]

[]

[ "<s>", "unsigned", "WebAssemblyTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ")", "{", "unsigned", "Cost", "=", "BasicTTIImplBase", "<", "WebAssemblyTTIImpl", ">", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "if", "(", "VectorType", "*", "VTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "Ty", ")", ")", "{", "switch", "(", "Opcode", ")", "{", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "case", "Instruction", "::", "Shl", ":", "if", "(", "Opd2Info", "!=", "TTI", "::", "OK_UniformValue", "&&", "Opd2Info", "!=", "TTI", "::", "OK_UniformConstantValue", ")", "Cost", "=", "VTy", "->", "getNumElements", "(", ")", "*", "(", "TargetTransformInfo", "::", "TCC_Basic", "+", "getArithmeticInstrCost", "(", "Opcode", ",", "VTy", "->", "getElementType", "(", ")", ")", "+", "TargetTransformInfo", "::", "TCC_Basic", ")", ";", "break", ";", "}", "}", "return", "Cost", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

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

[]

[ "<s>", "static", "void", "arm_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "if", "(", "cum", "->", "nregs", "<", "NUM_ARG_REGS", ")", "*", "pretend_size", "=", "(", "NUM_ARG_REGS", "-", "cum", "->", "nregs", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", ".", "On", "the", "ARM", ",", "PRETEND_SIZE", "is", "set", "in", "order", "to", "have", "the", "prologue", "push", "the", "last", "named", "arg", "and", "all", "anonymous", "args", "onto", "the", "stack", ".", "XXX", "I", "know", "the", "prologue", "should", "n't", "be", "pushing", "registers", ",", "but", "it", "is", "faster", "that", "way", "." ]

[ "arm", "1" ]

[]

[ "<s>", "unsigned", "VEInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDrii", "||", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDLSXrii", "||", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDUrii", "||", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDQrii", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::LDrii", "VE::LDLSXrii", "VE::LDUrii", "VE::LDQrii", "1", "2", "2", "0", "3", "3", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "PPCScoreboardHazardRecognizer", "::", "Reset", "(", ")", "{", "ScoreboardHazardRecognizer", "::", "Reset", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "rtx", "rs6000_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "unsigned", "int", "regno", ";", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_struct_check_p", "(", "TYPE_MODE", "(", "valtype", ")", ",", "valtype", ")", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "0", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "valtype", ",", "true", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "valret", ";", "}", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "if", "(", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "valtype", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ")", "{", "int", "first_reg", ",", "n_regs", ";", "if", "(", "SCALAR_FLOAT_MODE_NOT_VECTOR_P", "(", "elt_mode", ")", ")", "{", "first_reg", "=", "(", "elt_mode", "==", "TDmode", ")", "?", "FP_ARG_RETURN", "+", "1", ":", "FP_ARG_RETURN", ";", "n_regs", "=", "(", "GET_MODE_SIZE", "(", "elt_mode", ")", "+", "7", ")", ">>", "3", ";", "}", "else", "{", "first_reg", "=", "ALTIVEC_ARG_RETURN", ";", "n_regs", "=", "1", ";", "}", "return", "rs6000_parallel_return", "(", "mode", ",", "n_elts", ",", "elt_mode", ",", "first_reg", ",", "n_regs", ")", ";", "}", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", ")", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_DImode", ":", "case", "E_SCmode", ":", "case", "E_DCmode", ":", "case", "E_TCmode", ":", "int", "count", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", ";", "return", "rs6000_parallel_return", "(", "mode", ",", "count", ",", "SImode", ",", "GP_ARG_RETURN", ",", "1", ")", ";", "}", "if", "(", "(", "INTEGRAL_TYPE_P", "(", "valtype", ")", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", "<", "(", "TARGET_32BIT", "?", "32", ":", "64", ")", ")", "||", "POINTER_TYPE_P", "(", "valtype", ")", ")", "mode", "=", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", ")", "regno", "=", "(", "mode", "==", "TDmode", ")", "?", "FP_ARG_RETURN", "+", "1", ":", "FP_ARG_RETURN", ";", "else", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "valtype", ")", "&&", "TARGET_HARD_FLOAT", "&&", "!", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "if", "(", "TREE_CODE", "(", "valtype", ")", "==", "COMPLEX_TYPE", "&&", "targetm", ".", "calls", ".", "split_complex_arg", ")", "return", "rs6000_complex_function_value", "(", "mode", ")", ";", "else", "if", "(", "(", "TREE_CODE", "(", "valtype", ")", "==", "VECTOR_TYPE", "||", "VECTOR_ALIGNMENT_P", "(", "mode", ")", ")", "&&", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "mode", ")", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "regno", "=", "GP_ARG_RETURN", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", ".", "On", "the", "SPE", ",", "both", "FPs", "and", "vectors", "are", "returned", "in", "r3", ".", "On", "RS/6000", "an", "integer", "value", "is", "in", "r3", "and", "a", "floating-point", "value", "is", "in", "fp1", ",", "unless", "-msoft-float", "." ]

[ "rs6000", "0", "1", "7", "3", "1", "4", "1", "32", "64", "1" ]

[]

[ "<s>", "bool", "microblaze_expand_block_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "length", ",", "rtx", "align_rtx", ")", "{", "if", "(", "GET_CODE", "(", "length", ")", "==", "CONST_INT", ")", "{", "unsigned", "HOST_WIDE_INT", "bytes", "=", "UINTVAL", "(", "length", ")", ";", "unsigned", "int", "align", "=", "UINTVAL", "(", "align_rtx", ")", ";", "if", "(", "align", ">", "UNITS_PER_WORD", ")", "{", "align", "=", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "align", "<", "UNITS_PER_WORD", ")", "{", "if", "(", "UINTVAL", "(", "length", ")", "<=", "MAX_MOVE_BYTES", ")", "{", "move_by_pieces", "(", "dest", ",", "src", ",", "bytes", ",", "align", ",", "RETURN_BEGIN", ")", ";", "return", "true", ";", "}", "else", "return", "false", ";", "}", "if", "(", "UINTVAL", "(", "length", ")", "<=", "2", "*", "MAX_MOVE_BYTES", ")", "{", "microblaze_block_move_straight", "(", "dest", ",", "src", ",", "UINTVAL", "(", "length", ")", ")", ";", "return", "true", ";", "}", "else", "if", "(", "optimize", ")", "{", "microblaze_block_move_loop", "(", "dest", ",", "src", ",", "UINTVAL", "(", "length", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Expand", "a", "movmemsi", "instruction", "." ]

[ "microblaze", "2" ]

[]

[ "<s>", "static", "bool", "is_load_insn", "(", "rtx", "insn", ",", "rtx", "*", "load_mem", ")", "{", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "return", "false", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "false", ";", "return", "is_load_insn1", "(", "PATTERN", "(", "insn", ")", ",", "load_mem", ")", ";", "}", "</s>" ]

[ "Determine", "if", "INSN", "loads", "from", "memory", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "compute_zdepdi_operands", "(", "unsigned", "HOST_WIDE_INT", "imm", ",", "unsigned", "*", "op", ")", "{", "int", "lsb", ",", "len", ",", "maxlen", ";", "maxlen", "=", "MIN", "(", "HOST_BITS_PER_WIDE_INT", ",", "64", ")", ";", "for", "(", "lsb", "=", "0", ";", "lsb", "<", "maxlen", ";", "lsb", "++", ")", "{", "if", "(", "(", "imm", "&", "1", ")", "!=", "0", ")", "break", ";", "imm", ">>=", "1", ";", "}", "if", "(", "(", "imm", "&", "0x10", ")", "==", "0", ")", "len", "=", "(", "lsb", "<=", "maxlen", "-", "4", ")", "?", "4", ":", "maxlen", "-", "lsb", ";", "else", "{", "for", "(", "len", "=", "5", ";", "len", "<", "maxlen", "-", "lsb", ";", "len", "++", ")", "{", "if", "(", "(", "imm", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "len", ")", ")", "==", "0", ")", "break", ";", "}", "if", "(", "HOST_BITS_PER_WIDE_INT", "==", "32", "&&", "len", "==", "maxlen", "-", "lsb", ")", "len", "+=", "32", ";", "imm", "=", "(", "imm", "&", "0xf", ")", "-", "0x10", ";", "}", "op", "[", "0", "]", "=", "imm", ";", "op", "[", "1", "]", "=", "63", "-", "lsb", ";", "op", "[", "2", "]", "=", "len", ";", "}", "</s>" ]

[ "Compute", "position", "(", "in", "OP", "[", "1", "]", ")", "and", "width", "(", "in", "OP", "[", "2", "]", ")", "useful", "for", "copying", "IMM", "to", "a", "register", "using", "the", "depdi", ",", "z", "instructions", ".", "Store", "the", "immediate", "value", "to", "insert", "in", "OP", "[", "0", "]", "." ]

[ "pa", "64", "0", "1", "0", "1", "0x10", "0", "4", "4", "5", "1", "0", "32", "32", "0xf", "0x10", "0", "1", "63", "2" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Mips", "::", "RetRA", ")", ";", "if", "(", "Val", "!=", "nullptr", "&&", "!", "isSupportedReturnType", "(", "Val", "->", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "RetInfos", ";", "ArgInfo", "ArgRetInfo", "(", "VRegs", ",", "*", "Val", ",", "0", ")", ";", "setArgFlags", "(", "ArgRetInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "ArgRetInfo", ",", "RetInfos", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "8", ">", "Outs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "MipsOutgoingValueHandler", "RetHandler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "Ret", ")", ";", "std", "::", "string", "FuncName", "=", "F", ".", "getName", "(", ")", ".", "str", "(", ")", ";", "MipsOutgoingValueAssigner", "Assigner", "(", "TLI", ".", "CCAssignFnForReturn", "(", ")", ",", "FuncName", ".", "c_str", "(", ")", ",", "true", ")", ";", "if", "(", "!", "determineAssignments", "(", "Assigner", ",", "RetInfos", ",", "CCInfo", ")", ")", "return", "false", ";", "if", "(", "!", "handleAssignments", "(", "RetHandler", ",", "RetInfos", ",", "CCInfo", ",", "ArgLocs", ",", "MIRBuilder", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "Mips", "Mips", "Mips::RetRA", "Mips", "Mips", "8", "0", "16", "ISD::OutputArg", "8", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "const", "LanaiInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", "AArch64FastISel", "::", "getRegForGEPIndex", "(", "const", "Value", "*", "Idx", ")", "{", "unsigned", "IdxN", "=", "getRegForValue", "(", "Idx", ")", ";", "if", "(", "IdxN", "==", "0", ")", "return", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", "(", "0", ",", "false", ")", ";", "bool", "IdxNIsKill", "=", "hasTrivialKill", "(", "Idx", ")", ";", "MVT", "PtrVT", "=", "TLI", ".", "getPointerTy", "(", ")", ";", "EVT", "IdxVT", "=", "EVT", "::", "getEVT", "(", "Idx", "->", "getType", "(", ")", ",", "false", ")", ";", "if", "(", "IdxVT", ".", "bitsLT", "(", "PtrVT", ")", ")", "{", "IdxN", "=", "emitIntExt", "(", "IdxVT", ".", "getSimpleVT", "(", ")", ",", "IdxN", ",", "PtrVT", ",", "false", ")", ";", "IdxNIsKill", "=", "true", ";", "}", "else", "if", "(", "IdxVT", ".", "bitsGT", "(", "PtrVT", ")", ")", "llvm_unreachable", "(", "\"AArch64 FastISel doesn't support types larger than i64\"", ")", ";", "return", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", "(", "IdxN", ",", "IdxNIsKill", ")", ";", "}", "</s>" ]

[ "This", "is", "a", "wrapper", "around", "getRegForValue", "that", "also", "takes", "care", "of", "truncating", "or", "sign-extending", "the", "given", "getelementptr", "index", "value", "." ]

[ "AArch64", "AArch64", "0", "0", "\"AArch64 FastISel doesn't support types larger than i64\"" ]

[]

[ "<s>", "void", "AArch64Operand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_FPImm", ":", "OS", "<<", "\"<fpimm \"", "<<", "getFPImm", "(", ")", "<<", "\"(\"", "<<", "AArch64_AM", "::", "getFPImmFloat", "(", "getFPImm", "(", ")", ")", "<<", "\") >\"", ";", "break", ";", "case", "k_Barrier", ":", "{", "StringRef", "Name", "=", "getBarrierName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<barrier \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<barrier invalid #\"", "<<", "getBarrier", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "k_ShiftedImm", ":", "{", "unsigned", "Shift", "=", "getShiftedImmShift", "(", ")", ";", "OS", "<<", "\"<shiftedimm \"", ";", "OS", "<<", "*", "getShiftedImmVal", "(", ")", ";", "OS", "<<", "\", lsl #\"", "<<", "AArch64_AM", "::", "getShiftValue", "(", "Shift", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_CondCode", ":", "OS", "<<", "\"<condcode \"", "<<", "getCondCode", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_VectorList", ":", "{", "OS", "<<", "\"<vectorlist \"", ";", "unsigned", "Reg", "=", "getVectorListStart", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "getVectorListCount", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "OS", "<<", "Reg", "+", "i", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "}", "case", "k_VectorIndex", ":", "OS", "<<", "\"<vectorindex \"", "<<", "getVectorIndex", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_SysReg", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "k_SysCR", ":", "OS", "<<", "\"c\"", "<<", "getSysCR", "(", ")", ";", "break", ";", "case", "k_Prefetch", ":", "{", "StringRef", "Name", "=", "getPrefetchName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<prfop \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<prfop invalid #\"", "<<", "getPrefetch", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_PSBHint", ":", "{", "OS", "<<", "getPSBHintName", "(", ")", ";", "break", ";", "}", "case", "k_ShiftExtend", ":", "{", "OS", "<<", "\"<\"", "<<", "AArch64_AM", "::", "getShiftExtendName", "(", "getShiftExtendType", "(", ")", ")", "<<", "\" #\"", "<<", "getShiftExtendAmount", "(", ")", ";", "if", "(", "!", "hasShiftExtendAmount", "(", ")", ")", "OS", "<<", "\"<imp>\"", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"<fpimm \"", "\"(\"", "AArch64_AM::getFPImmFloat", "\") >\"", "\"<barrier \"", "\">\"", "\"<barrier invalid #\"", "\">\"", "\"<shiftedimm \"", "\", lsl #\"", "AArch64_AM::getShiftValue", "\">\"", "\"<condcode \"", "\">\"", "\"<register \"", "\">\"", "\"<vectorlist \"", "0", "\" \"", "\">\"", "\"<vectorindex \"", "\">\"", "\"<sysreg: \"", "\"'\"", "\"'\"", "\"c\"", "\"<prfop \"", "\">\"", "\"<prfop invalid #\"", "\">\"", "\"<\"", "AArch64_AM::getShiftExtendName", "\" #\"", "\"<imp>\"" ]

[]

[ "<s>", "static", "bool", "ix86_tieable_integer_mode_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "case", "SImode", ":", "return", "true", ";", "case", "QImode", ":", "return", "TARGET_64BIT", "||", "!", "TARGET_PARTIAL_REG_STALL", ";", "case", "DImode", ":", "return", "TARGET_64BIT", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_modes_tieable_p", ".", "Return", "true", "if", "MODE", "is", "a", "tieable", "integer", "mode", "." ]

[ "i386" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_INIT_M0", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ".", "getIterator", "(", ")", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "AMDGPU", "::", "M0", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "GET_GROUPSTATICSIZE", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "MFI", "->", "LDSSize", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "case", "AMDGPU", "::", "SI_KILL", ":", "return", "splitKillBlock", "(", "MI", ",", "BB", ")", ";", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "}", "return", "BB", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_INIT_M0", "SI", "AMDGPU::S_MOV_B32", "AMDGPU::M0", "0", "AMDGPU::BRANCH", "AMDGPU::GET_GROUPSTATICSIZE", "SI", "SI", "SI", "AMDGPU::S_MOV_B32", "0", "AMDGPU::SI_KILL", "AMDGPU" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "Size", "=", "4", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint32_t", "insn", "=", "llvm", "::", "support", "::", "endian", "::", "read", "<", "uint32_t", ",", "llvm", "::", "support", "::", "little", ",", "llvm", "::", "support", "::", "unaligned", ">", "(", "Bytes", ".", "data", "(", ")", ")", ";", "insn", "&=", "~", "static_cast", "<", "uint32_t", ">", "(", "HexagonII", "::", "InstParseBits", "::", "INST_PARSE_MASK", ")", ";", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "HexagonMCInstrInfo", "::", "AppendImplicitOperands", "(", "MI", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "Hexagon", "Hexagon", "4", "4", "support::endian", "support::little", "support::unaligned", "HexagonII::InstParseBits", "Hexagon" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "leaveMBB", "(", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"** Leaving \"", "<<", "printMBBReference", "(", "*", "MBB", ")", "<<", "\"\\n\"", ";", ")", ";", "advanceTo", "(", "MBB", "->", "getFirstTerminator", "(", ")", ")", ";", "}", "</s>" ]

[ "Tell", "the", "strategy", "that", "current", "MBB", "is", "done", "." ]

[ "SystemZ", "SystemZ", "\"** Leaving \"", "\"\\n\"" ]

[]

[ "<s>", "void", "XtensaFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "false", "&&", "\"XtensaFrameLowering::determineCalleeSaves\"", "\" not implemented\"", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"XtensaFrameLowering::determineCalleeSaves\"", "\" not implemented\"" ]

[]

[ "<s>", "static", "void", "rs6000_set_sched_context", "(", "void", "*", "_sc", ")", "{", "rs6000_sched_context_t", "sc", "=", "(", "rs6000_sched_context_t", ")", "_sc", ";", "gcc_assert", "(", "sc", "!=", "NULL", ")", ";", "cached_can_issue_more", "=", "sc", "->", "cached_can_issue_more", ";", "last_scheduled_insn", "=", "sc", "->", "last_scheduled_insn", ";", "load_store_pendulum", "=", "sc", "->", "load_store_pendulum", ";", "}", "</s>" ]

[ "Sets", "the", "global", "scheduling", "context", "to", "the", "one", "pointed", "to", "by", "_SC", "." ]

[ "rs6000" ]

[]

[ "<s>", "uint64_t", "MipsFrameLowering", "::", "estimateStackSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "int64_t", "Offset", "=", "0", ";", "for", "(", "int", "I", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "I", "!=", "0", ";", "++", "I", ")", "Offset", "=", "std", "::", "max", "(", "Offset", ",", "-", "MFI", "->", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "const", "uint16_t", "*", "R", "=", "TRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "{", "unsigned", "Size", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "*", "R", ")", "->", "getSize", "(", ")", ";", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "Size", ",", "Size", ")", ";", "}", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "assert", "(", "!", "MFI", "->", "getObjectIndexEnd", "(", ")", "||", "MaxAlign", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MFI", "->", "getObjectIndexEnd", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "MFI", "->", "getObjectSize", "(", "I", ")", ",", "MaxAlign", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "&&", "hasReservedCallFrame", "(", "MF", ")", ")", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "MFI", "->", "getMaxCallFrameSize", "(", ")", ",", "std", "::", "max", "(", "MaxAlign", ",", "getStackAlignment", "(", ")", ")", ")", ";", "return", "RoundUpToAlignment", "(", "Offset", ",", "getStackAlignment", "(", ")", ")", ";", "}", "</s>" ]

[ "Estimate", "and", "return", "the", "size", "of", "the", "stack", "frame", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM Native Client Rewrite Pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM Native Client Rewrite Pass\"" ]

[]

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

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

[ "X86", "\"X86 speculative load hardening\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "OptimizeNone", ")", ")", "{", "F", ".", "removeAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeNone", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "TPC" ]

[]

[ "<s>", "static", "rtx", "gen_stack_pointer_inc", "(", "rtx", "increment", ")", "{", "return", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "increment", ")", ")", ";", "}", "</s>" ]

[ "Generate", "an", "increment", "for", "the", "stack", "pointer", "." ]

[ "sparc" ]

[]

[ "<s>", "unsigned", "MipsInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "reverse_iterator", "I", "=", "MBB", ".", "rbegin", "(", ")", ",", "REnd", "=", "MBB", ".", "rend", "(", ")", ";", "unsigned", "removed", "=", "0", ";", "while", "(", "I", "!=", "REnd", "&&", "removed", "<", "2", ")", "{", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "++", "I", ";", "continue", ";", "}", "if", "(", "!", "getAnalyzableBrOpc", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "rbegin", "(", ")", ";", "++", "removed", ";", "}", "return", "removed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"code size not handled\"", "0", "2" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MF", ".", "setAlignment", "(", "8", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "MCContext", "&", "Context", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ";", "MCSectionELF", "*", "ConfigSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.config\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "ConfigSection", ")", ";", "const", "AMDGPUSubtarget", "&", "STM", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "SIProgramInfo", "KernelInfo", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "getSIProgramInfo", "(", "KernelInfo", ",", "MF", ")", ";", "if", "(", "!", "STM", ".", "isAmdHsaOS", "(", ")", ")", "{", "EmitProgramInfoSI", "(", "MF", ",", "KernelInfo", ")", ";", "}", "AMDGPUTargetStreamer", "*", "TS", "=", "static_cast", "<", "AMDGPUTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "TS", "->", "EmitDirectiveHSACodeObjectVersion", "(", "1", ",", "0", ")", ";", "AMDGPU", "::", "IsaVersion", "ISA", "=", "STM", ".", "getIsaVersion", "(", ")", ";", "TS", "->", "EmitDirectiveHSACodeObjectISA", "(", "ISA", ".", "Major", ",", "ISA", ".", "Minor", ",", "ISA", ".", "Stepping", ",", "\"AMD\"", ",", "\"AMDGPU\"", ")", ";", "}", "else", "{", "EmitProgramInfoR600", "(", "MF", ")", ";", "}", "DisasmLines", ".", "clear", "(", ")", ";", "HexLines", ".", "clear", "(", ")", ";", "DisasmLineMaxLen", "=", "0", ";", "EmitFunctionBody", "(", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "MCSectionELF", "*", "CommentSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.csdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "CommentSection", ")", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "OutStreamer", "->", "emitRawComment", "(", "\" Kernel info:\"", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" codeLenInByte = \"", "+", "Twine", "(", "KernelInfo", ".", "CodeLen", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" NumSgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumSGPR", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" NumVgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumVGPR", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" FloatMode: \"", "+", "Twine", "(", "KernelInfo", ".", "FloatMode", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" IeeeMode: \"", "+", "Twine", "(", "KernelInfo", ".", "IEEEMode", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" ScratchSize: \"", "+", "Twine", "(", "KernelInfo", ".", "ScratchSize", ")", ",", "false", ")", ";", "}", "else", "{", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "Twine", "(", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "+", "Twine", "(", "MFI", "->", "StackSize", ")", ")", ")", ";", "}", "}", "if", "(", "STM", ".", "dumpCode", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "Context", ".", "getELFSection", "(", "\".AMDGPU.disasm\"", ",", "ELF", "::", "SHT_NOTE", ",", "0", ")", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "DisasmLines", ".", "size", "(", ")", ";", "++", "i", ")", "{", "std", "::", "string", "Comment", "(", "DisasmLineMaxLen", "-", "DisasmLines", "[", "i", "]", ".", "size", "(", ")", ",", "' '", ")", ";", "Comment", "+=", "\" ; \"", "+", "HexLines", "[", "i", "]", "+", "\"\\n\"", ";", "OutStreamer", "->", "EmitBytes", "(", "StringRef", "(", "DisasmLines", "[", "i", "]", ")", ")", ";", "OutStreamer", "->", "EmitBytes", "(", "StringRef", "(", "Comment", ")", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "8", "\".AMDGPU.config\"", "0", "AMDGPU", "AMDGPU", "SI", "AMDGPU", "SI", "SI", "AMDGPU", "AMDGPU", "1", "0", "AMDGPU::IsaVersion", "\"AMD\"", "\"AMDGPU\"", "R600", "0", "\".AMDGPU.csdata\"", "0", "AMDGPU", "\" Kernel info:\"", "\" codeLenInByte = \"", "\" NumSgprs: \"", "\" NumVgprs: \"", "\" FloatMode: \"", "\" IeeeMode: \"", "\" ScratchSize: \"", "R600", "R600", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "\".AMDGPU.disasm\"", "0", "0", "\" ; \"", "\"\\n\"" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARM", "ARMCC::CondCodes", "4", "ARM::LDRcp", "0" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "bool", "AllowsUnaligned", "=", "Subtarget", "->", "allowsUnalignedMem", "(", ")", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "{", "if", "(", "AllowsUnaligned", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "Subtarget", "->", "hasV7Ops", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v2f64", ":", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "AllowsUnaligned", "||", "Subtarget", "->", "isLittle", "(", ")", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f64", "MVT::v2f64" ]

[]

[ "<s>", "unsigned", "getSetRegWaitStates", "(", ")", "const", "{", "return", "getGeneration", "(", ")", "<=", "SEA_ISLANDS", "?", "1", ":", "2", ";", "}", "</s>" ]

[ "Number", "of", "hazard", "wait", "states", "for", "s_setreg_b32/s_setreg_imm32_b32", "." ]

[ "AMDGPU", "1", "2" ]

[]

[ "<s>", "unsigned", "AArch64AsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "AArch64Operand", "&", "Op", "=", "static_cast", "<", "AArch64Operand", "&", ">", "(", "AsmOp", ")", ";", "int64_t", "ExpectedVal", ";", "switch", "(", "Kind", ")", "{", "default", ":", "return", "Match_InvalidOperand", ";", "case", "MCK__HASH_0", ":", "ExpectedVal", "=", "0", ";", "break", ";", "case", "MCK__HASH_1", ":", "ExpectedVal", "=", "1", ";", "break", ";", "case", "MCK__HASH_12", ":", "ExpectedVal", "=", "12", ";", "break", ";", "case", "MCK__HASH_16", ":", "ExpectedVal", "=", "16", ";", "break", ";", "case", "MCK__HASH_2", ":", "ExpectedVal", "=", "2", ";", "break", ";", "case", "MCK__HASH_24", ":", "ExpectedVal", "=", "24", ";", "break", ";", "case", "MCK__HASH_3", ":", "ExpectedVal", "=", "3", ";", "break", ";", "case", "MCK__HASH_32", ":", "ExpectedVal", "=", "32", ";", "break", ";", "case", "MCK__HASH_4", ":", "ExpectedVal", "=", "4", ";", "break", ";", "case", "MCK__HASH_48", ":", "ExpectedVal", "=", "48", ";", "break", ";", "case", "MCK__HASH_6", ":", "ExpectedVal", "=", "6", ";", "break", ";", "case", "MCK__HASH_64", ":", "ExpectedVal", "=", "64", ";", "break", ";", "case", "MCK__HASH_8", ":", "ExpectedVal", "=", "8", ";", "break", ";", "case", "MCK_MPR", ":", "if", "(", "Op", ".", "isTokenEqual", "(", "\"za\"", ")", ")", "return", "Match_Success", ";", "return", "Match_InvalidOperand", ";", "}", "if", "(", "!", "Op", ".", "isImm", "(", ")", ")", "return", "Match_InvalidOperand", ";", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return", "Match_InvalidOperand", ";", "if", "(", "CE", "->", "getValue", "(", ")", "==", "ExpectedVal", ")", "return", "Match_Success", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "0", "1", "12", "16", "2", "24", "3", "32", "4", "48", "6", "64", "8", "\"za\"" ]

[]

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

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

[ "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL", "HSAIL" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "Register", ";", "}", "</s>" ]

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

[ "CSKY" ]

[]

[ "<s>", "const", "char", "*", "output_set_got", "(", "rtx", "dest", ")", "{", "rtx", "xops", "[", "3", "]", ";", "xops", "[", "0", "]", "=", "dest", ";", "xops", "[", "1", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "GOT_SYMBOL_NAME", ")", ";", "if", "(", "!", "TARGET_DEEP_BRANCH_PREDICTION", "||", "!", "flag_pic", ")", "{", "xops", "[", "2", "]", "=", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "gen_label_rtx", "(", ")", ")", ";", "if", "(", "!", "flag_pic", ")", "output_asm_insn", "(", "\"mov{l}\\t{%2, %0|%0, %2}\"", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "\"call\\t%a2\"", ",", "xops", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "machopic_function_base_name", "(", ")", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "xops", "[", "2", "]", ",", "0", ")", ")", ")", ";", "if", "(", "flag_pic", ")", "output_asm_insn", "(", "\"pop{l}\\t%0\"", ",", "xops", ")", ";", "}", "else", "{", "char", "name", "[", "32", "]", ";", "get_pc_thunk_name", "(", "name", ",", "REGNO", "(", "dest", ")", ")", ";", "pic_labels_used", "|=", "1", "<<", "REGNO", "(", "dest", ")", ";", "xops", "[", "2", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "name", ")", ")", ";", "xops", "[", "2", "]", "=", "gen_rtx_MEM", "(", "QImode", ",", "xops", "[", "2", "]", ")", ";", "output_asm_insn", "(", "\"call\\t%X2\"", ",", "xops", ")", ";", "}", "if", "(", "!", "flag_pic", "||", "TARGET_DEEP_BRANCH_PREDICTION", ")", "output_asm_insn", "(", "\"add{l}\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "else", "if", "(", "!", "TARGET_MACHO", ")", "output_asm_insn", "(", "\"add{l}\\t{%1+[.-%a2], %0|%0, %1+(.-%a2)}\"", ",", "xops", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Emit", "code", "for", "the", "SET_GOT", "patterns", "." ]

[ "i386", "3", "0", "1", "2", "\"mov{l}\\t{%2, %0|%0, %2}\"", "\"call\\t%a2\"", "\"L\"", "2", "0", "\"pop{l}\\t%0\"", "32", "1", "2", "2", "2", "\"call\\t%X2\"", "\"add{l}\\t{%1, %0|%0, %1}\"", "\"add{l}\\t{%1+[.-%a2], %0|%0, %1+(.-%a2)}\"", "\"\"" ]

[]

[ "<s>", "MachineInstrBuilder", "MipsInstrInfo", "::", "genInstrWithNewOpc", "(", "unsigned", "NewOpc", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstrBuilder", "MIB", ";", "int", "ZeroOperandPosition", "=", "-", "1", ";", "bool", "BranchWithZeroOperand", "=", "false", ";", "if", "(", "I", "->", "isBranch", "(", ")", "&&", "!", "I", "->", "isPseudo", "(", ")", ")", "{", "auto", "TRI", "=", "I", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "ZeroOperandPosition", "=", "I", "->", "findRegisterUseOperandIdx", "(", "Mips", "::", "ZERO", ",", "false", ",", "TRI", ")", ";", "BranchWithZeroOperand", "=", "ZeroOperandPosition", "!=", "-", "1", ";", "}", "if", "(", "BranchWithZeroOperand", ")", "{", "switch", "(", "NewOpc", ")", "{", "case", "Mips", "::", "BEQC", ":", "NewOpc", "=", "Mips", "::", "BEQZC", ";", "break", ";", "case", "Mips", "::", "BNEC", ":", "NewOpc", "=", "Mips", "::", "BNEZC", ";", "break", ";", "case", "Mips", "::", "BGEC", ":", "NewOpc", "=", "Mips", "::", "BGEZC", ";", "break", ";", "case", "Mips", "::", "BLTC", ":", "NewOpc", "=", "Mips", "::", "BLTZC", ";", "break", ";", "case", "Mips", "::", "BEQC64", ":", "NewOpc", "=", "Mips", "::", "BEQZC64", ";", "break", ";", "case", "Mips", "::", "BNEC64", ":", "NewOpc", "=", "Mips", "::", "BNEZC64", ";", "break", ";", "}", "}", "MIB", "=", "BuildMI", "(", "*", "I", "->", "getParent", "(", ")", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "NewOpc", ")", ")", ";", "if", "(", "NewOpc", "==", "Mips", "::", "JIC", "||", "NewOpc", "==", "Mips", "::", "JIALC", "||", "NewOpc", "==", "Mips", "::", "JIC64", "||", "NewOpc", "==", "Mips", "::", "JIALC64", ")", "{", "if", "(", "NewOpc", "==", "Mips", "::", "JIALC", "||", "NewOpc", "==", "Mips", "::", "JIALC64", ")", "MIB", "->", "removeOperand", "(", "0", ")", ";", "for", "(", "unsigned", "J", "=", "0", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "MIB", ".", "add", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "MIB", ".", "addImm", "(", "0", ")", ";", "for", "(", "unsigned", "J", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ",", "E", "=", "I", "->", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "const", "MachineOperand", "&", "MO", "=", "I", "->", "getOperand", "(", "J", ")", ";", "if", "(", "MO", ".", "isMCSymbol", "(", ")", "&&", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "MipsII", "::", "MO_JALR", ")", ")", "MIB", ".", "addSym", "(", "MO", ".", "getMCSymbol", "(", ")", ",", "MipsII", "::", "MO_JALR", ")", ";", "}", "}", "else", "{", "for", "(", "unsigned", "J", "=", "0", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "if", "(", "BranchWithZeroOperand", "&&", "(", "unsigned", ")", "ZeroOperandPosition", "==", "J", ")", "continue", ";", "MIB", ".", "add", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "}", "MIB", ".", "copyImplicitOps", "(", "*", "I", ")", ";", "MIB", ".", "cloneMemRefs", "(", "*", "I", ")", ";", "return", "MIB", ";", "}", "</s>" ]

[ "Create", "an", "instruction", "which", "has", "the", "same", "operands", "and", "memory", "operands", "as", "MI", "but", "has", "a", "new", "opcode", "." ]

[ "Mips", "Mips", "1", "Mips::ZERO", "1", "Mips::BEQC", "Mips::BEQZC", "Mips::BNEC", "Mips::BNEZC", "Mips::BGEC", "Mips::BGEZC", "Mips::BLTC", "Mips::BLTZC", "Mips::BEQC64", "Mips::BEQZC64", "Mips::BNEC64", "Mips::BNEZC64", "Mips::JIC", "Mips::JIALC", "Mips::JIC64", "Mips::JIALC64", "Mips::JIALC", "Mips::JIALC64", "0", "0", "0", "MipsII::MO_JALR", "MipsII::MO_JALR", "0" ]

[]

[ "<s>", "void", "addLOHDirective", "(", "MCLOHType", "Kind", ",", "const", "MILOHArgs", "&", "Args", ")", "{", "LOHContainerSet", ".", "push_back", "(", "MILOHDirective", "(", "Kind", ",", "Args", ")", ")", ";", "LOHRelated", ".", "insert", "(", "Args", ".", "begin", "(", ")", ",", "Args", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "LOH", "directive", "of", "this", "Kind", "and", "this", "Args", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SISubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "SeenFI", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isFI", "(", ")", ")", "{", "if", "(", "SeenFI", ")", "llvm_unreachable", "(", "\"should not see multiple frame indices\"", ")", ";", "SeenFI", "=", "true", ";", "}", "}", "MachineOperand", "*", "FIOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "assert", "(", "FIOp", "&&", "FIOp", "->", "isFI", "(", ")", "&&", "\"frame index must be address operand\"", ")", ";", "assert", "(", "TII", "->", "isMUBUF", "(", "MI", ")", ")", ";", "MachineOperand", "*", "OffsetOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "int64_t", "NewOffset", "=", "OffsetOp", "->", "getImm", "(", ")", "+", "Offset", ";", "if", "(", "isUInt", "<", "12", ">", "(", "NewOffset", ")", ")", "{", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "NewReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "assert", "(", "Offset", "!=", "0", "&&", "\"Non-zero offset expected\"", ")", ";", "unsigned", "UnusedCarry", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_ADD_I32_e64", ")", ",", "NewReg", ")", ".", "addReg", "(", "UnusedCarry", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "BaseReg", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "NewReg", ",", "false", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "\"should not see multiple frame indices\"", "AMDGPU::OpName", "\"frame index must be address operand\"", "AMDGPU::OpName", "12", "AMDGPU::VGPR_32RegClass", "0", "\"Non-zero offset expected\"", "AMDGPU::SReg_64RegClass", "AMDGPU::V_ADD_I32_e64" ]

[]

[ "<s>", "bool", "AMDGPUAAResult", "::", "pointsToConstantMemory", "(", "const", "MemoryLocation", "&", "Loc", ",", "bool", "OrLocal", ")", "{", "const", "Value", "*", "Base", "=", "GetUnderlyingObject", "(", "Loc", ".", "Ptr", ",", "DL", ")", ";", "if", "(", "Base", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", "==", "AS", ".", "CONSTANT_ADDRESS", ")", "{", "return", "true", ";", "}", "if", "(", "const", "GlobalVariable", "*", "GV", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "Base", ")", ")", "{", "if", "(", "GV", "->", "isConstant", "(", ")", ")", "return", "true", ";", "}", "else", "if", "(", "const", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "Base", ")", ")", "{", "const", "Function", "*", "F", "=", "Arg", "->", "getParent", "(", ")", ";", "switch", "(", "F", "->", "getCallingConv", "(", ")", ")", "{", "default", ":", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "OrLocal", ")", ";", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "break", ";", "}", "unsigned", "ArgNo", "=", "Arg", "->", "getArgNo", "(", ")", ";", "if", "(", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "ArgNo", "+", "1", ",", "Attribute", "::", "NoAlias", ")", "&&", "(", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "ArgNo", "+", "1", ",", "Attribute", "::", "ReadNone", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "ArgNo", "+", "1", ",", "Attribute", "::", "ReadOnly", ")", ")", ")", "{", "return", "true", ";", "}", "}", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "OrLocal", ")", ";", "}", "</s>" ]

[ "A", "convenience", "wrapper", "around", "the", "primary", "pointsToConstantMemory", "interface", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "1", "1", "1" ]

[]

[ "<s>", "unsigned", "MBlazeRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "FrameIndexValue", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "oi", "=", "i", "==", "2", "?", "1", ":", "2", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "int", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "int", "Offset", "=", "(", "spOffset", "<", "0", ")", "?", "(", "stackSize", "-", "spOffset", ")", ":", "(", "spOffset", "+", "4", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "oi", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "MI", ".", "getOperand", "(", "oi", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "0", "\"Instr doesn't have FrameIndex operand!\"", "2", "1", "2", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "0", "4", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"DXIL Metadata Emit\"", ";", "}", "</s>" ]

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

[ "DirectX", "\"DXIL Metadata Emit\"" ]

[]

[ "<s>", "static", "rtx", "neon_vdup_constant", "(", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "x", ";", "if", "(", "GET_CODE", "(", "vals", ")", "!=", "CONST_VECTOR", "||", "GET_MODE_SIZE", "(", "inner_mode", ")", ">", "4", ")", "return", "NULL_RTX", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "vals", ",", "&", "x", ")", ")", "return", "NULL_RTX", ";", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "x", ")", ";", "return", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "Return", "a", "non-NULL", "RTX", "iff", "VALS", "is", "a", "vector", "constant", "that", "can", "be", "loaded", "into", "a", "register", "using", "VDUP", ".", "If", "this", "is", "the", "case", ",", "and", "GENERATE", "is", "set", ",", "we", "also", "generate", "instructions", "to", "do", "this", "and", "return", "an", "RTX", "to", "assign", "to", "the", "register", "." ]

[ "arm", "4" ]

[]

[ "<s>", "bool", "isLiveIn", "(", "int", "FI", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "LiveInFI", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "if", "(", "FI", "==", "LiveInFI", "[", "i", "]", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "VPValue", "is", "a", "live-in", ",", "i.e", ".", "defined", "outside", "the", "VPlan", "." ]

[ "MBlaze", "0" ]

[]

[ "<s>", "bool", "spu_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "if", "(", "ea_symbol_ref_p", "(", "*", "iter", ")", ")", "return", "0", ";", "if", "(", "!", "flag_pic", "&&", "mode", "==", "V4SImode", "&&", "(", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "x", ",", "0", ")", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "x", ",", "0", ")", ")", "==", "CONST", ")", ")", "return", "const_vec_duplicate_p", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", "&&", "!", "const_vector_immediate_p", "(", "x", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "We", "accept", ":", "-", "any", "32-bit", "constant", "(", "SImode", ",", "SFmode", ")", "-", "any", "constant", "that", "can", "be", "generated", "with", "fsmbi", "(", "any", "mode", ")", "-", "a", "64-bit", "constant", "where", "the", "high", "and", "low", "bits", "are", "identical", "(", "DImode", ",", "DFmode", ")", "-", "a", "128-bit", "constant", "where", "the", "four", "32-bit", "words", "match", "." ]

[ "spu", "0", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "spu_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "GET_MODE_BITSIZE", "(", "mode1", ")", "<=", "MAX_FIXED_MODE_SIZE", "&&", "GET_MODE_BITSIZE", "(", "mode2", ")", "<=", "MAX_FIXED_MODE_SIZE", ")", ";", "}", "</s>" ]

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

[ "spu" ]

[]

[ "<s>", "static", "const", "char", "*", "xtensa_invalid_within_doloop", "(", "const", "rtx_insn", "*", "insn", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "\"Function call in the loop.\"", ";", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_return", ")", "return", "\"Return from a call instruction in the loop.\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "NULL", "if", "INSN", "insn", "is", "valid", "within", "a", "low-overhead", "loop", ".", "Otherwise", "return", "why", "doloop", "can", "not", "be", "applied", "." ]

[ "xtensa", "\"Function call in the loop.\"", "\"Return from a call instruction in the loop.\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "MF", ".", "size", "(", ")", "<", "2", ")", "return", "Changed", ";", "for", "(", "MachineBasicBlock", "&", "B", ":", "llvm", "::", "make_early_inc_range", "(", "MF", ")", ")", "Changed", "|=", "processBlock", "(", "B", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "2" ]

[]

[ "<s>", "bool", "GBZ80TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCFunction", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "GBZ80", "GB", "ISD::OutputArg", "16" ]

[]

[ "<s>", "struct", "rtx_def", "*", "m88k_builtin_saveregs", "(", ")", "{", "rtx", "addr", ";", "tree", "fntype", "=", "TREE_TYPE", "(", "current_function_decl", ")", ";", "int", "argadj", "=", "(", "(", "!", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", "!=", "0", "&&", "(", "TREE_VALUE", "(", "tree_last", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ")", "!=", "void_type_node", ")", ")", ")", "?", "-", "UNITS_PER_WORD", ":", "0", ")", "+", "UNITS_PER_WORD", "-", "1", ";", "int", "fixed", ";", "variable_args_p", "=", "1", ";", "fixed", "=", "0", ";", "if", "(", "GET_CODE", "(", "current_function_arg_offset_rtx", ")", "==", "CONST_INT", ")", "fixed", "=", "(", "(", "INTVAL", "(", "current_function_arg_offset_rtx", ")", "+", "argadj", ")", "/", "UNITS_PER_WORD", ")", ";", "addr", "=", "assign_stack_local", "(", "BLKmode", ",", "8", "*", "UNITS_PER_WORD", ",", "-", "1", ")", ";", "set_mem_alias_set", "(", "addr", ",", "get_varargs_alias_set", "(", ")", ")", ";", "RTX_UNCHANGING_P", "(", "addr", ")", "=", "1", ";", "RTX_UNCHANGING_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "=", "1", ";", "if", "(", "fixed", "<", "8", ")", "move_block_from_reg", "(", "2", "+", "fixed", ",", "adjust_address", "(", "addr", ",", "Pmode", ",", "fixed", "*", "UNITS_PER_WORD", ")", ",", "8", "-", "fixed", ",", "UNITS_PER_WORD", "*", "(", "8", "-", "fixed", ")", ")", ";", "return", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "</s>" ]

[ "Do", "what", "is", "necessary", "for", "`", "va_start", "'", ".", "We", "look", "at", "the", "current", "function", "to", "determine", "if", "stdargs", "or", "varargs", "is", "used", "and", "spill", "as", "necessary", ".", "We", "return", "a", "pointer", "to", "the", "spill", "area", "." ]

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

[]

[ "<s>", "void", "Nios2AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "I", "->", "isPseudo", "(", ")", ")", "{", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "}", "MCInst", "TmpInst0", ";", "LowerNios2MachineInstToMCInst", "(", "&", "*", "I", ",", "TmpInst0", ",", "*", "this", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "\"Pseudo opcode found in EmitInstruction()\"", "Nios2" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isPostIncrement", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "return", "(", "getAddrMode", "(", "MI", ")", "==", "HexagonII", "::", "PostInc", ")", ";", "}", "</s>" ]

[ "Return", "true", "for", "post-incremented", "instructions", "." ]

[ "Hexagon", "Hexagon", "HexagonII::PostInc" ]

[]

[ "<s>", "static", "rtx", "loongarch_got_load_tls_ld", "(", "rtx", "dest", ",", "rtx", "sym", ")", "{", "return", "gen_got_load_tls_ld", "(", "Pmode", ",", "dest", ",", "sym", ")", ";", "}", "</s>" ]

[ "Load", "an", "entry", "from", "the", "GOT", "for", "a", "TLS", "LD", "access", "." ]

[ "loongarch" ]

[]

[ "<s>", "const", "X86InstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "rvexFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

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

[ "rvex", "rvex" ]

[]

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

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

[ "c6x", "0" ]

[]

[ "<s>", "unsigned", "XtensaMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "assert", "(", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", ";", "llvm", "::", "errs", "(", ")", "<<", "\"Crap\\n\"", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"Crap\\n\"", "0" ]

[]

[ "<s>", "virtual", "bool", "check", "(", "MachineBasicBlock", "&", "BB", ",", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "MI", ".", "getNumOperands", "(", ")", ">=", "1", "&&", "MI", ".", "getOpcode", "(", ")", "==", "Opc1", ";", "}", "</s>" ]

[ "Check", "if", "the", "constraints", "are", "satisfiable", "." ]

[ "X86", "1" ]

[]

[ "<s>", "void", "EmitRaw", "(", "const", "SmallVectorImpl", "<", "uint8_t", ">", "&", "Opcodes", ")", "{", "Ops", ".", "insert", "(", "Ops", ".", "end", "(", ")", ",", "Opcodes", ".", "begin", "(", ")", ",", "Opcodes", ".", "end", "(", ")", ")", ";", "OpBegins", ".", "push_back", "(", "OpBegins", ".", "back", "(", ")", "+", "Opcodes", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "unwind", "raw", "opcodes", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "Cpu0MCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "const", "char", "*", "get_some_local_dynamic_name", "(", "void", ")", "{", "rtx", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "some_ld_name", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "for_each_rtx", "(", "&", "PATTERN", "(", "insn", ")", ",", "get_some_local_dynamic_name_1", ",", "0", ")", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Locate", "some", "local-dynamic", "symbol", "still", "in", "use", "by", "this", "function", "so", "that", "we", "can", "print", "its", "name", "in", "local-dynamic", "base", "patterns", "." ]

[ "s390", "0" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "TS", ".", "forbidModuleDirective", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch", ")", "{", "emitPseudoIndirectBranch", "(", "OutStreamer", ",", "&", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "isLongBranchPseudo", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "I", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "128", "Mips::PseudoReturn", "Mips::PseudoIndirectBranch", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "BitVector", "CAHPRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CAHP", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CAHP", "::", "X1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CAHP", "::", "X2", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", "||", "HTM", ".", "Options", ".", "DisableTailCalls", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64allRegClassID", "AArch64::tcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRRegBankID", "\"Register class not supported\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "ARC", "ARC" ]

[]

[ "<s>", "static", "int", "mips_symbol_insns", "(", "enum", "mips_symbol_type", "type", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "!=", "MAX_MACHINE_MODE", "&&", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "0", ";", "return", "mips_symbol_insns_1", "(", "type", ",", "mode", ")", "*", "(", "TARGET_MIPS16", "?", "2", ":", "1", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "a", "symbol", "of", "the", "given", "type", "into", "a", "register", ".", "If", "valid", "in", "an", "address", ",", "the", "same", "number", "of", "instructions", "are", "needed", "for", "loads", "and", "stores", ".", "Treat", "extended", "mips16", "instructions", "as", "two", "instructions", "." ]

[ "mips", "0", "2", "1" ]

[]

[ "<s>", "static", "unsigned", "int", "num_occurences_in_str", "(", "char", "c", ",", "char", "*", "str", ")", "{", "unsigned", "int", "res", "=", "0", ";", "while", "(", "*", "str", "!=", "'\\0'", ")", "{", "if", "(", "*", "str", "==", "c", ")", "res", "++", ";", "str", "++", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Count", "how", "many", "times", "the", "character", "C", "appears", "in", "NULL-terminated", "string", "STR", "." ]

[ "aarch64", "0" ]

[]