Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "ARM" ]

[]

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

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

[ "ARM64", "ARM64", "MVT::i32" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "assert", "(", "!", "Val", "==", "!", "VReg", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "ARM", "::", "BX_RET", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "if", "(", "!", "lowerReturnVal", "(", "MIRBuilder", ",", "Val", ",", "VReg", ",", "Ret", ")", ")", "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", "." ]

[ "ARM", "ARM", "\"Return value without a vreg\"", "ARM::BX_RET", "ARMCC::AL" ]

[]

[ "<s>", "static", "inline", "bool", "is_virtual_register", "(", "rtx", "r", ")", "{", "return", "(", "GET_CODE", "(", "r", ")", "==", "REG", "&&", "REGNO", "(", "r", ")", ">=", "8", "&&", "REGNO", "(", "r", ")", "<", "32", ")", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "R", "is", "a", "virtual", "register", "." ]

[ "rl78", "8", "32" ]

[]

[ "<s>", "bool", "TLCS900TargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "return", "(", "VT1", ".", "getSizeInBits", "(", ")", ">", "VT2", ".", "getSizeInBits", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "TLCS900", "TLCS900" ]

[]

[ "<s>", "rtx", "mn10300_function_value", "(", "tree", "valtype", ",", "tree", "func", ",", "int", "outgoing", ")", "{", "rtx", "rv", ";", "enum", "machine_mode", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "if", "(", "!", "POINTER_TYPE_P", "(", "valtype", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_DATA_REGNUM", ")", ";", "else", "if", "(", "!", "TARGET_PTR_A0D0", "||", "!", "outgoing", "||", "current_function_returns_struct", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_ADDRESS_REGNUM", ")", ";", "rv", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "FIRST_ADDRESS_REGNUM", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "1", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "FIRST_DATA_REGNUM", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "return", "rv", ";", "}", "</s>" ]

[ "Return", "the", "location", "of", "the", "function", "'s", "value", ".", "This", "will", "be", "either", "$", "d0", "for", "integer", "functions", ",", "$", "a0", "for", "pointers", ",", "or", "a", "PARALLEL", "of", "both", "$", "d0", "and", "$", "a0", "if", "the", "-mreturn-pointer-on-do", "flag", "is", "set", ".", "Note", "that", "we", "only", "return", "the", "PARALLEL", "for", "outgoing", "values", ";", "we", "do", "not", "want", "callers", "relying", "on", "this", "extra", "copy", "." ]

[ "mn10300", "2", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "allowsMisalignedMemoryAccesses", "(", "LLT", "Ty", ",", "unsigned", "AddrSpace", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", "=", "MachineMemOperand", "::", "MONone", ",", "bool", "*", "IsFast", "=", "nullptr", ")", "const", "override", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "return", "allowsMisalignedMemoryAccessesImpl", "(", "Ty", ".", "getSizeInBits", "(", ")", ",", "AddrSpace", ",", "Alignment", ",", "Flags", ",", "IsFast", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "XOR32rr", ")", ")", ";", "case", "X86", "::", "SETB_C8r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB8rr", ")", ")", ";", "case", "X86", "::", "SETB_C16r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB16rr", ")", ")", ";", "case", "X86", "::", "SETB_C32r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB32rr", ")", ")", ";", "case", "X86", "::", "SETB_C64r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB64rr", ")", ")", ";", "case", "X86", "::", "V_SET0", ":", "case", "X86", "::", "FsFLD0SS", ":", "case", "X86", "::", "FsFLD0SD", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "AVX_SET0", ":", "assert", "(", "HasAVX", "&&", "\"AVX not supported\"", ")", ";", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VXORPSYrr", ")", ")", ";", "case", "X86", "::", "AVX512_512_SET0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPXORDZrr", ")", ")", ";", "case", "X86", "::", "V_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VPCMPEQDrr", ":", "X86", "::", "PCMPEQDrr", ")", ")", ";", "case", "X86", "::", "AVX2_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "case", "X86", "::", "KSET0B", ":", "case", "X86", "::", "KSET0W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXORWrr", ")", ")", ";", "case", "X86", "::", "KSET0D", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXORDrr", ")", ")", ";", "case", "X86", "::", "KSET0Q", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXORQrr", ")", ")", ";", "case", "X86", "::", "KSET1B", ":", "case", "X86", "::", "KSET1W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXNORWrr", ")", ")", ";", "case", "X86", "::", "KSET1D", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXNORDrr", ")", ")", ";", "case", "X86", "::", "KSET1Q", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXNORQrr", ")", ")", ";", "case", "TargetOpcode", "::", "LOAD_STACK_GUARD", ":", "expandLoadStackGuard", "(", "MIB", ",", "*", "this", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::MOV32r0", "X86::XOR32rr", "X86::SETB_C8r", "X86::SBB8rr", "X86::SETB_C16r", "X86::SBB16rr", "X86::SETB_C32r", "X86::SBB32rr", "X86::SETB_C64r", "X86::SBB64rr", "X86::V_SET0", "X86::FsFLD0SS", "X86::FsFLD0SD", "X86::VXORPSrr", "X86::XORPSrr", "X86::AVX_SET0", "\"AVX not supported\"", "X86::VXORPSYrr", "X86::AVX512_512_SET0", "X86::VPXORDZrr", "X86::V_SETALLONES", "X86::VPCMPEQDrr", "X86::PCMPEQDrr", "X86::AVX2_SETALLONES", "X86::VPCMPEQDYrr", "X86::TEST8ri_NOREX", "X86::TEST8ri", "X86::KSET0B", "X86::KSET0W", "X86::KXORWrr", "X86::KSET0D", "X86::KXORDrr", "X86::KSET0Q", "X86::KXORQrr", "X86::KSET1B", "X86::KSET1W", "X86::KXNORWrr", "X86::KSET1D", "X86::KXNORDrr", "X86::KSET1Q", "X86::KXNORQrr" ]

[]

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

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

[ "Dcpu16" ]

[]

[ "<s>", "void", "VLIWMachineScheduler", "::", "schedule", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Converging Scheduling VLIW BB#\"", "<<", "BB", "->", "getNumber", "(", ")", "<<", "\" \"", "<<", "BB", "->", "getName", "(", ")", "<<", "\" in_func \"", "<<", "BB", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\" at loop depth \"", "<<", "MLI", "->", "getLoopDepth", "(", "BB", ")", "<<", "\" \\n\"", ")", ";", "buildDAGWithRegPressure", "(", ")", ";", "SmallVector", "<", "SUnit", "*", ",", "8", ">", "TopRoots", ",", "BotRoots", ";", "findRootsAndBiasEdges", "(", "TopRoots", ",", "BotRoots", ")", ";", "SchedImpl", "->", "initialize", "(", "this", ")", ";", "DEBUG", "(", "unsigned", "maxH", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ">", "maxH", ")", "maxH", "=", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Height \"", "<<", "maxH", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "unsigned", "maxD", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ">", "maxD", ")", "maxD", "=", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Depth \"", "<<", "maxD", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "initQueues", "(", "TopRoots", ",", "BotRoots", ")", ";", "bool", "IsTopNode", "=", "false", ";", "while", "(", "true", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"** VLIWMachineScheduler::schedule picking next node\\n\"", ")", ";", "SUnit", "*", "SU", "=", "SchedImpl", "->", "pickNode", "(", "IsTopNode", ")", ";", "if", "(", "!", "SU", ")", "break", ";", "if", "(", "!", "checkSchedLimit", "(", ")", ")", "break", ";", "scheduleMI", "(", "SU", ",", "IsTopNode", ")", ";", "updateQueues", "(", "SU", ",", "IsTopNode", ")", ";", "SchedImpl", "->", "schedNode", "(", "SU", ",", "IsTopNode", ")", ";", "}", "assert", "(", "CurrentTop", "==", "CurrentBottom", "&&", "\"Nonempty unscheduled zone.\"", ")", ";", "placeDebugValues", "(", ")", ";", "DEBUG", "(", "{", "unsigned", "BBNum", "=", "begin", "(", ")", "->", "getParent", "(", ")", "->", "getNumber", "(", ")", ";", "dbgs", "(", ")", "<<", "\"*** Final schedule for BB#\"", "<<", "BBNum", "<<", "\" ***\\n\"", ";", "dumpSchedule", "(", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "Hexagon", "\"********** MI Converging Scheduling VLIW BB#\"", "\" \"", "\" in_func \"", "\" at loop depth \"", "\" \\n\"", "8", "0", "0", "\"Max Height \"", "\"\\n\"", "0", "0", "\"Max Depth \"", "\"\\n\"", "0", "\"** VLIWMachineScheduler::schedule picking next node\\n\"", "\"Nonempty unscheduled zone.\"", "\"*** Final schedule for BB#\"", "\" ***\\n\"" ]

[]

[ "<s>", "bool", "isExtractVecEltCheap", "(", "EVT", "VT", ",", "unsigned", "Index", ")", "const", "override", "{", "EVT", "EltVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "return", "(", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "&&", "Index", "==", "0", ";", "}", "</s>" ]

[ "Extract", "of", "a", "scalar", "FP", "value", "from", "index", "0", "of", "a", "vector", "is", "free", "." ]

[ "X86", "MVT::f32", "MVT::f64", "0" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "RISCVInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "DebugLoc", "DL", ";", "determineFrameLayout", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "std", "::", "advance", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "Entry", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "FPReg", ",", "SPReg", ",", "StackSize", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "FPReg", ",", "true", ")", ",", "0", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Shrink-wrapping not yet supported\"", "RISCV", "RISCV", "RISCV", "0", "0" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "case", "PPC", "::", "SPILL_CR", ":", "case", "PPC", "::", "SPILL_CRBIT", ":", "case", "PPC", "::", "STVX", ":", "case", "PPC", "::", "STXVD2X", ":", "case", "PPC", "::", "STXVX", ":", "case", "PPC", "::", "QVSTFDX", ":", "case", "PPC", "::", "QVSTFSXs", ":", "case", "PPC", "::", "QVSTFDXb", ":", "case", "PPC", "::", "SPILL_VRSAVE", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "PowerPC", "PPC", "PPC::STD", "PPC::STW", "PPC::STFS", "PPC::STFD", "PPC::SPILL_CR", "PPC::SPILL_CRBIT", "PPC::STVX", "PPC::STXVD2X", "PPC::STXVX", "PPC::QVSTFDX", "PPC::QVSTFSXs", "PPC::QVSTFDXb", "PPC::SPILL_VRSAVE", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "bool", "enableMachineScheduler", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "X86" ]

[]

[ "<s>", "void", "MCS51MCCodeEmitter", "::", "emitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "size_t", "WordCount", "=", "Size", "/", "2", ";", "for", "(", "int64_t", "i", "=", "WordCount", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "uint16_t", "Word", "=", "(", "Val", ">>", "(", "i", "*", "16", ")", ")", "&", "0xFFFF", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "Word", ",", "support", "::", "endianness", "::", "little", ")", ";", "}", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "MCS51", "MCS51", "2", "1", "0", "16", "0xFFFF", "support::endian", "support::endianness" ]

[]

[ "<s>", "inline", "tree", "function_instance", "::", "memory_scalar_type", "(", ")", "const", "{", "return", "base", "->", "memory_scalar_type", "(", "*", "this", ")", ";", "}", "</s>" ]

[ "If", "the", "function", "addresses", "memory", ",", "return", "the", "type", "of", "a", "single", "scalar", "memory", "element", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "getCost", "(", ")", "{", "return", "SUnits", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "inline", "cost", "estimate", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "notice_update_cc", "(", "rtx", "exp", ")", "{", "if", "(", "GET_CODE", "(", "exp", ")", "==", "SET", ")", "{", "if", "(", "SET_DEST", "(", "exp", ")", "==", "pc_rtx", ")", "return", ";", "if", "(", "REG_P", "(", "SET_DEST", "(", "exp", ")", ")", "&&", "(", "REG_P", "(", "SET_SRC", "(", "exp", ")", ")", "||", "GET_CODE", "(", "SET_SRC", "(", "exp", ")", ")", "==", "MEM", ")", ")", "{", "return", ";", "}", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "exp", ")", ")", "==", "MEM", "&&", "REG_P", "(", "SET_SRC", "(", "exp", ")", ")", ")", "{", "return", ";", "}", "}", "CC_STATUS_INIT", ";", "return", ";", "}", "</s>" ]

[ "On", "the", "68000", ",", "all", "the", "insns", "to", "store", "in", "an", "address", "register", "fail", "to", "set", "the", "cc", "'s", ".", "However", ",", "in", "some", "cases", "these", "instructions", "can", "make", "it", "possibly", "invalid", "to", "use", "the", "saved", "cc", "'s", ".", "In", "those", "cases", "we", "clear", "out", "some", "or", "all", "of", "the", "saved", "cc", "'s", "so", "they", "wo", "n't", "be", "used", "." ]

[ "cr16" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isLegalRegOperand", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MCOperandInfo", "&", "OpInfo", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "false", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "Register", "::", "isVirtualRegister", "(", "Reg", ")", "?", "MRI", ".", "getRegClass", "(", "Reg", ")", ":", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "DRC", "=", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ";", "if", "(", "MO", ".", "getSubReg", "(", ")", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MO", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterClass", "*", "SuperRC", "=", "RI", ".", "getLargestLegalSuperClass", "(", "RC", ",", "*", "MF", ")", ";", "if", "(", "!", "SuperRC", ")", "return", "false", ";", "DRC", "=", "RI", ".", "getMatchingSuperRegClass", "(", "SuperRC", ",", "DRC", ",", "MO", ".", "getSubReg", "(", ")", ")", ";", "if", "(", "!", "DRC", ")", "return", "false", ";", "}", "return", "RC", "->", "hasSuperClassEq", "(", "DRC", ")", ";", "}", "</s>" ]

[ "Check", "if", "MO", "(", "a", "register", "operand", ")", "is", "a", "legal", "register", "for", "the", "given", "operand", "description", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "int", "moxie_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "ret", ";", "if", "(", "(", "from", ")", "==", "FRAME_POINTER_REGNUM", "&&", "(", "to", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "moxie_compute_frame", "(", ")", ";", "ret", "=", "-", "cfun", "->", "machine", "->", "callee_saved_reg_size", ";", "}", "else", "if", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", "&&", "(", "to", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "ret", "=", "0x00", ";", "else", "abort", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "INITIAL_ELIMINATION_OFFSET", ",", "return", "the", "OFFSET", "." ]

[ "moxie", "0x00" ]

[]

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

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

[ "rs6000" ]

[]

[ "<s>", "void", "KudeyarFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "KudeyarMachineFunctionInfo", "*", "KudeyarFI", "=", "MF", ".", "getInfo", "<", "KudeyarMachineFunctionInfo", ">", "(", ")", ";", "const", "KudeyarInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "KudeyarInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "4", ";", "NumBytes", "=", "FrameSize", "-", "KudeyarFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "PUSH_R", ")", ")", ".", "addReg", "(", "Kudeyar", "::", "FP", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "MOV_RR", ")", ",", "Kudeyar", "::", "FP", ")", ".", "addReg", "(", "Kudeyar", "::", "SP", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "llvm", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "Kudeyar", "::", "FP", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "KudeyarFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Kudeyar", "::", "PUSH_R", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "SUB_RI32", ")", ",", "Kudeyar", "::", "SP", ")", ".", "addReg", "(", "Kudeyar", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "0", "4", "Kudeyar", "Kudeyar::PUSH_R", "Kudeyar::FP", "Kudeyar::MOV_RR", "Kudeyar::FP", "Kudeyar::SP", "Kudeyar::FP", "Kudeyar", "Kudeyar::PUSH_R", "Kudeyar::SUB_RI32", "Kudeyar::SP", "Kudeyar::SP" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addInstSelector", "(", ")", "{", "const", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonRemoveExtendArgs", "(", "TM", ")", ")", ";", "addPass", "(", "createHexagonISelDag", "(", "TM", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "addPass", "(", "createHexagonPeephole", "(", ")", ")", ";", "printAndVerify", "(", "\"After hexagon peephole pass\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"After hexagon peephole pass\"" ]

[]

[ "<s>", "static", "bool", "abi_v4_pass_in_fpr", "(", "machine_mode", "mode", ",", "bool", "named", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "return", "false", ";", "if", "(", "TARGET_DOUBLE_FLOAT", "&&", "mode", "==", "DFmode", ")", "return", "true", ";", "if", "(", "TARGET_SINGLE_FLOAT", "&&", "mode", "==", "SFmode", "&&", "named", ")", "return", "true", ";", "if", "(", "is_complex_IBM_long_double", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "ABI_V4", "passes", "MODE", "args", "to", "a", "function", "in", "floating", "point", "registers", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "AArch64TTIImpl", "::", "getCacheLineSize", "(", ")", "{", "return", "ST", "->", "getCacheLineSize", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "PowerPC", "PPC", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "bool", "csky_shifted_imm8_constant", "(", "unsigned", "HOST_WIDE_INT", "val", ",", "unsigned", "int", "*", "base", ",", "unsigned", "int", "*", "shift", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", "=", "0xff", ";", "int", "i", ";", "val", "=", "val", "&", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffffu", ";", "if", "(", "val", "==", "0", ")", "return", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "25", ";", "i", "++", ")", "if", "(", "(", "val", "&", "(", "mask", "<<", "i", ")", ")", "==", "val", ")", "{", "if", "(", "base", ")", "*", "base", "=", "(", "unsigned", "int", ")", "(", "val", ">>", "i", ")", ";", "if", "(", "shift", ")", "*", "shift", "=", "(", "unsigned", "int", ")", "i", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "constant", "VAL", "can", "be", "expressed", "by", "an", "8-bit", "constant", "with", "a", "shift", "value", ",", "filling", "in", "*", "BASE", "and", "*", "SHIFT", "." ]

[ "csky", "0xff", "0xffffffffu", "0", "0", "0", "25" ]

[]

[ "<s>", "bool", "MandarinAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "O", "<<", "'['", ";", "printMemOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "']'", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "Mandarin", "0" ]

[]

[ "<s>", "machreg_t", "inet_makeaddr", "(", "machreg_t", "net", ",", "machreg_t", "lna", ")", "{", "return", "_inet_makeaddr", "(", "net", ",", "lna", ")", ">>", "SHIFT_BITS", ";", "}", "</s>" ]

[ "<", "arpa/inet.h", ">", "has", "struct", "in_addr", "inet_makeaddr", "(", "int", ",", "int", ")", ";", "(", "IRIX", "6.2", ")", "struct", "in_addr", "inet_makeaddr", "(", "in_addr_t", ",", "in_addr_t", ")", ";", "(", "IRIX", "6.5", ")" ]

[ "mips" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createX86ISelDag", "(", "getX86TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "Triple", "(", "TM", "->", "getTargetTriple", "(", ")", ")", ".", "isOSBinFormatELF", "(", ")", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createCleanupLocalDynamicTLSPass", "(", ")", ")", ";", "addPass", "(", "createX86GlobalBaseRegPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx_insn", "*", "apply_GEN_FCN", "(", "enum", "insn_code", "icode", ",", "rtx", "*", "arg", ")", "{", "switch", "(", "insn_data", "[", "icode", "]", ".", "n_generator_args", ")", "{", "case", "0", ":", "return", "GEN_FCN", "(", "icode", ")", "(", ")", ";", "case", "1", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ")", ";", "case", "2", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ",", "arg", "[", "1", "]", ")", ";", "case", "3", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ",", "arg", "[", "1", "]", ",", "arg", "[", "2", "]", ")", ";", "case", "4", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ",", "arg", "[", "1", "]", ",", "arg", "[", "2", "]", ",", "arg", "[", "3", "]", ")", ";", "case", "5", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ",", "arg", "[", "1", "]", ",", "arg", "[", "2", "]", ",", "arg", "[", "3", "]", ",", "arg", "[", "4", "]", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Helper", "arc_expand_builtin", ",", "generates", "a", "pattern", "for", "the", "given", "icode", "and", "arguments", "." ]

[ "arc", "0", "1", "0", "2", "0", "1", "3", "0", "1", "2", "4", "0", "1", "2", "3", "5", "0", "1", "2", "3", "4" ]

[]

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

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

[ "LC3", "LC3" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "MSP430RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "MSP430", "::", "FP", ",", "MSP430", "::", "R5", ",", "MSP430", "::", "R6", ",", "MSP430", "::", "R7", ",", "MSP430", "::", "R8", ",", "MSP430", "::", "R9", ",", "MSP430", "::", "R10", ",", "MSP430", "::", "R11", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsFP", "[", "]", "=", "{", "MSP430", "::", "R5", ",", "MSP430", "::", "R6", ",", "MSP430", "::", "R7", ",", "MSP430", "::", "R8", ",", "MSP430", "::", "R9", ",", "MSP430", "::", "R10", ",", "MSP430", "::", "R11", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsIntr", "[", "]", "=", "{", "MSP430", "::", "FP", ",", "MSP430", "::", "R5", ",", "MSP430", "::", "R6", ",", "MSP430", "::", "R7", ",", "MSP430", "::", "R8", ",", "MSP430", "::", "R9", ",", "MSP430", "::", "R10", ",", "MSP430", "::", "R11", ",", "MSP430", "::", "R12", ",", "MSP430", "::", "R13", ",", "MSP430", "::", "R14", ",", "MSP430", "::", "R15", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "MSP430", "::", "R5", ",", "MSP430", "::", "R6", ",", "MSP430", "::", "R7", ",", "MSP430", "::", "R8", ",", "MSP430", "::", "R9", ",", "MSP430", "::", "R10", ",", "MSP430", "::", "R11", ",", "MSP430", "::", "R12", ",", "MSP430", "::", "R13", ",", "MSP430", "::", "R14", ",", "MSP430", "::", "R15", ",", "0", "}", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::FP", "MSP430::R5", "MSP430::R6", "MSP430::R7", "MSP430::R8", "MSP430::R9", "MSP430::R10", "MSP430::R11", "0", "MSP430::R5", "MSP430::R6", "MSP430::R7", "MSP430::R8", "MSP430::R9", "MSP430::R10", "MSP430::R11", "0", "MSP430::FP", "MSP430::R5", "MSP430::R6", "MSP430::R7", "MSP430::R8", "MSP430::R9", "MSP430::R10", "MSP430::R11", "MSP430::R12", "MSP430::R13", "MSP430::R14", "MSP430::R15", "0", "MSP430::R5", "MSP430::R6", "MSP430::R7", "MSP430::R8", "MSP430::R9", "MSP430::R10", "MSP430::R11", "MSP430::R12", "MSP430::R13", "MSP430::R14", "MSP430::R15", "0", "MSP430", "MSP430" ]

[]

[ "<s>", "static", "void", "rs6000_elf_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "first", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "!", "TARGET_AIX", "&&", "DEFAULT_ABI", "==", "ABI_AIX", ")", "{", "rtx", "sym_ref", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "size_t", "len", "=", "strlen", "(", "XSTR", "(", "sym_ref", ",", "0", ")", ")", ";", "char", "*", "str", "=", "XALLOCAVEC", "(", "char", ",", "len", "+", "2", ")", ";", "str", "[", "0", "]", "=", "'.'", ";", "memcpy", "(", "str", "+", "1", ",", "XSTR", "(", "sym_ref", ",", "0", ")", ",", "len", "+", "1", ")", ";", "XSTR", "(", "sym_ref", ",", "0", ")", "=", "ggc_alloc_string", "(", "str", ",", "len", "+", "1", ")", ";", "}", "}", "</s>" ]

[ "For", "a", "SYMBOL_REF", ",", "set", "generic", "flags", "and", "then", "perform", "some", "target-specific", "processing", ".", "When", "the", "AIX", "ABI", "is", "requested", "on", "a", "non-AIX", "system", ",", "replace", "the", "function", "name", "with", "the", "real", "name", "(", "with", "a", "leading", ".", ")", "rather", "than", "the", "function", "descriptor", "name", ".", "This", "saves", "a", "lot", "of", "overriding", "code", "to", "read", "the", "prefixes", "." ]

[ "powerpcspe", "0", "0", "2", "0", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "bool", "nvptx_unisimt_handle_set", "(", "rtx", "set", ",", "rtx_insn", "*", "insn", ",", "rtx", "master", ")", "{", "rtx", "reg", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "SET", "&&", "REG_P", "(", "reg", "=", "SET_DEST", "(", "set", ")", ")", "&&", "find_reg_note", "(", "insn", ",", "REG_UNUSED", ",", "reg", ")", "==", "NULL_RTX", ")", "{", "emit_insn_after", "(", "nvptx_gen_shuffle", "(", "reg", ",", "reg", ",", "master", ",", "SHUFFLE_IDX", ")", ",", "insn", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "SET", "subexpression", "of", "INSN", "sets", "a", "register", ",", "emit", "a", "shuffle", "instruction", "to", "propagate", "its", "value", "from", "lane", "MASTER", "to", "current", "lane", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vzip", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "high", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out0", ",", "out1", ",", "in0", ",", "in1", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "first_elem", ";", "bool", "is_swapped", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ">=", "8", ")", "return", "false", ";", "is_swapped", "=", "BYTES_BIG_ENDIAN", ";", "first_elem", "=", "d", "->", "perm", "[", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "0", ")", "^", "is_swapped", "]", ";", "high", "=", "nelt", "/", "2", ";", "if", "(", "first_elem", "==", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "high", ")", ")", ";", "else", "if", "(", "first_elem", "==", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "0", ")", ")", "high", "=", "0", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", "/", "2", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "i", "+", "high", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "2", "*", "i", "+", "is_swapped", ")", "]", "!=", "elt", ")", "return", "false", ";", "elt", "=", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "i", "+", "nelt", "+", "high", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "2", "*", "i", "+", "!", "is_swapped", ")", "]", "!=", "elt", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vzipv16qi_internal", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vzipv8qi_internal", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vzipv8hi_internal", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vzipv4hi_internal", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_neon_vzipv4si_internal", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_neon_vzipv2si_internal", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_neon_vzipv2sf_internal", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_neon_vzipv4sf_internal", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "is_swapped", ")", "std", "::", "swap", "(", "in0", ",", "in1", ")", ";", "out0", "=", "d", "->", "target", ";", "out1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "if", "(", "high", ")", "std", "::", "swap", "(", "out0", ",", "out1", ")", ";", "emit_insn", "(", "gen", "(", "out0", ",", "in0", ",", "in1", ",", "out1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VZIP", "insns", "." ]

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

[]

[ "<s>", "static", "bool", "sparc_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "if", "(", "code", "==", "'#'", "||", "code", "==", "'*'", "||", "code", "==", "'('", "||", "code", "==", "')'", "||", "code", "==", "'_'", "||", "code", "==", "'&'", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_PUNCT_VALID_P", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "void", "riscv_block_move_straight", "(", "rtx", "dest", ",", "rtx", "src", ",", "unsigned", "HOST_WIDE_INT", "length", ")", "{", "unsigned", "HOST_WIDE_INT", "offset", ",", "delta", ";", "unsigned", "HOST_WIDE_INT", "bits", ";", "int", "i", ";", "enum", "machine_mode", "mode", ";", "rtx", "*", "regs", ";", "bits", "=", "MAX", "(", "BITS_PER_UNIT", ",", "MIN", "(", "BITS_PER_WORD", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ")", ")", ";", "mode", "=", "mode_for_size", "(", "bits", ",", "MODE_INT", ",", "0", ")", ".", "require", "(", ")", ";", "delta", "=", "bits", "/", "BITS_PER_UNIT", ";", "regs", "=", "XALLOCAVEC", "(", "rtx", ",", "length", "/", "delta", ")", ";", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "{", "regs", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "riscv_emit_move", "(", "regs", "[", "i", "]", ",", "adjust_address", "(", "src", ",", "mode", ",", "offset", ")", ")", ";", "}", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "riscv_emit_move", "(", "adjust_address", "(", "dest", ",", "mode", ",", "offset", ")", ",", "regs", "[", "i", "]", ")", ";", "if", "(", "offset", "<", "length", ")", "{", "src", "=", "adjust_address", "(", "src", ",", "BLKmode", ",", "offset", ")", ";", "dest", "=", "adjust_address", "(", "dest", ",", "BLKmode", ",", "offset", ")", ";", "move_by_pieces", "(", "dest", ",", "src", ",", "length", "-", "offset", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ",", "RETURN_BEGIN", ")", ";", "}", "}", "</s>" ]

[ "Emit", "straight-line", "code", "to", "move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", ".", "Assume", "that", "the", "areas", "do", "not", "overlap", "." ]

[ "riscv", "0", "0", "0", "0", "0" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

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

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

[ "AArch64", "\"AArch64O0PreLegalizerCombiner\"" ]

[]

[ "<s>", "bool", "SIPeepholeSDWA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasSDWA", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "matchSDWAOperands", "(", "MF", ")", ";", "for", "(", "const", "auto", "&", "OperandPair", ":", "SDWAOperands", ")", "{", "const", "auto", "&", "Operand", "=", "OperandPair", ".", "second", ";", "MachineInstr", "*", "PotentialMI", "=", "Operand", "->", "potentialToConvert", "(", "TII", ")", ";", "if", "(", "PotentialMI", "&&", "isConvertibleToSDWA", "(", "*", "PotentialMI", ",", "ST", ")", ")", "{", "PotentialMatches", "[", "PotentialMI", "]", ".", "push_back", "(", "Operand", ".", "get", "(", ")", ")", ";", "}", "}", "for", "(", "auto", "&", "PotentialPair", ":", "PotentialMatches", ")", "{", "MachineInstr", "&", "PotentialMI", "=", "*", "PotentialPair", ".", "first", ";", "convertToSDWA", "(", "PotentialMI", ",", "PotentialPair", ".", "second", ")", ";", "}", "PotentialMatches", ".", "clear", "(", ")", ";", "SDWAOperands", ".", "clear", "(", ")", ";", "bool", "Ret", "=", "!", "ConvertedInstructions", ".", "empty", "(", ")", ";", "while", "(", "!", "ConvertedInstructions", ".", "empty", "(", ")", ")", "legalizeScalarOperands", "(", "*", "ConvertedInstructions", ".", "pop_back_val", "(", ")", ",", "ST", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isLoadBitCastBeneficial", "(", "EVT", "LoadTy", ",", "EVT", "CastTy", ",", "const", "SelectionDAG", "&", "DAG", ",", "const", "MachineMemOperand", "&", "MMO", ")", "const", "{", "assert", "(", "LoadTy", ".", "getSizeInBits", "(", ")", "==", "CastTy", ".", "getSizeInBits", "(", ")", ")", ";", "if", "(", "LoadTy", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i32", ")", "return", "false", ";", "unsigned", "LScalarSize", "=", "LoadTy", ".", "getScalarSizeInBits", "(", ")", ";", "unsigned", "CastScalarSize", "=", "CastTy", ".", "getScalarSizeInBits", "(", ")", ";", "if", "(", "(", "LScalarSize", ">=", "CastScalarSize", ")", "&&", "(", "CastScalarSize", "<", "32", ")", ")", "return", "false", ";", "bool", "Fast", "=", "false", ";", "return", "allowsMemoryAccess", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "DAG", ".", "getDataLayout", "(", ")", ",", "CastTy", ",", "MMO", ",", "&", "Fast", ")", "&&", "Fast", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "following", "transform", "is", "beneficial", ":", "fold", "(", "conv", "(", "load", "x", ")", ")", "-", ">", "(", "load", "(", "conv", "*", ")", "x", ")", "On", "architectures", "that", "do", "n't", "natively", "support", "some", "vector", "loads", "efficiently", ",", "casting", "the", "load", "to", "a", "smaller", "vector", "of", "larger", "types", "and", "loading", "is", "more", "efficient", ",", "however", ",", "this", "can", "be", "undone", "by", "optimizations", "in", "dag", "combiner", "." ]

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

[]

[ "<s>", "bool", "BTFDebug", "::", "InstLower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "GVar", ")", "{", "int64_t", "Imm", ";", "uint32_t", "Reloc", ";", "if", "(", "GVar", "->", "hasAttribute", "(", "BPFCoreSharedInfo", "::", "AmaAttr", ")", "||", "GVar", "->", "hasAttribute", "(", "BPFCoreSharedInfo", "::", "TypeIdAttr", ")", ")", "{", "Imm", "=", "PatchImms", "[", "GVar", "]", ".", "first", ";", "Reloc", "=", "PatchImms", "[", "GVar", "]", ".", "second", ";", "}", "else", "{", "return", "false", ";", "}", "if", "(", "Reloc", "==", "BPFCoreSharedInfo", "::", "ENUM_VALUE_EXISTENCE", "||", "Reloc", "==", "BPFCoreSharedInfo", "::", "ENUM_VALUE", "||", "Reloc", "==", "BPFCoreSharedInfo", "::", "BTF_TYPE_ID_LOCAL", "||", "Reloc", "==", "BPFCoreSharedInfo", "::", "BTF_TYPE_ID_REMOTE", ")", "OutMI", ".", "setOpcode", "(", "BPF", "::", "LD_imm64", ")", ";", "else", "OutMI", ".", "setOpcode", "(", "BPF", "::", "MOV_ri", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "return", "true", ";", "}", "}", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_MEM", "||", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_ALU32_MEM", "||", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_SHIFT", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "3", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "GVar", "&&", "GVar", "->", "hasAttribute", "(", "BPFCoreSharedInfo", "::", "AmaAttr", ")", ")", "{", "uint32_t", "Imm", "=", "PatchImms", "[", "GVar", "]", ".", "first", ";", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isImm", "(", ")", ")", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ")", ")", ";", "else", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Emit", "proper", "patchable", "instructions", "." ]

[ "BPF", "BPF::LD_imm64", "1", "BPFCoreSharedInfo::AmaAttr", "BPFCoreSharedInfo::TypeIdAttr", "BPFCoreSharedInfo::ENUM_VALUE_EXISTENCE", "BPFCoreSharedInfo::ENUM_VALUE", "BPFCoreSharedInfo::BTF_TYPE_ID_LOCAL", "BPFCoreSharedInfo::BTF_TYPE_ID_REMOTE", "BPF::LD_imm64", "BPF::MOV_ri", "0", "BPF::CORE_MEM", "BPF::CORE_ALU32_MEM", "BPF::CORE_SHIFT", "3", "BPFCoreSharedInfo::AmaAttr", "1", "0", "0", "0", "2" ]

[]

[ "<s>", "void", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "Opcode", ")", ";", "uint64_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "support", "::", "endianness", "E", "=", "IsLittleEndian", "?", "support", "::", "little", ":", "support", "::", "big", ";", "switch", "(", "Size", ")", "{", "case", "0", ":", "break", ";", "case", "4", ":", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Bits", ",", "E", ")", ";", "break", ";", "case", "8", ":", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Bits", ">>", "32", ",", "E", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Bits", ",", "E", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid instruction size\"", ")", ";", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "PowerPC", "support::endianness", "support::little", "support::big", "0", "4", "support::endian", "8", "support::endian", "32", "support::endian", "\"Invalid instruction size\"" ]

[]

[ "<s>", "static", "void", "sparc_emit_set_const64_longway", "(", "rtx", "op0", ",", "rtx", "temp", ",", "unsigned", "HOST_WIDE_INT", "high_bits", ",", "unsigned", "HOST_WIDE_INT", "low_bits", ")", "{", "rtx", "sub_temp", "=", "op0", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "sub_temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "(", "high_bits", "&", "0xfffffc00", ")", "!=", "0", ")", "{", "emit_insn", "(", "gen_safe_HIGH64", "(", "temp", ",", "high_bits", ")", ")", ";", "if", "(", "(", "high_bits", "&", "~", "0xfffffc00", ")", "!=", "0", ")", "emit_insn", "(", "gen_rtx_SET", "(", "sub_temp", ",", "gen_safe_OR64", "(", "temp", ",", "(", "high_bits", "&", "0x3ff", ")", ")", ")", ")", ";", "else", "sub_temp", "=", "temp", ";", "}", "else", "{", "emit_insn", "(", "gen_safe_SET64", "(", "temp", ",", "high_bits", ")", ")", ";", "sub_temp", "=", "temp", ";", "}", "if", "(", "can_create_pseudo_p", "(", ")", ")", "{", "rtx", "temp2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "temp3", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "temp4", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp4", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "sub_temp", ",", "GEN_INT", "(", "32", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_safe_HIGH64", "(", "temp2", ",", "low_bits", ")", ")", ";", "if", "(", "(", "low_bits", "&", "~", "0xfffffc00", ")", "!=", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "temp3", ",", "gen_safe_OR64", "(", "temp2", ",", "(", "low_bits", "&", "0x3ff", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_PLUS", "(", "DImode", ",", "temp4", ",", "temp3", ")", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_PLUS", "(", "DImode", ",", "temp4", ",", "temp2", ")", ")", ")", ";", "}", "}", "else", "{", "rtx", "low1", "=", "GEN_INT", "(", "(", "low_bits", ">>", "(", "32", "-", "12", ")", ")", "&", "0xfff", ")", ";", "rtx", "low2", "=", "GEN_INT", "(", "(", "low_bits", ">>", "(", "32", "-", "12", "-", "12", ")", ")", "&", "0xfff", ")", ";", "rtx", "low3", "=", "GEN_INT", "(", "(", "low_bits", ">>", "(", "32", "-", "12", "-", "12", "-", "8", ")", ")", "&", "0x0ff", ")", ";", "int", "to_shift", "=", "12", ";", "if", "(", "low1", "!=", "const0_rtx", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "sub_temp", ",", "GEN_INT", "(", "to_shift", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_IOR", "(", "DImode", ",", "op0", ",", "low1", ")", ")", ")", ";", "sub_temp", "=", "op0", ";", "to_shift", "=", "12", ";", "}", "else", "{", "to_shift", "+=", "12", ";", "}", "if", "(", "low2", "!=", "const0_rtx", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "sub_temp", ",", "GEN_INT", "(", "to_shift", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_IOR", "(", "DImode", ",", "op0", ",", "low2", ")", ")", ")", ";", "sub_temp", "=", "op0", ";", "to_shift", "=", "8", ";", "}", "else", "{", "to_shift", "+=", "8", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "sub_temp", ",", "GEN_INT", "(", "to_shift", ")", ")", ")", ")", ";", "if", "(", "low3", "!=", "const0_rtx", ")", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_IOR", "(", "DImode", ",", "op0", ",", "low3", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Full", "64-bit", "constant", "decomposition", ".", "Even", "though", "this", "is", "the", "'worst", "'", "case", ",", "we", "still", "optimize", "a", "few", "things", "away", "." ]

[ "sparc", "0xfffffc00", "0", "0xfffffc00", "0", "0x3ff", "32", "0xfffffc00", "0", "0x3ff", "32", "12", "0xfff", "32", "12", "12", "0xfff", "32", "12", "12", "8", "0x0ff", "12", "12", "12", "8", "8" ]

[]

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

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

[ "Comet2", "Comet2" ]

[]

[ "<s>", "void", "set", "(", "size_t", "Slot", ",", "const", "StackVreg", "&", "Elem", ")", "{", "assert", "(", "Slot", "<", "Data", ".", "size", "(", ")", "&&", "\"Out of range access\"", ")", ";", "Data", "[", "Slot", "]", "=", "Elem", ";", "}", "</s>" ]

[ "Set", "the", "generated", "scalar", "V", "for", "Def", "and", "the", "given", "Instance", "." ]

[ "TVM", "\"Out of range access\"" ]

[]

[ "<s>", "static", "pad_direction", "iq2000_function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "return", "(", "!", "BYTES_BIG_ENDIAN", "?", "PAD_UPWARD", ":", "(", "(", "mode", "==", "BLKmode", "?", "(", "type", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "int_size_in_bytes", "(", "type", ")", "<", "(", "PARM_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", ":", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<", "PARM_BOUNDARY", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", ")", "?", "PAD_DOWNWARD", ":", "PAD_UPWARD", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_PADDING", "." ]

[ "iq2000" ]

[]

[ "<s>", "void", "pdp11_expand_epilogue", "(", "void", ")", "{", "HOST_WIDE_INT", "fsize", "=", "get_frame_size", "(", ")", ";", "unsigned", "regno", ";", "rtx", "x", ",", "reg", ",", "via_ac", "=", "NULL", ";", "if", "(", "fsize", ")", "{", "if", "(", "frame_pointer_needed", ")", "{", "emit_move_insn", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ";", "}", "else", "emit_insn", "(", "gen_addhi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "fsize", ")", ")", ")", ";", "}", "if", "(", "pdp11_saved_regno", "(", "AC4_REGNUM", ")", "||", "pdp11_saved_regno", "(", "AC5_REGNUM", ")", ")", "{", "for", "(", "regno", "=", "AC0_REGNUM", ";", "regno", "<=", "AC3_REGNUM", ";", "regno", "++", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", ")", "{", "via_ac", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "break", ";", "}", "}", "for", "(", "regno", "=", "AC5_REGNUM", ";", "regno", ">=", "AC0_REGNUM", ";", "regno", "--", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", ")", "{", "x", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "DFmode", ",", "x", ")", ";", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "if", "(", "LOAD_FPU_REG_P", "(", "regno", ")", ")", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "else", "{", "emit_move_insn", "(", "via_ac", ",", "x", ")", ";", "emit_move_insn", "(", "reg", ",", "via_ac", ")", ";", "}", "}", "for", "(", "regno", "=", "PC_REGNUM", ";", "regno", ">=", "R0_REGNUM", "+", "2", ";", "regno", "--", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", ")", "{", "x", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "Pmode", ",", "x", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ",", "x", ")", ";", "}", "emit_jump_insn", "(", "gen_rtspc", "(", ")", ")", ";", "}", "</s>" ]

[ "Generate", "epilogue", ".", "This", "uses", "the", "frame", "pointer", "to", "pop", "the", "local", "variables", "and", "any", "alloca", "data", "off", "the", "stack", ".", "If", "there", "is", "no", "alloca", "and", "frame", "pointer", "elimination", "has", "n't", "been", "disabled", ",", "there", "is", "no", "frame", "pointer", "and", "the", "local", "variables", "are", "popped", "by", "adjusting", "the", "stack", "pointer", "instead", "." ]

[ "pdp11", "2" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SIRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "CallingConv", "::", "ID", "CC", "=", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "return", "CSR_AMDGPU_HighRegs_SaveList", ";", "default", ":", "{", "static", "const", "MCPhysReg", "NoCalleeSavedReg", "=", "AMDGPU", "::", "NoRegister", ";", "return", "&", "NoCalleeSavedReg", ";", "}", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "getLength", "(", ")", "{", "return", "CurType", ".", "Length", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "of", "data", "in", "this", "stream", "." ]

[ "X86" ]

[]

[ "<s>", "const", "uint16_t", "*", "FISCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "FISC", "::", "LR", ",", "FISC", "::", "X19", ",", "FISC", "::", "X20", ",", "FISC", "::", "X21", ",", "FISC", "::", "X22", ",", "FISC", "::", "X23", ",", "FISC", "::", "X24", ",", "FISC", "::", "X25", ",", "FISC", "::", "X26", ",", "FISC", "::", "X27", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC::LR", "FISC::X19", "FISC::X20", "FISC::X21", "FISC::X22", "FISC::X23", "FISC::X24", "FISC::X25", "FISC::X26", "FISC::X27", "0" ]

[]

[ "<s>", "static", "rtx", "aarch64_function_value", "(", "const_tree", "type", ",", "const_tree", "func", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "int", "unsignedp", ";", "int", "count", ";", "machine_mode", "ag_mode", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", ")", "mode", "=", "promote_function_mode", "(", "type", ",", "mode", ",", "&", "unsignedp", ",", "func", ",", "1", ")", ";", "if", "(", "aarch64_return_in_msb", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", "%", "UNITS_PER_WORD", "!=", "0", ")", "{", "size", "+=", "UNITS_PER_WORD", "-", "size", "%", "UNITS_PER_WORD", ";", "mode", "=", "int_mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "0", ")", ".", "require", "(", ")", ";", "}", "}", "if", "(", "aarch64_vfp_is_call_or_return_candidate", "(", "mode", ",", "type", ",", "&", "ag_mode", ",", "&", "count", ",", "NULL", ")", ")", "{", "if", "(", "!", "aarch64_composite_type_p", "(", "type", ",", "mode", ")", ")", "{", "gcc_assert", "(", "count", "==", "1", "&&", "mode", "==", "ag_mode", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "V0_REGNUM", ")", ";", "}", "else", "{", "int", "i", ";", "rtx", "par", ";", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "ag_mode", ",", "V0_REGNUM", "+", "i", ")", ";", "rtx", "offset", "=", "gen_int_mode", "(", "i", "*", "GET_MODE_SIZE", "(", "ag_mode", ")", ",", "Pmode", ")", ";", "tmp", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "tmp", ",", "offset", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "tmp", ";", "}", "return", "par", ";", "}", "}", "else", "return", "gen_rtx_REG", "(", "mode", ",", "R0_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", ".", "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", "." ]

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

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "isAsmClobberable", "(", "const", "MachineFunction", "&", "MF", ",", "MCRegister", "PhysReg", ")", "const", "{", "return", "PhysReg", "!=", "PPC", "::", "R1", "&&", "PhysReg", "!=", "PPC", "::", "X1", ";", "}", "</s>" ]

[ "Returns", "false", "if", "we", "ca", "n't", "guarantee", "that", "Physreg", ",", "specified", "as", "an", "IR", "asm", "clobber", "constraint", ",", "will", "be", "preserved", "across", "the", "statement", "." ]

[ "PowerPC", "PPC", "PPC::R1", "PPC::X1" ]

[]

[ "<s>", "bool", "SITypeRewriter", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "AMDGPU", "::", "getShaderType", "(", "F", ")", "==", "ShaderType", "::", "COMPUTE", ")", "return", "false", ";", "visit", "(", "F", ")", ";", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::getShaderType" ]

[]

[ "<s>", "unsigned", "getError", "(", ")", "const", "{", "return", "(", "Error", ")", ";", "}", "</s>" ]

[ "Get", "the", "current", "error", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_output_readwrite_section_asm_op", "(", "const", "char", "*", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.csect %s[RW],%s\\n\"", ",", "xcoff_private_data_section_name", ",", "XCOFF_CSECT_DEFAULT_ALIGNMENT_STR", ")", ";", "}", "</s>" ]

[ "Likewise", "for", "read-write", "sections", "." ]

[ "rs6000", "\"\\t.csect %s[RW],%s\\n\"" ]

[]

[ "<s>", "static", "void", "riscv_unique_section", "(", "tree", "decl", ",", "int", "reloc", ")", "{", "const", "char", "*", "prefix", "=", "NULL", ";", "bool", "one_only", "=", "DECL_ONE_ONLY", "(", "decl", ")", "&&", "!", "HAVE_COMDAT_GROUP", ";", "switch", "(", "categorize_decl_for_section", "(", "decl", ",", "reloc", ")", ")", "{", "case", "SECCAT_SRODATA", ":", "prefix", "=", "one_only", "?", "\".sr\"", ":", "\".srodata\"", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "prefix", ")", "{", "const", "char", "*", "name", ",", "*", "linkonce", ";", "char", "*", "string", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "name", "=", "targetm", ".", "strip_name_encoding", "(", "name", ")", ";", "linkonce", "=", "one_only", "?", "\".gnu.linkonce\"", ":", "\"\"", ";", "string", "=", "ACONCAT", "(", "(", "linkonce", ",", "prefix", ",", "\".\"", ",", "name", ",", "NULL", ")", ")", ";", "set_decl_section_name", "(", "decl", ",", "string", ")", ";", "return", ";", "}", "default_unique_section", "(", "decl", ",", "reloc", ")", ";", "}", "</s>" ]

[ "Switch", "to", "the", "appropriate", "section", "for", "output", "of", "DECL", "." ]

[ "riscv", "\".sr\"", "\".srodata\"", "\".gnu.linkonce\"", "\"\"", "\".\"" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "addPass", "(", "createAArch64BranchRelaxation", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "InstructionCost", "AArch64TTIImpl", "::", "getArithmeticReductionCost", "(", "unsigned", "Opcode", ",", "VectorType", "*", "ValTy", ",", "bool", "IsPairwiseForm", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "isa", "<", "ScalableVectorType", ">", "(", "ValTy", ")", ")", "return", "getArithmeticReductionCostSVE", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ",", "CostKind", ")", ";", "if", "(", "IsPairwiseForm", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "ValTy", ")", ";", "MVT", "MTy", "=", "LT", ".", "second", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "assert", "(", "ISD", "&&", "\"Invalid opcode\"", ")", ";", "static", "const", "CostTblEntry", "CostTblNoPairwise", "[", "]", "{", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i8", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v16i8", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i16", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i16", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i32", ",", "1", "}", ",", "}", ";", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "CostTblNoPairwise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "vector", "reduction", "intrinsics", "." ]

[ "AArch64", "AArch64", "\"Invalid opcode\"", "ISD::ADD", "MVT::v8i8", "1", "ISD::ADD", "MVT::v16i8", "1", "ISD::ADD", "MVT::v4i16", "1", "ISD::ADD", "MVT::v8i16", "1", "ISD::ADD", "MVT::v4i32", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI insert wait instructions\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI insert wait instructions\"" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "int", "symbolic_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "1", "if", "X", "contains", "a", "symbolic", "expression", ".", "We", "know", "these", "expressions", "will", "have", "one", "of", "a", "few", "well", "defined", "forms", ",", "so", "we", "need", "only", "check", "those", "forms", "." ]

[ "arc", "1", "0" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ";", "ModulePass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "LLT", "PtrTy", "=", "LLT", "::", "pointer", "(", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ",", "32", ")", ";", "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "if", "(", "IsTailCall", ")", "{", "Offset", "+=", "FPDiff", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "auto", "FIReg", "=", "MIRBuilder", ".", "buildFrameIndex", "(", "PtrTy", ",", "FI", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "return", "FIReg", ".", "getReg", "(", "0", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "SPReg", ")", "SPReg", "=", "MIRBuilder", ".", "buildCopy", "(", "PtrTy", ",", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "getReg", "(", "0", ")", ";", "auto", "OffsetReg", "=", "MIRBuilder", ".", "buildConstant", "(", "S32", ",", "Offset", ")", ";", "auto", "AddrReg", "=", "MIRBuilder", ".", "buildPtrAdd", "(", "PtrTy", ",", "SPReg", ",", "OffsetReg", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "Offset", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "AMDGPU", "ISD::ArgFlagsTy", "AMDGPU", "32", "32", "0", "SI", "SI", "0", "0" ]

[]

[ "<s>", "bool", "R600TargetLowering", "::", "isZero", "(", "SDValue", "Op", ")", "const", "{", "if", "(", "ConstantSDNode", "*", "Cst", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "return", "Cst", "->", "isNullValue", "(", ")", ";", "}", "else", "if", "(", "ConstantFPSDNode", "*", "CstFP", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "Op", ")", ")", "{", "return", "CstFP", "->", "isZero", "(", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "expression", "is", "a", "constant", "zero", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "void", "IA64InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "IA64", "::", "FPRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "LDF_FILL", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "}", "else", "if", "(", "RC", "==", "IA64", "::", "GRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "LD8", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "}", "else", "if", "(", "RC", "==", "IA64", "::", "PRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "LD8", ")", ",", "IA64", "::", "r2", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "CMPNE", ")", ",", "DestReg", ")", ".", "addReg", "(", "IA64", "::", "r2", ")", ".", "addReg", "(", "IA64", "::", "r0", ")", ";", "}", "else", "{", "assert", "(", "0", "&&", "\"sorry, I don't know how to load this sort of reg from the stack\\n\"", ")", ";", "}", "}", "</s>" ]

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

[ "IA64", "IA64", "IA64::FPRegisterClass", "IA64::LDF_FILL", "IA64::GRRegisterClass", "IA64::LD8", "IA64::PRRegisterClass", "IA64::LD8", "IA64::r2", "IA64::CMPNE", "IA64::r2", "IA64::r0", "0", "\"sorry, I don't know how to load this sort of reg from the stack\\n\"" ]

[]

[ "<s>", "bool", "SystemZAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "SystemZInstPrinter", "::", "printAddress", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "getImm", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNo", "+", "2", ")", ".", "getReg", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "1", "2" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TRI", "->", "getRegSizeInBits", "(", "RISCV", "::", "GPRRegClass", ")", "==", "32", "?", "RISCV", "::", "SW", ":", "RISCV", "::", "SD", ";", "else", "if", "(", "RISCV", "::", "GPRV64I8RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "SDVI8", ";", "else", "if", "(", "RISCV", "::", "GPRV64I16RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "SDVI16", ";", "else", "if", "(", "RISCV", "::", "GPRV64I32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "SDVI32", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSD", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::GPRRegClass", "32", "RISCV::SW", "RISCV::SD", "RISCV::GPRV64I8RegClass", "RISCV::SDVI8", "RISCV::GPRV64I16RegClass", "RISCV::SDVI16", "RISCV::GPRV64I32RegClass", "RISCV::SDVI32", "RISCV::FPR32RegClass", "RISCV::FSW", "RISCV::FPR64RegClass", "RISCV::FSD", "\"Can't store this register to stack slot\"", "0" ]

[]

[ "<s>", "Align", "SITargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "const", "Align", "PrefAlign", "=", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "const", "Align", "CacheLineAlign", "=", "Align", "(", "64", ")", ";", "if", "(", "!", "ML", "||", "DisableLoopAlignment", "||", "(", "getSubtarget", "(", ")", "->", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "GFX10", ")", "||", "getSubtarget", "(", ")", "->", "hasInstFwdPrefetchBug", "(", ")", ")", "return", "PrefAlign", ";", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "const", "MachineBasicBlock", "*", "Header", "=", "ML", "->", "getHeader", "(", ")", ";", "if", "(", "Header", "->", "getAlignment", "(", ")", "!=", "PrefAlign", ")", "return", "Header", "->", "getAlignment", "(", ")", ";", "unsigned", "LoopSize", "=", "0", ";", "for", "(", "const", "MachineBasicBlock", "*", "MBB", ":", "ML", "->", "blocks", "(", ")", ")", "{", "if", "(", "MBB", "!=", "Header", ")", "LoopSize", "+=", "MBB", "->", "getAlignment", "(", ")", ".", "value", "(", ")", "/", "2", ";", "for", "(", "const", "MachineInstr", "&", "MI", ":", "*", "MBB", ")", "{", "LoopSize", "+=", "TII", "->", "getInstSizeInBytes", "(", "MI", ")", ";", "if", "(", "LoopSize", ">", "192", ")", "return", "PrefAlign", ";", "}", "}", "if", "(", "LoopSize", "<=", "64", ")", "return", "PrefAlign", ";", "if", "(", "LoopSize", "<=", "128", ")", "return", "CacheLineAlign", ";", "for", "(", "MachineLoop", "*", "P", "=", "ML", "->", "getParentLoop", "(", ")", ";", "P", ";", "P", "=", "P", "->", "getParentLoop", "(", ")", ")", "{", "if", "(", "MachineBasicBlock", "*", "Exit", "=", "P", "->", "getExitBlock", "(", ")", ")", "{", "auto", "I", "=", "Exit", "->", "getFirstNonDebugInstr", "(", ")", ";", "if", "(", "I", "!=", "Exit", "->", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_INST_PREFETCH", ")", "return", "CacheLineAlign", ";", "}", "}", "MachineBasicBlock", "*", "Pre", "=", "ML", "->", "getLoopPreheader", "(", ")", ";", "MachineBasicBlock", "*", "Exit", "=", "ML", "->", "getExitBlock", "(", ")", ";", "if", "(", "Pre", "&&", "Exit", ")", "{", "BuildMI", "(", "*", "Pre", ",", "Pre", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_INST_PREFETCH", ")", ")", ".", "addImm", "(", "1", ")", ";", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstNonDebugInstr", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_INST_PREFETCH", ")", ")", ".", "addImm", "(", "2", ")", ";", "}", "return", "CacheLineAlign", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "AMDGPU", "SI", "64", "AMDGPU", "SI", "0", "2", "192", "64", "128", "AMDGPU::S_INST_PREFETCH", "AMDGPU::S_INST_PREFETCH", "1", "AMDGPU::S_INST_PREFETCH", "2" ]

[]

[ "<s>", "static", "const", "char", "*", "fp_const_from_val", "(", "REAL_VALUE_TYPE", "*", "r", ")", "{", "if", "(", "!", "fp_consts_inited", ")", "init_fp_table", "(", ")", ";", "gcc_assert", "(", "REAL_VALUES_EQUAL", "(", "*", "r", ",", "value_fp0", ")", ")", ";", "return", "\"0\"", ";", "}", "</s>" ]

[ "As", "for", "fp_immediate_constant", ",", "but", "value", "is", "passed", "directly", ",", "not", "in", "rtx", "." ]

[ "arm", "\"0\"" ]

[]

[ "<s>", "unsigned", "AArch64FastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "const", "auto", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "materializeInt", "(", "CI", ",", "VT", ")", ";", "else", "if", "(", "const", "ConstantFP", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "materializeFP", "(", "CFP", ",", "VT", ")", ";", "else", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "materializeGV", "(", "GV", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Emit", "a", "constant", "in", "a", "register", "using", "target-specific", "logic", ",", "such", "as", "constant", "pool", "loads", "." ]

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

[]

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

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

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

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown rematerializable operation!\"", ")", ";", "break", ";", "case", "PPC", "::", "LI", ":", "case", "PPC", "::", "LI8", ":", "case", "PPC", "::", "LIS", ":", "case", "PPC", "::", "LIS8", ":", "case", "PPC", "::", "QVGPCI", ":", "case", "PPC", "::", "ADDIStocHA", ":", "case", "PPC", "::", "ADDItocL", ":", "case", "PPC", "::", "LOAD_STACK_GUARD", ":", "case", "PPC", "::", "XXLXORz", ":", "case", "PPC", "::", "XXLXORspz", ":", "case", "PPC", "::", "XXLXORdpz", ":", "case", "PPC", "::", "V_SET0B", ":", "case", "PPC", "::", "V_SET0H", ":", "case", "PPC", "::", "V_SET0", ":", "case", "PPC", "::", "V_SETALLONESB", ":", "case", "PPC", "::", "V_SETALLONESH", ":", "case", "PPC", "::", "V_SETALLONES", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Unknown rematerializable operation!\"", "PPC::LI", "PPC::LI8", "PPC::LIS", "PPC::LIS8", "PPC::QVGPCI", "PPC::ADDIStocHA", "PPC::ADDItocL", "PPC::LOAD_STACK_GUARD", "PPC::XXLXORz", "PPC::XXLXORspz", "PPC::XXLXORdpz", "PPC::V_SET0B", "PPC::V_SET0H", "PPC::V_SET0", "PPC::V_SETALLONESB", "PPC::V_SETALLONESH", "PPC::V_SETALLONES" ]

[]

[ "<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>" ]

[ "Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "." ]

[ "AArch64" ]

[]

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

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

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

[]

[ "<s>", "static", "const", "char", "*", "avr_out_movhi_mr_r_xmega", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "int", "reg_src", "=", "true_regnum", "(", "src", ")", ";", "int", "mem_volatile_p", "=", "MEM_VOLATILE_P", "(", "dest", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "base", ")", ")", "{", "return", "io_address_operand", "(", "base", ",", "HImode", ")", "?", "avr_asm_len", "(", "\"out %i0,%A1\"", "CR_TAB", "\"out %i0+1,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ":", "avr_asm_len", "(", "\"sts %m0,%A1\"", "CR_TAB", "\"sts %m0+1,%B1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "}", "if", "(", "reg_base", ">", "0", ")", "{", "if", "(", "reg_base", "!=", "REG_X", ")", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"std %0+1,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "if", "(", "reg_src", "==", "REG_X", ")", "avr_asm_len", "(", "\"mov __tmp_reg__,r27\"", "CR_TAB", "\"st X,r26\"", "CR_TAB", "\"adiw r26,1\"", "CR_TAB", "\"st X,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "else", "avr_asm_len", "(", "\"st X+,%A1\"", "CR_TAB", "\"st X,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "reg_unused_after", "(", "insn", ",", "base", ")", "?", "\"\"", ":", "avr_asm_len", "(", "\"sbiw r26,1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "int", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ";", "reg_base", "=", "REGNO", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "disp", ">", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "{", "if", "(", "reg_base", "!=", "REG_Y", ")", "fatal_insn", "(", "\"incorrect insn:\"", ",", "insn", ")", ";", "return", "disp", "<=", "63", "+", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", "?", "avr_asm_len", "(", "\"adiw r28,%o0-62\"", "CR_TAB", "\"std Y+62,%A1\"", "CR_TAB", "\"std Y+63,%B1\"", "CR_TAB", "\"sbiw r28,%o0-62\"", ",", "op", ",", "plen", ",", "-", "4", ")", ":", "avr_asm_len", "(", "\"subi r28,lo8(-%o0)\"", "CR_TAB", "\"sbci r29,hi8(-%o0)\"", "CR_TAB", "\"st Y,%A1\"", "CR_TAB", "\"std Y+1,%B1\"", "CR_TAB", "\"subi r28,lo8(%o0)\"", "CR_TAB", "\"sbci r29,hi8(%o0)\"", ",", "op", ",", "plen", ",", "-", "6", ")", ";", "}", "if", "(", "reg_base", "!=", "REG_X", ")", "return", "avr_asm_len", "(", "\"std %A0,%A1\"", "CR_TAB", "\"std %B0,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "reg_src", "==", "REG_X", "?", "avr_asm_len", "(", "\"mov __tmp_reg__,r26\"", "CR_TAB", "\"mov __zero_reg__,r27\"", "CR_TAB", "\"adiw r26,%o0\"", "CR_TAB", "\"st X+,__tmp_reg__\"", "CR_TAB", "\"st X,__zero_reg__\"", "CR_TAB", "\"clr __zero_reg__\"", "CR_TAB", "\"sbiw r26,%o0+1\"", ",", "op", ",", "plen", ",", "-", "7", ")", ":", "avr_asm_len", "(", "\"adiw r26,%o0\"", "CR_TAB", "\"st X+,%A1\"", "CR_TAB", "\"st X,%B1\"", "CR_TAB", "\"sbiw r26,%o0+1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PRE_DEC", ")", "{", "if", "(", "!", "mem_volatile_p", ")", "return", "avr_asm_len", "(", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%A1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "REGNO", "(", "XEXP", "(", "base", ",", "0", ")", ")", "==", "REG_X", "?", "avr_asm_len", "(", "\"sbiw r26,2\"", "CR_TAB", "\"st X+,%A1\"", "CR_TAB", "\"st X,%B1\"", "CR_TAB", "\"sbiw r26,1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ":", "avr_asm_len", "(", "\"sbiw %r0,2\"", "CR_TAB", "\"st %p0,%A1\"", "CR_TAB", "\"std %p0+1,%B1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "POST_INC", ")", "{", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"st %0,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "}", "fatal_insn", "(", "\"unknown move insn:\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Helper", "for", "the", "next", "function", "for", "XMEGA", ".", "It", "does", "the", "same", "but", "with", "low", "byte", "first", "." ]

[ "avr", "0", "1", "0", "\"out %i0,%A1\"", "\"out %i0+1,%B1\"", "2", "\"sts %m0,%A1\"", "\"sts %m0+1,%B1\"", "4", "0", "\"st %0,%A1\"", "\"std %0+1,%B1\"", "2", "\"mov __tmp_reg__,r27\"", "\"st X,r26\"", "\"adiw r26,1\"", "\"st X,__tmp_reg__\"", "4", "\"st X+,%A1\"", "\"st X,%B1\"", "2", "\"\"", "\"sbiw r26,1\"", "1", "1", "0", "\"incorrect insn:\"", "63", "\"adiw r28,%o0-62\"", "\"std Y+62,%A1\"", "\"std Y+63,%B1\"", "\"sbiw r28,%o0-62\"", "4", "\"subi r28,lo8(-%o0)\"", "\"sbci r29,hi8(-%o0)\"", "\"st Y,%A1\"", "\"std Y+1,%B1\"", "\"subi r28,lo8(%o0)\"", "\"sbci r29,hi8(%o0)\"", "6", "\"std %A0,%A1\"", "\"std %B0,%B1\"", "2", "\"mov __tmp_reg__,r26\"", "\"mov __zero_reg__,r27\"", "\"adiw r26,%o0\"", "\"st X+,__tmp_reg__\"", "\"st X,__zero_reg__\"", "\"clr __zero_reg__\"", "\"sbiw r26,%o0+1\"", "7", "\"adiw r26,%o0\"", "\"st X+,%A1\"", "\"st X,%B1\"", "\"sbiw r26,%o0+1\"", "4", "\"st %0,%B1\"", "\"st %0,%A1\"", "2", "0", "\"sbiw r26,2\"", "\"st X+,%A1\"", "\"st X,%B1\"", "\"sbiw r26,1\"", "4", "\"sbiw %r0,2\"", "\"st %p0,%A1\"", "\"std %p0+1,%B1\"", "3", "\"st %0,%A1\"", "\"st %0,%B1\"", "2", "\"unknown move insn:\"", "\"\"" ]

[]

[ "<s>", "static", "rtx", "find_addr_reg", "(", "rtx", "addr", ")", "{", "while", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "REG", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", "return", "addr", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "a", "REG", "that", "occurs", "in", "ADDR", "with", "coefficient", "1", ".", "ADDR", "can", "be", "effectively", "incremented", "by", "incrementing", "REG", ".", "r0", "is", "special", "and", "we", "must", "not", "select", "it", "as", "an", "address", "register", "by", "this", "routine", "since", "our", "caller", "will", "try", "to", "increment", "the", "returned", "register", "via", "an", "``", "la", "''", "instruction", "." ]

[ "pdp11", "0", "0", "1", "1", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "tree", "ix86_handle_selectany_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "decl", "=", "*", "node", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "||", "!", "TREE_PUBLIC", "(", "decl", ")", ")", "error", "(", "\"%qE attribute applies only to initialized variables\"", "\" with external linkage\"", ",", "name", ")", ";", "else", "{", "make_decl_one_only", "(", "decl", ",", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "DECL_COMMON", "(", "decl", ")", "=", "0", ";", "}", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

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

[ "i386", "\"%qE attribute applies only to initialized variables\"", "\" with external linkage\"", "0" ]

[]

[ "<s>", "static", "rtx_insn", "*", "set_frame_related_p", "(", "void", ")", "{", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "rtx_insn", "*", "insn", ";", "end_sequence", "(", ")", ";", "if", "(", "!", "seq", ")", "return", "NULL", ";", "if", "(", "INSN_P", "(", "seq", ")", ")", "{", "insn", "=", "seq", ";", "while", "(", "insn", "!=", "NULL_RTX", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "seq", "=", "emit_insn", "(", "seq", ")", ";", "}", "else", "{", "seq", "=", "emit_insn", "(", "seq", ")", ";", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "1", ";", "}", "return", "seq", ";", "}", "</s>" ]

[ "Helper", "function", "to", "set", "RTX_FRAME_RELATED_P", "on", "instructions", ",", "including", "sequences", "." ]

[ "alpha", "1", "1" ]

[]

[ "<s>", "void", "StackFixup", "::", "dump", "(", ")", "const", "{", "print", "(", "dbgs", "(", ")", ")", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "TVM" ]

[]

[ "<s>", "static", "void", "expand_block_move_1", "(", "rtx", "dst_reg", ",", "rtx", "src_reg", ",", "rtx", "bytes_rtx", ")", "{", "const", "rtx", "sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__byt_memcpy\"", ")", ";", "emit_library_call", "(", "sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "dst_reg", ",", "Pmode", ",", "src_reg", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "bytes_rtx", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "}", "</s>" ]

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

[ "visium", "\"__byt_memcpy\"", "3" ]

[]

[ "<s>", "static", "bool", "nios2_legitimate_address_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "operand", ",", "bool", "strict_p", ")", "{", "switch", "(", "GET_CODE", "(", "operand", ")", ")", "{", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "operand", ")", ")", "return", "false", ";", "case", "CONST", ":", "if", "(", "gprel_constant_p", "(", "operand", ")", "||", "r0rel_constant_p", "(", "operand", ")", ")", "return", "true", ";", "case", "LABEL_REF", ":", "if", "(", "nios2_large_constant_allowed", "(", ")", "&&", "nios2_symbolic_constant_p", "(", "operand", ")", ")", "return", "true", ";", "return", "false", ";", "case", "CONST_INT", ":", "if", "(", "r0rel_constant_p", "(", "operand", ")", ")", "return", "true", ";", "return", "nios2_large_constant_allowed", "(", ")", ";", "case", "CONST_DOUBLE", ":", "return", "false", ";", "case", "REG", ":", "return", "nios2_regno_ok_for_base_p", "(", "REGNO", "(", "operand", ")", ",", "strict_p", ")", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "operand", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operand", ",", "1", ")", ";", "if", "(", "nios2_valid_addr_expr_p", "(", "op0", ",", "op1", ",", "strict_p", ")", "||", "nios2_valid_addr_expr_p", "(", "op1", ",", "op0", ",", "strict_p", ")", ")", "return", "true", ";", "}", "break", ";", "case", "LO_SUM", ":", "if", "(", "TARGET_ARCH_R2", "&&", "(", "TARGET_BYPASS_CACHE", "||", "TARGET_BYPASS_CACHE_VOLATILE", ")", ")", "return", "false", ";", "else", "{", "rtx", "op0", "=", "XEXP", "(", "operand", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operand", ",", "1", ")", ";", "return", "(", "REG_P", "(", "op0", ")", "&&", "nios2_regno_ok_for_base_p", "(", "REGNO", "(", "op0", ")", ",", "strict_p", ")", "&&", "nios2_large_constant_p", "(", "op1", ")", ")", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_ADDRESS_P", "." ]

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

[]

[ "<s>", "static", "bool", "ix86_broadcast", "(", "HOST_WIDE_INT", "v", ",", "unsigned", "int", "width", ",", "HOST_WIDE_INT", "&", "val_broadcast", ")", "{", "wide_int", "val", "=", "wi", "::", "uhwi", "(", "v", ",", "HOST_BITS_PER_WIDE_INT", ")", ";", "val_broadcast", "=", "wi", "::", "extract_uhwi", "(", "val", ",", "0", ",", "width", ")", ";", "for", "(", "unsigned", "int", "i", "=", "width", ";", "i", "<", "HOST_BITS_PER_WIDE_INT", ";", "i", "+=", "width", ")", "{", "HOST_WIDE_INT", "each", "=", "wi", "::", "extract_uhwi", "(", "val", ",", "i", ",", "width", ")", ";", "if", "(", "val_broadcast", "!=", "each", ")", "return", "false", ";", "}", "val_broadcast", "=", "sext_hwi", "(", "val_broadcast", ",", "width", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "V", "can", "be", "broadcasted", "from", "an", "integer", "of", "WIDTH", "bits", "which", "is", "returned", "in", "VAL_BROADCAST", ".", "Otherwise", ",", "return", "false", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", "||", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI_end", "=", "MBB", ".", "end", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "EH_RETURN_JMPR", ")", "{", "assert", "(", "MBBI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "\"Offset should be in register!\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "DEALLOCFRAME", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "ADD_rr", ")", ",", "Hexagon", "::", "R29", ")", ".", "addReg", "(", "Hexagon", "::", "R29", ")", ".", "addReg", "(", "Hexagon", "::", "R28", ")", ";", "return", ";", "}", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "hasV4TOps", "(", ")", "&&", "MBBI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "JMPret", "&&", "!", "DisableDeallocRet", ")", "{", "MachineBasicBlock", "::", "iterator", "BeforeJMPR", "=", "MBB", ".", "begin", "(", ")", "==", "MBBI", "?", "MBBI", ":", "std", "::", "prev", "(", "MBBI", ")", ";", "if", "(", "BeforeJMPR", "!=", "MBBI", "&&", "BeforeJMPR", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "RESTORE_DEALLOC_RET_JMP_V4", ")", "{", "MBB", ".", "erase", "(", "MBBI", ")", ";", "return", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI_end", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "DEALLOC_RET_V4", ")", ")", ";", "MIB", "->", "copyImplicitOps", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "&", "*", "MBBI", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "Term", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "Term", "==", "MBB", ".", "begin", "(", ")", "?", "MBB", ".", "end", "(", ")", ":", "std", "::", "prev", "(", "Term", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "RESTORE_DEALLOC_BEFORE_TAILCALL_V4", ")", "return", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "DEALLOCFRAME", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::EH_RETURN_JMPR", "0", "\"Offset should be in register!\"", "Hexagon::DEALLOCFRAME", "Hexagon::ADD_rr", "Hexagon::R29", "Hexagon::R29", "Hexagon::R28", "Hexagon", "Hexagon::JMPret", "Hexagon::RESTORE_DEALLOC_RET_JMP_V4", "Hexagon::DEALLOC_RET_V4", "Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4", "Hexagon::DEALLOCFRAME" ]

[]

[ "<s>", "static", "const", "char", "*", "s390_branch_condition_mnemonic", "(", "rtx", "code", ",", "int", "inv", ")", "{", "static", "const", "char", "*", "const", "mnemonic", "[", "16", "]", "=", "{", "NULL", ",", "\"o\"", ",", "\"h\"", ",", "\"nle\"", ",", "\"l\"", ",", "\"nhe\"", ",", "\"lh\"", ",", "\"ne\"", ",", "\"e\"", ",", "\"nlh\"", ",", "\"he\"", ",", "\"nl\"", ",", "\"le\"", ",", "\"nh\"", ",", "\"no\"", ",", "NULL", "}", ";", "int", "mask", "=", "s390_branch_condition_mask", "(", "code", ")", ";", "gcc_assert", "(", "mask", ">=", "0", ")", ";", "if", "(", "inv", ")", "mask", "^=", "15", ";", "gcc_assert", "(", "mask", ">=", "1", "&&", "mask", "<=", "14", ")", ";", "return", "mnemonic", "[", "mask", "]", ";", "}", "</s>" ]

[ "If", "INV", "is", "false", ",", "return", "assembler", "mnemonic", "string", "to", "implement", "a", "branch", "specified", "by", "CODE", ".", "If", "INV", "is", "true", ",", "return", "mnemonic", "for", "the", "corresponding", "inverted", "branch", "." ]

[ "s390", "16", "\"o\"", "\"h\"", "\"nle\"", "\"l\"", "\"nhe\"", "\"lh\"", "\"ne\"", "\"e\"", "\"nlh\"", "\"he\"", "\"nl\"", "\"le\"", "\"nh\"", "\"no\"", "0", "15", "1", "14" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_compute_func_type", "(", "void", ")", "{", "unsigned", "long", "type", "=", "ARM_FT_UNKNOWN", ";", "tree", "a", ";", "tree", "attr", ";", "gcc_assert", "(", "TREE_CODE", "(", "current_function_decl", ")", "==", "FUNCTION_DECL", ")", ";", "if", "(", "optimize", ">", "0", "&&", "(", "TREE_NOTHROW", "(", "current_function_decl", ")", "||", "!", "(", "flag_unwind_tables", "||", "(", "flag_exceptions", "&&", "!", "USING_SJLJ_EXCEPTIONS", ")", ")", ")", "&&", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", "type", "|=", "ARM_FT_VOLATILE", ";", "if", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "type", "|=", "ARM_FT_NESTED", ";", "attr", "=", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ";", "a", "=", "lookup_attribute", "(", "\"naked\"", ",", "attr", ")", ";", "if", "(", "a", "!=", "NULL_TREE", ")", "type", "|=", "ARM_FT_NAKED", ";", "a", "=", "lookup_attribute", "(", "\"isr\"", ",", "attr", ")", ";", "if", "(", "a", "==", "NULL_TREE", ")", "a", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "attr", ")", ";", "if", "(", "a", "==", "NULL_TREE", ")", "type", "|=", "TARGET_INTERWORK", "?", "ARM_FT_INTERWORKED", ":", "ARM_FT_NORMAL", ";", "else", "type", "|=", "arm_isr_value", "(", "TREE_VALUE", "(", "a", ")", ")", ";", "return", "type", ";", "}", "</s>" ]

[ "Computes", "the", "type", "of", "the", "current", "function", "." ]

[ "arm", "0", "\"naked\"", "\"isr\"", "\"interrupt\"" ]

[]

[ "<s>", "bool", "NVPTXLowerKernelArgs", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "isKernelFunction", "(", "F", ")", ")", "return", "false", ";", "if", "(", "TM", "&&", "TM", "->", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "{", "for", "(", "auto", "&", "B", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "B", ")", "{", "if", "(", "LoadInst", "*", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "LI", "->", "getType", "(", ")", "->", "isPointerTy", "(", ")", ")", "{", "Value", "*", "UO", "=", "GetUnderlyingObject", "(", "LI", "->", "getPointerOperand", "(", ")", ",", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "if", "(", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "UO", ")", ")", "{", "if", "(", "Arg", "->", "hasByValAttr", "(", ")", ")", "{", "markPointerAsGlobal", "(", "LI", ")", ";", "}", "}", "}", "}", "}", "}", "}", "for", "(", "Argument", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "getType", "(", ")", "->", "isPointerTy", "(", ")", ")", "{", "if", "(", "Arg", ".", "hasByValAttr", "(", ")", ")", "handleByValParam", "(", "&", "Arg", ")", ";", "else", "if", "(", "TM", "&&", "TM", "->", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "markPointerAsGlobal", "(", "&", "Arg", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX::CUDA", "NVPTX::CUDA" ]

[]

[ "<s>", "const", "LegalizerInfo", "*", "RISCVSubtarget", "::", "getLegalizerInfo", "(", ")", "const", "{", "return", "Legalizer", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "static", "bool", "alpha_split_complex_arg", "(", "const_tree", "type", ")", "{", "return", "TYPE_MODE", "(", "type", ")", "!=", "TCmode", ";", "}", "</s>" ]

[ "TCmode", "complex", "values", "are", "passed", "by", "invisible", "reference", ".", "We", "should", "not", "split", "these", "values", "." ]

[ "alpha" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_SystemZ", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "RetValue", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "RetValue", ")", ";", "InVals", ".", "push_back", "(", "RetValue", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "SystemZ", "SystemZ", "ISD::InputArg", "16", "SystemZ", "0", "1", "0", "2", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE" ]

[]

[ "<s>", "void", "xstormy16_initialize_trampoline", "(", "rtx", "addr", ",", "rtx", "fnaddr", ",", "rtx", "static_chain", ")", "{", "rtx", "reg_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "temp", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "reg_fnaddr", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "reg_addr_mem", ";", "reg_addr_mem", "=", "gen_rtx_MEM", "(", "HImode", ",", "reg_addr", ")", ";", "emit_move_insn", "(", "reg_addr", ",", "addr", ")", ";", "emit_move_insn", "(", "temp", ",", "GEN_INT", "(", "0x3130", "|", "STATIC_CHAIN_REGNUM", ")", ")", ";", "emit_move_insn", "(", "reg_addr_mem", ",", "temp", ")", ";", "emit_insn", "(", "gen_addhi3", "(", "reg_addr", ",", "reg_addr", ",", "const2_rtx", ")", ")", ";", "emit_move_insn", "(", "temp", ",", "static_chain", ")", ";", "emit_move_insn", "(", "reg_addr_mem", ",", "temp", ")", ";", "emit_insn", "(", "gen_addhi3", "(", "reg_addr", ",", "reg_addr", ",", "const2_rtx", ")", ")", ";", "emit_move_insn", "(", "reg_fnaddr", ",", "fnaddr", ")", ";", "emit_move_insn", "(", "temp", ",", "reg_fnaddr", ")", ";", "emit_insn", "(", "gen_andhi3", "(", "temp", ",", "temp", ",", "GEN_INT", "(", "0xFF", ")", ")", ")", ";", "emit_insn", "(", "gen_iorhi3", "(", "temp", ",", "temp", ",", "GEN_INT", "(", "0x0200", ")", ")", ")", ";", "emit_move_insn", "(", "reg_addr_mem", ",", "temp", ")", ";", "emit_insn", "(", "gen_addhi3", "(", "reg_addr", ",", "reg_addr", ",", "const2_rtx", ")", ")", ";", "emit_insn", "(", "gen_lshrhi3", "(", "reg_fnaddr", ",", "reg_fnaddr", ",", "GEN_INT", "(", "8", ")", ")", ")", ";", "emit_move_insn", "(", "reg_addr_mem", ",", "reg_fnaddr", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "ADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "trampoline", ";", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "nested", "function", ";", "STATIC_CHAIN", "is", "an", "RTX", "for", "the", "static", "chain", "value", "that", "should", "be", "passed", "to", "the", "function", "when", "it", "is", "called", "." ]

[ "stormy16", "0x3130", "0xFF", "0x0200", "8" ]

[]

[ "<s>", "bool", "FalkorMarkStridedAccesses", "::", "run", "(", ")", "{", "bool", "MadeChange", "=", "false", ";", "for", "(", "Loop", "*", "I", ":", "LI", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "I", ")", ",", "LE", "=", "df_end", "(", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "AArch64" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "if", "(", "!", "FBB", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AArch64", "::", "B", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "else", "instantiateCondBranch", "(", "MBB", ",", "DL", ",", "TBB", ",", "Cond", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "4", ";", "return", "1", ";", "}", "instantiateCondBranch", "(", "MBB", ",", "DL", ",", "TBB", ",", "Cond", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AArch64", "::", "B", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "8", ";", "return", "2", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"insertBranch must not be told to insert a fallthrough\"", "AArch64::B", "4", "1", "AArch64::B", "8", "2" ]

[]

[ "<s>", "static", "void", "do_load_mask_compare", "(", "const", "machine_mode", "load_mode", ",", "rtx", "diff", ",", "rtx", "cmp_rem", ",", "rtx", "dcond", ",", "rtx", "src1_addr", ",", "rtx", "src2_addr", ",", "rtx", "orig_src1", ",", "rtx", "orig_src2", ")", "{", "HOST_WIDE_INT", "load_mode_size", "=", "GET_MODE_SIZE", "(", "load_mode", ")", ";", "rtx", "shift_amount", "=", "gen_reg_rtx", "(", "word_mode", ")", ";", "rtx", "d1", "=", "gen_reg_rtx", "(", "word_mode", ")", ";", "rtx", "d2", "=", "gen_reg_rtx", "(", "word_mode", ")", ";", "do_load_for_compare_from_addr", "(", "load_mode", ",", "d1", ",", "src1_addr", ",", "orig_src1", ")", ";", "do_load_for_compare_from_addr", "(", "load_mode", ",", "d2", ",", "src2_addr", ",", "orig_src2", ")", ";", "do_sub3", "(", "shift_amount", ",", "GEN_INT", "(", "load_mode_size", ")", ",", "cmp_rem", ")", ";", "if", "(", "word_mode", "==", "DImode", ")", "{", "emit_insn", "(", "gen_ashldi3", "(", "shift_amount", ",", "shift_amount", ",", "GEN_INT", "(", "LOG2_BITS_PER_UNIT", ")", ")", ")", ";", "emit_insn", "(", "gen_lshrdi3", "(", "d1", ",", "d1", ",", "gen_lowpart", "(", "SImode", ",", "shift_amount", ")", ")", ")", ";", "emit_insn", "(", "gen_lshrdi3", "(", "d2", ",", "d2", ",", "gen_lowpart", "(", "SImode", ",", "shift_amount", ")", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_ashlsi3", "(", "shift_amount", ",", "shift_amount", ",", "GEN_INT", "(", "LOG2_BITS_PER_UNIT", ")", ")", ")", ";", "emit_insn", "(", "gen_lshrsi3", "(", "d1", ",", "d1", ",", "shift_amount", ")", ")", ";", "emit_insn", "(", "gen_lshrsi3", "(", "d2", ",", "d2", ",", "shift_amount", ")", ")", ";", "}", "if", "(", "TARGET_P9_MISC", ")", "{", "rtx", "cmp", "=", "gen_rtx_COMPARE", "(", "CCUNSmode", ",", "d1", ",", "d2", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dcond", ",", "cmp", ")", ")", ";", "}", "else", "{", "if", "(", "word_mode", "==", "DImode", ")", "emit_insn", "(", "gen_subfdi3_carry", "(", "diff", ",", "d2", ",", "d1", ")", ")", ";", "else", "emit_insn", "(", "gen_subfsi3_carry", "(", "diff", ",", "d2", ",", "d1", ")", ")", ";", "}", "}", "</s>" ]

[ "Generate", "rtl", "for", "a", "load", ",", "shift", ",", "and", "compare", "of", "less", "than", "a", "full", "word", ".", "LOAD_MODE", "is", "the", "machine", "mode", "for", "the", "loads", ".", "DIFF", "is", "the", "reg", "for", "the", "difference", ".", "CMP_REM", "is", "the", "reg", "containing", "the", "remaining", "bytes", "to", "compare", ".", "DCOND", "is", "the", "CCUNS", "reg", "for", "the", "compare", "if", "we", "are", "doing", "P9", "code", "with", "setb", ".", "SRC1_ADDR", "is", "the", "first", "source", "address", ".", "SRC2_ADDR", "is", "the", "second", "source", "address", ".", "ORIG_SRC1", "is", "the", "original", "first", "source", "block", "'s", "address", "rtx", ".", "ORIG_SRC2", "is", "the", "original", "second", "source", "block", "'s", "address", "rtx", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "SIPeepholeSDWA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasSDWA", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "bool", "Ret", "=", "false", ";", "do", "{", "matchSDWAOperands", "(", "MF", ")", ";", "for", "(", "const", "auto", "&", "OperandPair", ":", "SDWAOperands", ")", "{", "const", "auto", "&", "Operand", "=", "OperandPair", ".", "second", ";", "MachineInstr", "*", "PotentialMI", "=", "Operand", "->", "potentialToConvert", "(", "TII", ")", ";", "if", "(", "PotentialMI", "&&", "isConvertibleToSDWA", "(", "*", "PotentialMI", ",", "ST", ")", ")", "{", "PotentialMatches", "[", "PotentialMI", "]", ".", "push_back", "(", "Operand", ".", "get", "(", ")", ")", ";", "}", "}", "for", "(", "auto", "&", "PotentialPair", ":", "PotentialMatches", ")", "{", "MachineInstr", "&", "PotentialMI", "=", "*", "PotentialPair", ".", "first", ";", "convertToSDWA", "(", "PotentialMI", ",", "PotentialPair", ".", "second", ")", ";", "}", "PotentialMatches", ".", "clear", "(", ")", ";", "SDWAOperands", ".", "clear", "(", ")", ";", "Changed", "=", "!", "ConvertedInstructions", ".", "empty", "(", ")", ";", "if", "(", "Changed", ")", "Ret", "=", "true", ";", "while", "(", "!", "ConvertedInstructions", ".", "empty", "(", ")", ")", "legalizeScalarOperands", "(", "*", "ConvertedInstructions", ".", "pop_back_val", "(", ")", ",", "ST", ")", ";", "}", "while", "(", "Changed", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "MachineModuleInfo", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "MachineModulePass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "void", "PPCPreRASchedStrategy", "::", "tryCandidate", "(", "SchedCandidate", "&", "Cand", ",", "SchedCandidate", "&", "TryCand", ",", "SchedBoundary", "*", "Zone", ")", "const", "{", "GenericScheduler", "::", "tryCandidate", "(", "Cand", ",", "TryCand", ",", "Zone", ")", ";", "if", "(", "!", "Cand", ".", "isValid", "(", ")", "||", "!", "Zone", ")", "return", ";", "if", "(", "TryCand", ".", "Reason", "!=", "NodeOrder", "&&", "TryCand", ".", "Reason", "!=", "NoCand", ")", "return", ";", "if", "(", "biasAddiLoadCandidate", "(", "Cand", ",", "TryCand", ",", "*", "Zone", ")", ")", "return", ";", "}", "</s>" ]

[ "Apply", "a", "set", "of", "heuristics", "to", "a", "new", "candidate", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "avr_cpu_cpp_builtins", "(", "struct", "cpp_reader", "*", "pfile", ")", "{", "int", "i", ";", "builtin_define_std", "(", "\"AVR\"", ")", ";", "if", "(", "avr_arch", "->", "macro", ")", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_ARCH__=%s\"", ",", "avr_arch", "->", "macro", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPD__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPX__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPY", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPY__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPZ", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPZ__\"", ")", ";", "if", "(", "AVR_HAVE_ELPM", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPM__\"", ")", ";", "if", "(", "AVR_HAVE_ELPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPMX__\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MOVW__\"", ")", ";", "if", "(", "AVR_HAVE_LPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_LPMX__\"", ")", ";", "if", "(", "avr_arch", "->", "asm_only", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ASM_ONLY__\"", ")", ";", "if", "(", "AVR_HAVE_MUL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ENHANCED__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MUL__\"", ")", ";", "}", "if", "(", "avr_arch", "->", "have_jmp_call", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_MEGA__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_JMP_CALL__\"", ")", ";", "}", "if", "(", "AVR_XMEGA", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_XMEGA__\"", ")", ";", "if", "(", "AVR_TINY", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_TINY__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x4000\"", ")", ";", "}", "if", "(", "AVR_HAVE_EIJMP_EICALL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_EIJMP_EICALL__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_3_BYTE_PC__\"", ")", ";", "}", "else", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_2_BYTE_PC__\"", ")", ";", "}", "if", "(", "AVR_HAVE_8BIT_SP", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_8BIT_SP__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_16BIT_SP__\"", ")", ";", "if", "(", "AVR_HAVE_SPH", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_SPH__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_SP8__\"", ")", ";", "if", "(", "TARGET_NO_INTERRUPTS", ")", "cpp_define", "(", "pfile", ",", "\"__NO_INTERRUPTS__\"", ")", ";", "if", "(", "TARGET_SKIP_BUG", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP__\"", ")", ";", "if", "(", "AVR_HAVE_JMP_CALL", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", ")", ";", "}", "if", "(", "TARGET_RMW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ISA_RMW__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_SFR_OFFSET__=0x%x\"", ",", "avr_arch", "->", "sfr_offset", ")", ";", "cpp_define", "(", "pfile", ",", "\"__WITH_AVRLIBC__\"", ")", ";", "if", "(", "lang_GNU_C", "(", ")", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", "&&", "avr_addrspace", "[", "i", "]", ".", "segment", "<", "avr_n_flash", "&&", "(", "AVR_HAVE_LPM", "||", "avr_addrspace", "[", "i", "]", ".", "pointer_size", "<=", "2", ")", ")", "{", "const", "char", "*", "name", "=", "avr_addrspace", "[", "i", "]", ".", "name", ";", "char", "*", "Name", "=", "(", "char", "*", ")", "alloca", "(", "1", "+", "strlen", "(", "name", ")", ")", ";", "cpp_define", "(", "pfile", ",", "avr_toupper", "(", "Name", ",", "name", ")", ")", ";", "}", "}", "cpp_define", "(", "pfile", ",", "\"__BUILTIN_AVR_\"", "#", "NAME", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__INT24_MAX__=8388607%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"LL\"", ":", "\"L\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__UINT24_MAX__=16777215%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"ULL\"", ":", "\"UL\"", ")", ";", "}", "</s>" ]

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

[ "avr", "\"AVR\"", "\"__AVR_ARCH__=%s\"", "\"__AVR_HAVE_RAMPD__\"", "\"__AVR_HAVE_RAMPX__\"", "\"__AVR_HAVE_RAMPY__\"", "\"__AVR_HAVE_RAMPZ__\"", "\"__AVR_HAVE_ELPM__\"", "\"__AVR_HAVE_ELPMX__\"", "\"__AVR_HAVE_MOVW__\"", "\"__AVR_HAVE_LPMX__\"", "\"__AVR_ASM_ONLY__\"", "\"__AVR_ENHANCED__\"", "\"__AVR_HAVE_MUL__\"", "\"__AVR_MEGA__\"", "\"__AVR_HAVE_JMP_CALL__\"", "\"__AVR_XMEGA__\"", "\"__AVR_TINY__\"", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x4000\"", "\"__AVR_HAVE_EIJMP_EICALL__\"", "\"__AVR_3_BYTE_PC__\"", "\"__AVR_2_BYTE_PC__\"", "\"__AVR_HAVE_8BIT_SP__\"", "\"__AVR_HAVE_16BIT_SP__\"", "\"__AVR_HAVE_SPH__\"", "\"__AVR_SP8__\"", "\"__NO_INTERRUPTS__\"", "\"__AVR_ERRATA_SKIP__\"", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", "\"__AVR_ISA_RMW__\"", "\"__AVR_SFR_OFFSET__=0x%x\"", "\"__WITH_AVRLIBC__\"", "0", "2", "1", "\"__BUILTIN_AVR_\"", "\"__INT24_MAX__=8388607%s\"", "8", "\"LL\"", "\"L\"", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", "\"__UINT24_MAX__=16777215%s\"", "8", "\"ULL\"", "\"UL\"" ]

[]

[ "<s>", "void", "TGSICFGStructurizer", "::", "removeSuccessor", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "while", "(", "MBB", "->", "succ_size", "(", ")", ")", "MBB", "->", "removeSuccessor", "(", "*", "MBB", "->", "succ_begin", "(", ")", ")", ";", "}", "</s>" ]

[ "Remove", "specified", "successor", "from", "the", "successors", "list", "of", "this", "MachineBasicBlock", "." ]

[ "TGSI", "TGSI" ]

[]