vmm: Fix use-after-free in load_elf()
[akaros.git] / user / perfmon / events / intel_snb_events.h
1 /*
2  * Copyright (c) 2011 Google, Inc
3  * Contributed by Stephane Eranian <eranian@gmail.com>
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a copy
6  * of this software and associated documentation files (the "Software"), to deal
7  * in the Software without restriction, including without limitation the rights
8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9  * of the Software, and to permit persons to whom the Software is furnished to do so,
10  * subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in all
13  * copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
16  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
17  * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
18  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19  * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
20  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * This file is part of libpfm, a performance monitoring support library for
23  * applications on Linux.
24  *
25  * This file has been automatically generated.
26  *
27  * PMU: snb (Intel Sandy Bridge)
28  */
29
30 static const intel_x86_umask_t snb_agu_bypass_cancel[]={
31    { .uname  = "COUNT",
32      .udesc  = "This event counts executed load operations",
33      .ucode = 0x100,
34      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
35    },
36 };
37
38 static const intel_x86_umask_t snb_arith[]={
39    { .uname  = "FPU_DIV_ACTIVE",
40      .udesc  = "Cycles that the divider is active, includes integer and floating point",
41      .ucode = 0x100,
42      .uflags= INTEL_X86_NCOMBO,
43    },
44    { .uname  = "FPU_DIV",
45      .udesc  = "Number of cycles the divider is activated, includes integer and floating point",
46      .uequiv = "FPU_DIV_ACTIVE:c=1:e=1",
47      .ucode = 0x100 | INTEL_X86_MOD_EDGE | (0x1 << INTEL_X86_CMASK_BIT),
48      .uflags= INTEL_X86_NCOMBO,
49    },
50 };
51
52 static const intel_x86_umask_t snb_br_inst_exec[]={
53    { .uname  = "NONTAKEN_COND",
54      .udesc  = "All macro conditional non-taken branch instructions",
55      .ucode = 0x4100,
56      .uflags= INTEL_X86_NCOMBO,
57    },
58    { .uname  = "TAKEN_COND",
59      .udesc  = "All macro conditional taken branch instructions",
60      .ucode = 0x8100,
61      .uflags= INTEL_X86_NCOMBO,
62    },
63    { .uname  = "NONTAKEN_DIRECT_JUMP",
64      .udesc  = "All macro unconditional non-taken branch instructions, excluding calls and indirects",
65      .ucode = 0x4200,
66      .uflags= INTEL_X86_NCOMBO,
67    },
68    { .uname  = "TAKEN_DIRECT_JUMP",
69      .udesc  = "All macro unconditional taken branch instructions, excluding calls and indirects",
70      .ucode = 0x8200,
71      .uflags= INTEL_X86_NCOMBO,
72    },
73    { .uname  = "NONTAKEN_INDIRECT_JUMP_NON_CALL_RET",
74      .udesc  = "All non-taken indirect branches that are not calls nor returns",
75      .ucode = 0x4400,
76      .uflags= INTEL_X86_NCOMBO,
77    },
78    { .uname  = "TAKEN_INDIRECT_JUMP_NON_CALL_RET",
79      .udesc  = "All taken indirect branches that are not calls nor returns",
80      .ucode = 0x8400,
81      .uflags= INTEL_X86_NCOMBO,
82    },
83    { .uname  = "TAKEN_RETURN_NEAR",
84      .udesc  = "All taken indirect branches that have a return mnemonic",
85      .ucode = 0x8800,
86      .uflags= INTEL_X86_NCOMBO,
87    },
88    { .uname  = "TAKEN_DIRECT_NEAR_CALL",
89      .udesc  = "All taken non-indirect calls",
90      .ucode = 0x9000,
91      .uflags= INTEL_X86_NCOMBO,
92    },
93    { .uname  = "TAKEN_INDIRECT_NEAR_CALL",
94      .udesc  = "All taken indirect calls, including both register and memory indirect",
95      .ucode = 0xa000,
96      .uflags= INTEL_X86_NCOMBO,
97    },
98    { .uname  = "ALL_BRANCHES",
99      .udesc  = "All near executed branches instructions (not necessarily retired)",
100      .ucode = 0xff00,
101      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
102    },
103    { .uname  = "ALL_CONDITIONAL",
104      .udesc  = "All macro conditional branch instructions",
105      .ucode = 0xc100,
106      .uflags= INTEL_X86_NCOMBO,
107    },
108
109    { .uname  = "ANY_COND",
110      .udesc  = "All macro conditional branch instructions",
111      .ucode = 0xc100,
112      .uequiv = "ALL_CONDITIONAL",
113      .uflags= INTEL_X86_NCOMBO,
114    },
115    { .uname  = "ANY_INDIRECT_JUMP_NON_CALL_RET",
116      .udesc  = "All indirect branches that are not calls nor returns",
117      .ucode = 0xc400,
118      .uflags= INTEL_X86_NCOMBO,
119    },
120    { .uname  = "ANY_DIRECT_NEAR_CALL",
121      .udesc  = "All non-indirect calls",
122      .ucode = 0xd000,
123      .uflags= INTEL_X86_NCOMBO,
124    },
125 };
126
127 static const intel_x86_umask_t snb_br_inst_retired[]={
128    { .uname  = "ALL_BRANCHES",
129      .udesc  = "All taken and not taken macro branches including far branches (Precise Event)",
130      .ucode = 0x400,
131      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS | INTEL_X86_DFL,
132    },
133    { .uname  = "CONDITIONAL",
134      .udesc  = "All taken and not taken macro conditional branch instructions (Precise Event)",
135      .ucode = 0x100,
136      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
137    },
138    { .uname  = "FAR_BRANCH",
139      .udesc  = "Number of far branch instructions retired (Precise Event)",
140      .ucode = 0x4000,
141      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
142    },
143    { .uname  = "NEAR_CALL",
144      .udesc  = "All macro direct and indirect near calls, does not count far calls (Precise Event)",
145      .ucode = 0x200,
146      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
147    },
148    { .uname  = "NEAR_RETURN",
149      .udesc  = "Number of near ret instructions retired (Precise Event)",
150      .ucode = 0x800,
151      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
152    },
153    { .uname  = "NEAR_TAKEN",
154      .udesc  = "Number of near branch taken instructions retired (Precise Event)",
155      .ucode = 0x2000,
156      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
157    },
158    { .uname  = "NOT_TAKEN",
159      .udesc  = "All not taken macro branch instructions retired (Precise Event)",
160      .ucode = 0x1000,
161      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
162    },
163 };
164
165 static const intel_x86_umask_t snb_br_misp_exec[]={
166    { .uname  = "NONTAKEN_COND",
167      .udesc  = "All non-taken mispredicted macro conditional branch instructions",
168      .ucode = 0x4100,
169      .uflags= INTEL_X86_NCOMBO,
170    },
171    { .uname  = "TAKEN_COND",
172      .udesc  = "All taken mispredicted macro conditional branch instructions",
173      .ucode = 0x8100,
174      .uflags= INTEL_X86_NCOMBO,
175    },
176    { .uname  = "NONTAKEN_INDIRECT_JUMP_NON_CALL_RET",
177      .udesc  = "All non-taken mispredicted indirect branches that are not calls nor returns",
178      .ucode = 0x4400,
179      .uflags= INTEL_X86_NCOMBO,
180    },
181    { .uname  = "TAKEN_INDIRECT_JUMP_NON_CALL_RET",
182      .udesc  = "All taken mispredicted indirect branches that are not calls nor returns",
183      .ucode = 0x8400,
184      .uflags= INTEL_X86_NCOMBO,
185    },
186    { .uname  = "NONTAKEN_RETURN_NEAR",
187      .udesc  = "All non-taken mispredicted indirect branches that have a return mnemonic",
188      .ucode = 0x4800,
189      .uflags= INTEL_X86_NCOMBO,
190    },
191    { .uname  = "TAKEN_RETURN_NEAR",
192      .udesc  = "All taken mispredicted indirect branches that have a return mnemonic",
193      .ucode = 0x8800,
194      .uflags= INTEL_X86_NCOMBO,
195    },
196    { .uname  = "NONTAKEN_DIRECT_NEAR_CALL",
197      .udesc  = "All non-taken mispredicted non-indirect calls",
198      .ucode = 0x5000,
199      .uflags= INTEL_X86_NCOMBO,
200    },
201    { .uname  = "TAKEN_DIRECT_NEAR_CALL",
202      .udesc  = "All taken mispredicted non-indirect calls",
203      .ucode = 0x9000,
204      .uflags= INTEL_X86_NCOMBO,
205    },
206    { .uname  = "NONTAKEN_INDIRECT_NEAR_CALL",
207      .udesc  = "All nontaken mispredicted indirect calls, including both register and memory indirect",
208      .ucode = 0x6000,
209      .uflags= INTEL_X86_NCOMBO,
210    },
211    { .uname  = "TAKEN_INDIRECT_NEAR_CALL",
212      .udesc  = "All taken mispredicted indirect calls, including both register and memory indirect",
213      .ucode = 0xa000,
214      .uflags= INTEL_X86_NCOMBO,
215    },
216    { .uname  = "ANY_COND",
217      .udesc  = "All mispredicted macro conditional branch instructions",
218      .ucode = 0xc100,
219      .uflags= INTEL_X86_NCOMBO,
220    },
221    { .uname  = "ANY_RETURN_NEAR",
222      .udesc  = "All mispredicted indirect branches that have a return mnemonic",
223      .ucode = 0xc800,
224      .uflags= INTEL_X86_NCOMBO,
225    },
226    { .uname  = "ANY_DIRECT_NEAR_CALL",
227      .udesc  = "All mispredicted non-indirect calls",
228      .ucode = 0xd000,
229      .uflags= INTEL_X86_NCOMBO,
230    },
231    { .uname  = "ANY_INDIRECT_JUMP_NON_CALL_RET",
232      .udesc  = "All mispredicted indirect branches that are not calls nor returns",
233      .ucode = 0xc400,
234      .uflags= INTEL_X86_NCOMBO,
235    },
236    { .uname  = "ALL_BRANCHES",
237      .udesc  = "All mispredicted branch instructions",
238      .ucode = 0xff00,
239      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
240    },
241 };
242
243 static const intel_x86_umask_t snb_br_misp_retired[]={
244    { .uname  = "ALL_BRANCHES",
245      .udesc  = "All mispredicted macro branches (Precise Event)",
246      .ucode = 0x400,
247      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS | INTEL_X86_DFL,
248    },
249    { .uname  = "CONDITIONAL",
250      .udesc  = "All mispredicted macro conditional branch instructions (Precise Event)",
251      .ucode = 0x100,
252      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
253    },
254    { .uname  = "NEAR_CALL",
255      .udesc  = "All macro direct and indirect near calls (Precise Event)",
256      .ucode = 0x200,
257      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
258    },
259    { .uname  = "NOT_TAKEN",
260      .udesc  = "Number of branch instructions retired that were mispredicted and not-taken (Precise Event)",
261      .ucode = 0x1000,
262      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
263    },
264    { .uname  = "TAKEN",
265      .udesc  = "Number of branch instructions retired that were mispredicted and taken (Precise Event)",
266      .ucode = 0x2000,
267      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
268    },
269 };
270
271 static const intel_x86_umask_t snb_lock_cycles[]={
272    { .uname  = "SPLIT_LOCK_UC_LOCK_DURATION",
273      .udesc  = "Cycles in which the L1D and L2 are locked, due to a UC lock or split lock",
274      .ucode = 0x100,
275      .uflags= INTEL_X86_NCOMBO,
276    },
277    { .uname  = "CACHE_LOCK_DURATION",
278      .udesc  = "Cycles in which the L1D is locked",
279      .ucode = 0x200,
280      .uflags= INTEL_X86_NCOMBO,
281    },
282 };
283
284 static const intel_x86_umask_t snb_cpl_cycles[]={
285    { .uname  = "RING0",
286      .udesc  = "Unhalted core cycles the thread was in ring 0",
287      .ucode = 0x100,
288      .uflags= INTEL_X86_NCOMBO,
289    },
290    { .uname  = "RING0_TRANS",
291      .udesc  = "Transitions from rings 1, 2, or 3 to ring 0",
292      .uequiv = "RING0:c=1:e=1",
293      .ucode = 0x100 | INTEL_X86_MOD_EDGE | (0x1 << INTEL_X86_CMASK_BIT),
294      .uflags= INTEL_X86_NCOMBO,
295    },
296    { .uname  = "RING123",
297      .udesc  = "Unhalted core cycles the thread was in rings 1, 2, or 3",
298      .ucode = 0x200,
299      .uflags= INTEL_X86_NCOMBO,
300    },
301 };
302
303 static const intel_x86_umask_t snb_cpu_clk_unhalted[]={
304    { .uname  = "REF_P",
305      .udesc  = "Cycles when the core is unhalted (count at 100 Mhz)",
306      .ucode = 0x100,
307      .uflags= INTEL_X86_NCOMBO,
308    },
309    { .uname  = "THREAD_P",
310      .udesc  = "Cycles when thread is not halted",
311      .ucode = 0x0,
312      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
313    },
314 };
315
316 static const intel_x86_umask_t snb_dsb2mite_switches[]={
317    { .uname  = "COUNT",
318      .udesc  = "Number of DSB to MITE switches",
319      .ucode = 0x100,
320      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
321    },
322    { .uname  = "PENALTY_CYCLES",
323      .udesc  = "Cycles SB to MITE switches caused delay",
324      .ucode = 0x200,
325      .uflags= INTEL_X86_NCOMBO,
326    },
327 };
328
329 static const intel_x86_umask_t snb_dsb_fill[]={
330    { .uname  = "ALL_CANCEL",
331      .udesc  = "Number of times a valid DSB fill has been cancelled for any reason",
332      .ucode = 0xa00,
333      .uflags= INTEL_X86_NCOMBO,
334    },
335    { .uname  = "EXCEED_DSB_LINES",
336      .udesc  = "DSB Fill encountered > 3 DSB lines",
337      .ucode = 0x800,
338      .uflags= INTEL_X86_NCOMBO,
339    },
340    { .uname  = "OTHER_CANCEL",
341      .udesc  = "Number of times a valid DSB fill has been cancelled not because of exceeding way limit",
342      .ucode = 0x200,
343      .uflags= INTEL_X86_NCOMBO,
344    },
345 };
346
347 static const intel_x86_umask_t snb_dtlb_load_misses[]={
348    { .uname  = "MISS_CAUSES_A_WALK",
349      .udesc  = "Demand load miss in all TLB levels which causes an page walk of any page size",
350      .ucode = 0x100,
351      .uflags= INTEL_X86_NCOMBO,
352    },
353    { .uname  = "CAUSES_A_WALK",
354      .udesc  = "Demand load miss in all TLB levels which causes an page walk of any page size",
355      .ucode = 0x100,
356      .uequiv = "MISS_CAUSES_A_WALK",
357      .uflags= INTEL_X86_NCOMBO,
358    },
359    { .uname  = "STLB_HIT",
360      .udesc  = "Number of DTLB lookups for loads which missed first level DTLB but hit second level DTLB (STLB); No page walk.",
361      .ucode = 0x1000,
362      .uflags= INTEL_X86_NCOMBO,
363    },
364    { .uname  = "WALK_COMPLETED",
365      .udesc  = "Demand load miss in all TLB levels which causes a page walk that completes for any page size",
366      .ucode = 0x200,
367      .uflags= INTEL_X86_NCOMBO,
368    },
369    { .uname  = "WALK_DURATION",
370      .udesc  = "Cycles PMH is busy with a walk",
371      .ucode = 0x400,
372      .uflags= INTEL_X86_NCOMBO,
373    },
374 };
375
376 static const intel_x86_umask_t snb_dtlb_store_misses[]={
377    { .uname  = "MISS_CAUSES_A_WALK",
378      .udesc  = "Miss in all TLB levels that causes a page walk of any page size (4K/2M/4M/1G)",
379      .ucode = 0x100,
380      .uflags= INTEL_X86_NCOMBO,
381    },
382    { .uname  = "CAUSES_A_WALK",
383      .udesc  = "Miss in all TLB levels that causes a page walk of any page size (4K/2M/4M/1G)",
384      .ucode = 0x100,
385      .uequiv = "MISS_CAUSES_A_WALK",
386      .uflags= INTEL_X86_NCOMBO,
387    },
388    { .uname  = "STLB_HIT",
389      .udesc  = "First level miss but second level hit; no page walk. Only relevant if multiple levels",
390      .ucode = 0x1000,
391      .uflags= INTEL_X86_NCOMBO,
392    },
393    { .uname  = "WALK_COMPLETED",
394      .udesc  = "Miss in all TLB levels that causes a page walk that completes of any page size (4K/2M/4M/1G)",
395      .ucode = 0x200,
396      .uflags= INTEL_X86_NCOMBO,
397    },
398    { .uname  = "WALK_DURATION",
399      .udesc  = "Cycles PMH is busy with this walk",
400      .ucode = 0x400,
401      .uflags= INTEL_X86_NCOMBO,
402    },
403 };
404
405 static const intel_x86_umask_t snb_fp_assist[]={
406    { .uname  = "ANY",
407      .udesc  = "Cycles with any input/output SSE or FP assists",
408      .ucode = 0x1e00,
409      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
410    },
411    { .uname  = "SIMD_INPUT",
412      .udesc  = "Number of SIMD FP assists due to input values",
413      .ucode = 0x1000,
414      .uflags= INTEL_X86_NCOMBO,
415    },
416    { .uname  = "SIMD_OUTPUT",
417      .udesc  = "Number of SIMD FP assists due to output values",
418      .ucode = 0x800,
419      .uflags= INTEL_X86_NCOMBO,
420    },
421    { .uname  = "X87_INPUT",
422      .udesc  = "Number of X87 assists due to input value",
423      .ucode = 0x400,
424      .uflags= INTEL_X86_NCOMBO,
425    },
426    { .uname  = "X87_OUTPUT",
427      .udesc  = "Number of X87 assists due to output value",
428      .ucode = 0x200,
429      .uflags= INTEL_X86_NCOMBO,
430    },
431 };
432
433 static const intel_x86_umask_t snb_fp_comp_ops_exe[]={
434    { .uname  = "X87",
435      .udesc  = "Number of X87 uops executed",
436      .ucode = 0x100,
437      .uflags= INTEL_X86_NCOMBO,
438    },
439    { .uname  = "SSE_FP_PACKED_DOUBLE",
440      .udesc  = "Number of SSE double precision FP packed uops executed",
441      .ucode = 0x1000,
442      .uflags= INTEL_X86_NCOMBO,
443    },
444    { .uname  = "SSE_FP_SCALAR_SINGLE",
445      .udesc  = "Number of SSE single precision FP scalar uops executed",
446      .ucode = 0x2000,
447      .uflags= INTEL_X86_NCOMBO,
448    },
449    { .uname  = "SSE_PACKED_SINGLE",
450      .udesc  = "Number of SSE single precision FP packed uops executed",
451      .ucode = 0x4000,
452      .uflags= INTEL_X86_NCOMBO,
453    },
454    { .uname  = "SSE_SCALAR_DOUBLE",
455      .udesc  = "Number of SSE double precision FP scalar uops executed",
456      .ucode = 0x8000,
457      .uflags= INTEL_X86_NCOMBO,
458    },
459 };
460
461 static const intel_x86_umask_t snb_hw_interrupts[]={
462    { .uname  = "RECEIVED",
463      .udesc  = "Number of hardware interrupts received by the processor",
464      .ucode = 0x100,
465      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
466    },
467 };
468
469 static const intel_x86_umask_t snb_hw_pre_req[]={
470    { .uname  = "L1D_MISS",
471      .udesc  = "Hardware prefetch requests that misses the L1D cache. A request is counted each time it accesses the cache and misses it, including if a block is applicable or if it hits the full buffer, for example. This accounts for both L1 streamer and IP-based Hw prefetchers",
472      .ucode = 0x200,
473      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
474    },
475 };
476
477 static const intel_x86_umask_t snb_icache[]={
478    { .uname  = "MISSES",
479      .udesc  = "Number of Instruction Cache, Streaming Buffer and Victim Cache Misses. Includes UC accesses",
480      .ucode = 0x200,
481      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
482    },
483 };
484
485 static const intel_x86_umask_t snb_idq[]={
486    { .uname  = "EMPTY",
487      .udesc  = "Cycles IDQ is empty",
488      .ucode = 0x200,
489      .uflags= INTEL_X86_NCOMBO,
490    },
491    { .uname  = "MITE_UOPS",
492      .udesc  = "Number of uops delivered to IDQ from MITE path",
493      .ucode = 0x400,
494      .uflags= INTEL_X86_NCOMBO,
495    },
496    { .uname  = "DSB_UOPS",
497      .udesc  = "Number of uops delivered to IDQ from DSB path",
498      .ucode = 0x800,
499      .uflags= INTEL_X86_NCOMBO,
500    },
501    { .uname  = "MS_DSB_UOPS",
502      .udesc  = "Number of uops delivered to IDQ when MS busy by DSB",
503      .ucode = 0x1000,
504      .uflags= INTEL_X86_NCOMBO,
505    },
506    { .uname  = "MS_MITE_UOPS",
507      .udesc  = "Number of uops delivered to IDQ when MS busy by MITE",
508      .ucode = 0x2000,
509      .uflags= INTEL_X86_NCOMBO,
510    },
511    { .uname  = "MS_UOPS",
512      .udesc  = "Number of uops were delivered to IDQ from MS by either DSB or MITE",
513      .ucode = 0x3000,
514      .uflags= INTEL_X86_NCOMBO,
515    },
516    { .uname  = "MITE_UOPS_CYCLES",
517      .udesc  = "Cycles where uops are delivered to IDQ from MITE (MITE active)",
518      .uequiv = "MITE_UOPS:c=1",
519      .ucode = 0x400 | (0x1 << INTEL_X86_CMASK_BIT),
520      .uflags= INTEL_X86_NCOMBO,
521    },
522    { .uname  = "DSB_UOPS_CYCLES",
523      .udesc  = "Cycles where uops are delivered to IDQ from DSB (DSB active)",
524      .ucode = 0x800 | (0x1 << INTEL_X86_CMASK_BIT),
525      .modhw = _INTEL_X86_ATTR_C,
526      .uflags= INTEL_X86_NCOMBO,
527    },
528    { .uname  = "MS_DSB_UOPS_CYCLES",
529      .udesc  = "Cycles where uops delivered to IDQ when MS busy by DSB",
530      .uequiv = "MS_DSB_UOPS:c=1",
531      .ucode = 0x1000 | (0x1 << INTEL_X86_CMASK_BIT),
532      .uflags= INTEL_X86_NCOMBO,
533    },
534    { .uname  = "MS_MITE_UOPS_CYCLES",
535      .udesc  = "Cycles where uops delivered to IDQ when MS busy by MITE",
536      .uequiv = "MS_MITE_UOPS:c=1",
537      .ucode = 0x2000 | (0x1 << INTEL_X86_CMASK_BIT),
538      .uflags= INTEL_X86_NCOMBO,
539    },
540    { .uname  = "MS_UOPS_CYCLES",
541      .udesc  = "Cycles where uops delivered to IDQ from MS by either BSD or MITE",
542      .uequiv = "MS_UOPS:c=1",
543      .ucode = 0x3000 | (0x1 << INTEL_X86_CMASK_BIT),
544      .uflags= INTEL_X86_NCOMBO,
545    },
546    { .uname  = "ALL_DSB_UOPS",
547      .udesc  = "Number of uops deliver from either DSB paths",
548      .ucode = 0x1800,
549      .uflags= INTEL_X86_NCOMBO,
550    },
551    { .uname  = "ALL_DSB_CYCLES",
552      .udesc  = "Cycles MITE/MS deliver anything",
553      .ucode = 0x1800 | (0x1 << INTEL_X86_CMASK_BIT),
554      .modhw = _INTEL_X86_ATTR_C,
555      .uflags= INTEL_X86_NCOMBO,
556    },
557    { .uname  = "ALL_MITE_UOPS",
558      .udesc  = "Number of uops delivered from either MITE paths",
559      .ucode = 0x2400,
560      .uflags= INTEL_X86_NCOMBO,
561    },
562    { .uname  = "ALL_MITE_CYCLES",
563      .udesc  = "Cycles DSB/MS deliver anything",
564      .ucode = 0x2400 | (0x1 << INTEL_X86_CMASK_BIT),
565      .modhw = _INTEL_X86_ATTR_C,
566      .uflags= INTEL_X86_NCOMBO,
567    },
568    { .uname  = "ANY_UOPS",
569      .udesc  = "Number of uops delivered to IDQ from any path",
570      .ucode = 0x3c00,
571      .uflags= INTEL_X86_NCOMBO,
572    },
573    { .uname  = "MS_DSB_UOPS_OCCUR",
574      .udesc  = "Occurrences of DSB MS going active",
575      .uequiv = "MS_DSB_UOPS:c=1:e=1",
576      .ucode = 0x1000 | INTEL_X86_MOD_EDGE | (0x1 << INTEL_X86_CMASK_BIT),
577      .uflags= INTEL_X86_NCOMBO,
578    },
579 };
580
581 static const intel_x86_umask_t snb_idq_uops_not_delivered[]={
582    { .uname  = "CORE",
583      .udesc  = "Number of non-delivered uops to RAT (use cmask to qualify further)",
584      .ucode = 0x100,
585      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
586    },
587 };
588
589 static const intel_x86_umask_t snb_ild_stall[]={
590    { .uname  = "LCP",
591      .udesc  = "Stall caused by changing prefix length of the instruction",
592      .ucode = 0x100,
593      .uflags= INTEL_X86_NCOMBO,
594    },
595    { .uname  = "IQ_FULL",
596      .udesc  = "Stall cycles due to IQ full",
597      .ucode = 0x400,
598      .uflags= INTEL_X86_NCOMBO,
599    },
600 };
601
602 static const intel_x86_umask_t snb_insts_written_to_iq[]={
603    { .uname  = "INSTS",
604      .udesc  = "Number of instructions written to IQ every cycle",
605      .ucode = 0x100,
606      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
607    },
608 };
609
610 static const intel_x86_umask_t snb_inst_retired[]={
611    { .uname  = "ANY_P",
612      .udesc  = "Number of instructions retired",
613      .ucode = 0x0,
614      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
615    },
616    { .uname  = "PREC_DIST",
617      .udesc  = "Precise instruction retired event to reduce effect of PEBS shadow IP distribution (Precise Event)",
618      .ucntmsk = 0x2,
619      .ucode = 0x100,
620      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
621    },
622 };
623
624 static const intel_x86_umask_t snb_int_misc[]={
625    { .uname  = "RAT_STALL_CYCLES",
626      .udesc  = "Cycles RAT external stall is sent to IDQ for this thread",
627      .ucode = 0x4000,
628      .uflags= INTEL_X86_NCOMBO,
629    },
630    { .uname  = "RECOVERY_CYCLES",
631      .udesc  = "Cycles waiting to be recovered after Machine Clears due to all other cases except JEClear",
632      .ucode = 0x300 | (0x1 << INTEL_X86_CMASK_BIT),
633      .modhw = _INTEL_X86_ATTR_C,
634      .uflags= INTEL_X86_NCOMBO,
635    },
636    { .uname  = "RECOVERY_STALLS_COUNT",
637      .udesc  = "Number of times need to wait after Machine Clears due to all other cases except JEClear",
638      .ucode = 0x300 | INTEL_X86_MOD_EDGE | (0x1 << INTEL_X86_CMASK_BIT),
639      .modhw = _INTEL_X86_ATTR_E | _INTEL_X86_ATTR_C,
640      .uflags= INTEL_X86_NCOMBO,
641    },
642 };
643
644 static const intel_x86_umask_t snb_itlb[]={
645    { .uname  = "ITLB_FLUSH",
646      .udesc  = "Number of ITLB flushes, includes 4k/2M/4M pages",
647      .ucode = 0x100,
648      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
649    },
650    { .uname  = "FLUSH",
651      .udesc  = "Number of ITLB flushes, includes 4k/2M/4M pages",
652      .ucode = 0x100,
653      .uequiv = "ITLB_FLUSH",
654      .uflags= INTEL_X86_NCOMBO,
655    },
656 };
657
658 static const intel_x86_umask_t snb_l1d[]={
659    { .uname  = "ALLOCATED_IN_M",
660      .udesc  = "Number of allocations of L1D cache lines in modified (M) state",
661      .ucode = 0x200,
662      .uflags= INTEL_X86_NCOMBO,
663    },
664    { .uname  = "ALL_M_REPLACEMENT",
665      .udesc  = "Number of cache lines in M-state evicted of L1D due to snoop HITM or dirty line replacement",
666      .ucode = 0x800,
667      .uflags= INTEL_X86_NCOMBO,
668    },
669    { .uname  = "M_EVICT",
670      .udesc  = "Number of modified lines evicted from L1D due to replacement",
671      .ucode = 0x400,
672      .uflags= INTEL_X86_NCOMBO,
673    },
674    { .uname  = "REPLACEMENT",
675      .udesc  = "Number of cache lines brought into the L1D cache",
676      .ucode = 0x100,
677      .uflags= INTEL_X86_NCOMBO,
678    },
679 };
680
681 static const intel_x86_umask_t snb_l1d_blocks[]={
682    { .uname  = "BANK_CONFLICT",
683      .udesc  = "Number of dispatched loads cancelled due to L1D bank conflicts with other load ports",
684      .ucode = 0x100,
685      .uflags= INTEL_X86_NCOMBO,
686    },
687    { .uname  = "BANK_CONFLICT_CYCLES",
688      .udesc  = "Cycles with l1d blocks due to bank conflicts",
689      .ucode = 0x500,
690      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
691    },
692 };
693
694 static const intel_x86_umask_t snb_l1d_pend_miss[]={
695    { .uname  = "OCCURRENCES",
696      .udesc  = "Occurrences of L1D_PEND_MISS going active",
697      .uequiv = "PENDING:e=1:c=1",
698      .ucode = 0x100 | INTEL_X86_MOD_EDGE | (0x1 << INTEL_X86_CMASK_BIT),
699      .uflags= INTEL_X86_NCOMBO,
700    },
701    { .uname  = "EDGE",
702      .udesc  = "Occurrences of L1D_PEND_MISS going active",
703      .uequiv = "OCCURRENCES",
704      .ucode = 0x100 | INTEL_X86_MOD_EDGE | (0x1 << INTEL_X86_CMASK_BIT),
705      .uflags= INTEL_X86_NCOMBO,
706    },
707    { .uname  = "PENDING",
708      .udesc  = "Number of L1D load misses outstanding every cycle",
709      .ucode = 0x100,
710      .uflags= INTEL_X86_NCOMBO,
711    },
712    { .uname  = "PENDING_CYCLES",
713      .udesc  = "Cycles with L1D load misses outstanding",
714      .uequiv = "PENDING:c=1",
715      .ucode = 0x100 | (0x1 << INTEL_X86_CMASK_BIT),
716      .uflags= INTEL_X86_NCOMBO,
717    },
718 };
719
720 static const intel_x86_umask_t snb_l2_l1d_wb_rqsts[]={
721    { .uname  = "HIT_E",
722      .udesc  = "Non rejected writebacks from L1D to L2 cache lines in E state",
723      .ucode = 0x400,
724      .uflags= INTEL_X86_NCOMBO,
725    },
726    { .uname  = "HIT_M",
727      .udesc  = "Non rejected writebacks from L1D to L2 cache lines in M state",
728      .ucode = 0x800,
729      .uflags= INTEL_X86_NCOMBO,
730    },
731 };
732
733 static const intel_x86_umask_t snb_l2_lines_in[]={
734    { .uname  = "ANY",
735      .udesc  = "L2 cache lines filling (counting does not cover rejects)",
736      .ucode = 0x700,
737      .uflags= INTEL_X86_NCOMBO,
738    },
739    { .uname  = "E",
740      .udesc  = "L2 cache lines in E state (counting does not cover rejects)",
741      .ucode = 0x400,
742      .uflags= INTEL_X86_NCOMBO,
743    },
744    { .uname  = "I",
745      .udesc  = "L2 cache lines in I state (counting does not cover rejects)",
746      .ucode = 0x100,
747      .uflags= INTEL_X86_NCOMBO,
748    },
749    { .uname  = "S",
750      .udesc  = "L2 cache lines in S state (counting does not cover rejects)",
751      .ucode = 0x200,
752      .uflags= INTEL_X86_NCOMBO,
753    },
754 };
755
756 static const intel_x86_umask_t snb_l2_lines_out[]={
757    { .uname  = "DEMAND_CLEAN",
758      .udesc  = "L2 clean line evicted by a demand",
759      .ucode = 0x100,
760      .uflags= INTEL_X86_NCOMBO,
761    },
762    { .uname  = "DEMAND_DIRTY",
763      .udesc  = "L2 dirty line evicted by a demand",
764      .ucode = 0x200,
765      .uflags= INTEL_X86_NCOMBO,
766    },
767    { .uname  = "PREFETCH_CLEAN",
768      .udesc  = "L2 clean line evicted by a prefetch",
769      .ucode = 0x400,
770      .uflags= INTEL_X86_NCOMBO,
771    },
772    { .uname  = "PREFETCH_DIRTY",
773      .udesc  = "L2 dirty line evicted by an MLC Prefetch",
774      .ucode = 0x800,
775      .uflags= INTEL_X86_NCOMBO,
776    },
777    { .uname  = "DIRTY_ANY",
778      .udesc  = "Any L2 dirty line evicted (does not cover rejects)",
779      .ucode = 0xa00,
780      .uflags= INTEL_X86_NCOMBO,
781    },
782 };
783
784 static const intel_x86_umask_t snb_l2_rqsts[]={
785    { .uname  = "ALL_CODE_RD",
786      .udesc  = "Any ifetch request to L2 cache",
787      .ucode = 0x3000,
788      .uflags= INTEL_X86_NCOMBO,
789    },
790    { .uname  = "CODE_RD_HIT",
791      .udesc  = "L2 cache hits when fetching instructions",
792      .ucode = 0x1000,
793      .uflags= INTEL_X86_NCOMBO,
794    },
795    { .uname  = "CODE_RD_MISS",
796      .udesc  = "L2 cache misses when fetching instructions",
797      .ucode = 0x2000,
798      .uflags= INTEL_X86_NCOMBO,
799    },
800    { .uname  = "ALL_DEMAND_DATA_RD",
801      .udesc  = "Demand  data read requests to L2 cache",
802      .ucode = 0x300,
803      .uflags= INTEL_X86_NCOMBO,
804    },
805    { .uname  = "ALL_DEMAND_RD_HIT",
806      .udesc  = "Demand data read requests that hit L2",
807      .ucode = 0x100,
808      .uflags= INTEL_X86_NCOMBO,
809    },
810    { .uname  = "ALL_PF",
811      .udesc  = "Any L2 HW prefetch request to L2 cache",
812      .ucode = 0xc000,
813      .uflags= INTEL_X86_NCOMBO,
814    },
815    { .uname  = "PF_HIT",
816      .udesc  = "Requests from the L2 hardware prefetchers that hit L2 cache",
817      .ucode = 0x4000,
818      .uflags= INTEL_X86_NCOMBO,
819    },
820    { .uname  = "PF_MISS",
821      .udesc  = "Requests from the L2 hardware prefetchers that miss L2 cache",
822      .ucode = 0x8000,
823      .uflags= INTEL_X86_NCOMBO,
824    },
825    { .uname  = "RFO_ANY",
826      .udesc  = "Any RFO requests to L2 cache",
827      .ucode = 0xc00,
828      .uflags= INTEL_X86_NCOMBO,
829    },
830    { .uname  = "RFO_HITS",
831      .udesc  = "RFO requests that hit L2 cache",
832      .ucode = 0x400,
833      .uflags= INTEL_X86_NCOMBO,
834    },
835    { .uname  = "RFO_MISS",
836      .udesc  = "RFO requests that miss L2 cache",
837      .ucode = 0x800,
838      .uflags= INTEL_X86_NCOMBO,
839    },
840 };
841
842 static const intel_x86_umask_t snb_l2_store_lock_rqsts[]={
843    { .uname  = "HIT_E",
844      .udesc  = "RFOs that hit cache lines in E state",
845      .ucode = 0x400,
846      .uflags= INTEL_X86_NCOMBO,
847    },
848    { .uname  = "MISS",
849      .udesc  = "RFOs that miss cache (I state)",
850      .ucode = 0x100,
851      .uflags= INTEL_X86_NCOMBO,
852    },
853    { .uname  = "HIT_M",
854      .udesc  = "RFOs that hit cache lines in M state",
855      .ucode = 0x800,
856      .uflags= INTEL_X86_NCOMBO,
857    },
858    { .uname  = "ALL",
859      .udesc  = "RFOs that access cache lines in any state",
860      .ucode = 0xf00,
861      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
862    },
863 };
864
865 static const intel_x86_umask_t snb_l2_trans[]={
866    { .uname  = "ALL",
867      .udesc  = "Transactions accessing MLC pipe",
868      .ucode = 0x8000,
869      .uflags= INTEL_X86_NCOMBO,
870    },
871    { .uname  = "CODE_RD",
872      .udesc  = "L2 cache accesses when fetching instructions",
873      .ucode = 0x400,
874      .uflags= INTEL_X86_NCOMBO,
875    },
876    { .uname  = "L1D_WB",
877      .udesc  = "L1D writebacks that access L2 cache",
878      .ucode = 0x1000,
879      .uflags= INTEL_X86_NCOMBO,
880    },
881    { .uname  = "LOAD",
882      .udesc  = "Demand Data Read* requests that access L2 cache",
883      .ucode = 0x100,
884      .uflags= INTEL_X86_NCOMBO,
885    },
886    { .uname  = "L2_FILL",
887      .udesc  = "L2 fill requests that access L2 cache",
888      .ucode = 0x2000,
889      .uflags= INTEL_X86_NCOMBO,
890    },
891    { .uname  = "L2_WB",
892      .udesc  = "L2 writebacks that access L2 cache",
893      .ucode = 0x4000,
894      .uflags= INTEL_X86_NCOMBO,
895    },
896    { .uname  = "ALL_PREFETCH",
897      .udesc  = "L2 or L3 HW prefetches that access L2 cache (including rejects)",
898      .ucode = 0x800,
899      .uflags= INTEL_X86_NCOMBO,
900    },
901    { .uname  = "RFO",
902      .udesc  = "RFO requests that access L2 cache",
903      .ucode = 0x200,
904      .uflags= INTEL_X86_NCOMBO,
905    },
906 };
907
908 static const intel_x86_umask_t snb_ld_blocks[]={
909    { .uname  = "DATA_UNKNOWN",
910      .udesc  = "Blocked loads due to store buffer blocks with unknown data",
911      .ucode = 0x100,
912      .uflags= INTEL_X86_NCOMBO,
913    },
914    { .uname  = "STORE_FORWARD",
915      .udesc  = "Loads blocked by overlapping with store buffer that cannot be forwarded",
916      .ucode = 0x200,
917      .uflags= INTEL_X86_NCOMBO,
918    },
919    { .uname  = "NO_SR",
920      .udesc  = "Number of split loads blocked due to resource not available",
921      .ucode = 0x800,
922      .uflags= INTEL_X86_NCOMBO,
923    },
924    { .uname  = "ALL_BLOCK",
925      .udesc  = "Number of cases where any load is blocked but has not DCU miss",
926      .ucode = 0x1000,
927      .uflags= INTEL_X86_NCOMBO,
928    },
929 };
930
931 static const intel_x86_umask_t snb_ld_blocks_partial[]={
932    { .uname  = "ADDRESS_ALIAS",
933      .udesc  = "False dependencies in MOB due to partial compare on address",
934      .ucode = 0x100,
935      .uflags= INTEL_X86_NCOMBO,
936    },
937    { .uname  = "ALL_STA_BLOCK",
938      .udesc  = "Number of times that load operations are temporarily blocked because of older stores, with addresses that are not yet known. A load operation may incur more than one block of this type",
939      .ucode = 0x800,
940      .uflags= INTEL_X86_NCOMBO,
941    },
942 };
943
944 static const intel_x86_umask_t snb_load_hit_pre[]={
945    { .uname  = "HW_PF",
946      .udesc  = "Non sw-prefetch load dispatches that hit the fill buffer allocated for HW prefetch",
947      .ucode = 0x200,
948      .uflags= INTEL_X86_NCOMBO,
949    },
950    { .uname  = "SW_PF",
951      .udesc  = "Non sw-prefetch load dispatches that hit the fill buffer allocated for SW prefetch",
952      .ucode = 0x100,
953      .uflags= INTEL_X86_NCOMBO,
954    },
955 };
956
957 static const intel_x86_umask_t snb_l3_lat_cache[]={
958    { .uname  = "MISS",
959      .udesc  = "Core-originated cacheable demand requests missed L3",
960      .ucode = 0x100,
961      .uflags= INTEL_X86_NCOMBO,
962    },
963    { .uname  = "REFERENCE",
964      .udesc  = "Core-originated cacheable demand requests that refer to L3",
965      .ucode = 0x200,
966      .uflags= INTEL_X86_NCOMBO,
967    },
968 };
969
970 static const intel_x86_umask_t snb_machine_clears[]={
971    { .uname  = "MASKMOV",
972      .udesc  = "The number of executed Intel AVX masked load operations that refer to an illegal address range with the mask bits set to 0",
973      .ucode = 0x2000,
974      .uflags= INTEL_X86_NCOMBO,
975    },
976    { .uname  = "MEMORY_ORDERING",
977      .udesc  = "Number of Memory Ordering Machine Clears detected",
978      .ucode = 0x200,
979      .uflags= INTEL_X86_NCOMBO,
980    },
981    { .uname  = "SMC",
982      .udesc  = "Self-Modifying Code detected",
983      .ucode = 0x400,
984      .uflags= INTEL_X86_NCOMBO,
985    },
986 };
987
988 static const intel_x86_umask_t snb_mem_load_uops_llc_hit_retired[]={
989    { .uname  = "XSNP_HIT",
990      .udesc  = "Load LLC Hit and a cross-core Snoop hits in on-pkg core cache (Precise Event)",
991      .ucode = 0x200,
992      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
993    },
994    { .uname  = "XSNP_HITM",
995      .udesc  = "Load had HitM Response from a core on same socket (shared LLC) (Precise Event)",
996      .ucode = 0x400,
997      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
998    },
999    { .uname  = "XSNP_MISS",
1000      .udesc  = "Load LLC Hit and a cross-core Snoop missed in on-pkg core cache (Precise Event)",
1001      .ucode = 0x100,
1002      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1003    },
1004    { .uname  = "XSNP_NONE",
1005      .udesc  = "Load hit in last-level (L3) cache with no snoop needed (Precise Event)",
1006      .ucode = 0x800,
1007      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1008    },
1009 };
1010
1011 static const intel_x86_umask_t snb_mem_load_uops_misc_retired[]={
1012    { .uname  = "LLC_MISS",
1013      .udesc  = "Counts load driven L3 misses and some non simd split loads (Precise Event)",
1014      .ucode = 0x200,
1015      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS | INTEL_X86_DFL,
1016    },
1017 };
1018
1019 static const intel_x86_umask_t snb_mem_load_uops_retired[]={
1020    { .uname  = "HIT_LFB",
1021      .udesc  = "A load missed L1D but hit the Fill Buffer (Precise Event)",
1022      .ucode = 0x4000,
1023      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1024    },
1025    { .uname  = "L1_HIT",
1026      .udesc  = "Load hit in nearest-level (L1D) cache (Precise Event)",
1027      .ucode = 0x100,
1028      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1029    },
1030    { .uname  = "L2_HIT",
1031      .udesc  = "Load hit in mid-level (L2) cache (Precise Event)",
1032      .ucode = 0x200,
1033      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1034    },
1035    { .uname  = "L3_HIT",
1036      .udesc  = "Load hit in last-level (L3) cache with no snoop needed (Precise Event)",
1037      .ucode = 0x400,
1038      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1039    },
1040    { .uname  = "L3_MISS",
1041      .udesc  = "Retired load uops which data sources were data missed LLC (excluding unknown data source)",
1042      .ucode = 0x2000,
1043      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1044    },
1045 };
1046
1047 static const intel_x86_umask_t snb_mem_trans_retired[]={
1048    { .uname  = "LATENCY_ABOVE_THRESHOLD",
1049      .udesc  = "Memory load instructions retired above programmed clocks, minimum threshold value is 3 (Precise Event and ldlat required)",
1050      .ucode = 0x100,
1051      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS | INTEL_X86_LDLAT,
1052    },
1053    { .uname  = "PRECISE_STORE",
1054      .udesc  = "Capture where stores occur, must use with PEBS (Precise Event required)",
1055      .ucode = 0x200,
1056      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1057    },
1058 };
1059
1060 static const intel_x86_umask_t snb_mem_uops_retired[]={
1061    { .uname  = "ALL_LOADS",
1062      .udesc  = "Any retired loads (Precise Event)",
1063      .ucode = 0x8100,
1064      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1065    },
1066    { .uname  = "ANY_LOADS",
1067      .udesc  = "Any retired loads (Precise Event)",
1068      .ucode = 0x8100,
1069      .uequiv = "ALL_LOADS",
1070      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1071    },
1072    { .uname  = "ALL_STORES",
1073      .udesc  = "Any retired stores (Precise Event)",
1074      .ucode = 0x8200,
1075      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1076    },
1077    { .uname  = "ANY_STORES",
1078      .udesc  = "Any retired stores (Precise Event)",
1079      .ucode = 0x8200,
1080      .uequiv = "ALL_STORES",
1081      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1082    },
1083    { .uname  = "LOCK_LOADS",
1084      .udesc  = "Locked retired loads (Precise Event)",
1085      .ucode = 0x2100,
1086      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1087    },
1088    { .uname  = "LOCK_STORES",
1089      .udesc  = "Locked retired stores (Precise Event)",
1090      .ucode = 0x2200,
1091      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1092    },
1093    { .uname  = "SPLIT_LOADS",
1094      .udesc  = "Retired loads causing cacheline splits (Precise Event)",
1095      .ucode = 0x4100,
1096      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1097    },
1098    { .uname  = "SPLIT_STORES",
1099      .udesc  = "Retired stores causing cacheline splits (Precise Event)",
1100      .ucode = 0x4200,
1101      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1102    },
1103    { .uname  = "STLB_MISS_LOADS",
1104      .udesc  = "STLB misses dues to retired loads (Precise Event)",
1105      .ucode = 0x1100,
1106      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1107    },
1108    { .uname  = "STLB_MISS_STORES",
1109      .udesc  = "STLB misses dues to retired stores (Precise Event)",
1110      .ucode = 0x1200,
1111      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1112    },
1113 };
1114
1115 static const intel_x86_umask_t snb_misalign_mem_ref[]={
1116    { .uname  = "LOADS",
1117      .udesc  = "Speculative cache-line split load uops dispatched to the L1D",
1118      .ucode = 0x100,
1119      .uflags= INTEL_X86_NCOMBO,
1120    },
1121    { .uname  = "STORES",
1122      .udesc  = "Speculative cache-line split Store-address uops dispatched to L1D",
1123      .ucode = 0x200,
1124      .uflags= INTEL_X86_NCOMBO,
1125    },
1126 };
1127
1128 static const intel_x86_umask_t snb_offcore_requests[]={
1129    { .uname  = "ALL_DATA_RD",
1130      .udesc  = "Demand and prefetch read requests sent to uncore",
1131      .ucode = 0x800,
1132      .uflags= INTEL_X86_NCOMBO,
1133    },
1134    { .uname  = "ALL_DATA_READ",
1135      .udesc  = "Demand and prefetch read requests sent to uncore",
1136      .uequiv = "ALL_DATA_RD",
1137      .ucode = 0x800,
1138      .uflags= INTEL_X86_NCOMBO,
1139    },
1140    { .uname  = "DEMAND_CODE_RD",
1141      .udesc  = "Offcore code read requests, including cacheable and un-cacheables",
1142      .ucode = 0x200,
1143      .uflags= INTEL_X86_NCOMBO,
1144    },
1145    { .uname  = "DEMAND_DATA_RD",
1146      .udesc  = "Demand Data Read requests sent to uncore",
1147      .ucode = 0x100,
1148      .uflags= INTEL_X86_NCOMBO,
1149    },
1150    { .uname  = "DEMAND_RFO",
1151      .udesc  = "Offcore Demand RFOs, includes regular RFO, Locks, ItoM",
1152      .ucode = 0x400,
1153      .uflags= INTEL_X86_NCOMBO,
1154    },
1155 };
1156
1157 static const intel_x86_umask_t snb_offcore_requests_buffer[]={
1158    { .uname  = "SQ_FULL",
1159      .udesc  = "Offcore requests buffer cannot take more entries for this thread core",
1160      .ucode = 0x100,
1161      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1162    },
1163 };
1164
1165 static const intel_x86_umask_t snb_offcore_requests_outstanding[]={
1166    { .uname  = "ALL_DATA_RD_CYCLES",
1167      .udesc  = "Cycles with cacheable data read transactions in the superQ",
1168      .uequiv = "ALL_DATA_RD:c=1",
1169      .ucode = 0x800 | (0x1 << INTEL_X86_CMASK_BIT),
1170      .uflags= INTEL_X86_NCOMBO,
1171    },
1172    { .uname  = "DEMAND_CODE_RD_CYCLES",
1173      .udesc  = "Cycles with demand code reads transactions in the superQ",
1174      .uequiv = "DEMAND_CODE_RD:c=1",
1175      .ucode = 0x200 | (0x1 << INTEL_X86_CMASK_BIT),
1176      .uflags= INTEL_X86_NCOMBO,
1177    },
1178    { .uname  = "DEMAND_DATA_RD_CYCLES",
1179      .udesc  = "Cycles with demand data read transactions in the superQ",
1180      .uequiv = "DEMAND_DATA_RD:c=1",
1181      .ucode = 0x100 | (0x1 << INTEL_X86_CMASK_BIT),
1182      .uflags= INTEL_X86_NCOMBO,
1183    },
1184    { .uname  = "ALL_DATA_RD",
1185      .udesc  = "Cacheable data read transactions in the superQ every cycle",
1186      .ucode = 0x800,
1187      .uflags= INTEL_X86_NCOMBO,
1188    },
1189    { .uname  = "DEMAND_CODE_RD",
1190      .udesc  = "Code read transactions in the superQ every cycle",
1191      .ucode = 0x200,
1192      .uflags= INTEL_X86_NCOMBO,
1193    },
1194    { .uname  = "DEMAND_DATA_RD",
1195      .udesc  = "Demand data read transactions in the superQ every cycle",
1196      .ucode = 0x100,
1197      .uflags= INTEL_X86_NCOMBO,
1198    },
1199    { .uname  = "DEMAND_RFO",
1200      .udesc  = "Outstanding RFO (store) transactions in the superQ every cycle",
1201      .ucode = 0x400,
1202      .uflags= INTEL_X86_NCOMBO,
1203    },
1204    { .uname  = "DEMAND_RFO_CYCLES",
1205      .udesc  = "Cycles with outstanding RFO (store) transactions in the superQ",
1206      .uequiv = "DEMAND_RFO:c=1",
1207      .ucode = 0x400 | (0x1 << INTEL_X86_CMASK_BIT),
1208      .uflags= INTEL_X86_NCOMBO,
1209    },
1210 };
1211
1212 static const intel_x86_umask_t snb_other_assists[]={
1213    { .uname  = "ITLB_MISS_RETIRED",
1214      .udesc  = "Number of instructions that experienced an ITLB miss",
1215      .ucode = 0x200,
1216      .uflags= INTEL_X86_NCOMBO,
1217    },
1218    { .uname  = "AVX_TO_SSE",
1219      .udesc  = "Number of transitions from AVX-256 to legacy SSE when penalty applicable",
1220      .ucode = 0x1000,
1221      .uflags= INTEL_X86_NCOMBO,
1222    },
1223    { .uname  = "SSE_TO_AVX",
1224      .udesc  = "Number of transitions from legacy SSE to AVX-256 when penalty applicable",
1225      .ucode = 0x2000,
1226      .uflags= INTEL_X86_NCOMBO,
1227    },
1228 };
1229
1230 static const intel_x86_umask_t snb_partial_rat_stalls[]={
1231    { .uname  = "FLAGS_MERGE_UOP",
1232      .udesc  = "Number of flags-merge uops in flight in each cycle",
1233      .ucode = 0x2000,
1234      .uflags= INTEL_X86_NCOMBO,
1235    },
1236    { .uname  = "CYCLES_FLAGS_MERGE_UOP",
1237      .udesc  = "Cycles in which flags-merge uops in flight",
1238      .uequiv = "FLAGS_MERGE_UOP:c=1",
1239      .ucode = 0x2000 | (0x1 << INTEL_X86_CMASK_BIT),
1240      .uflags= INTEL_X86_NCOMBO,
1241    },
1242    { .uname  = "MUL_SINGLE_UOP",
1243      .udesc  = "Number of Multiply packed/scalar single precision uops allocated",
1244      .ucode = 0x8000,
1245      .uflags= INTEL_X86_NCOMBO,
1246    },
1247    { .uname  = "SLOW_LEA_WINDOW",
1248      .udesc  = "Number of cycles with at least one slow LEA uop allocated",
1249      .ucode = 0x4000,
1250      .uflags= INTEL_X86_NCOMBO,
1251    },
1252 };
1253
1254 static const intel_x86_umask_t snb_resource_stalls[]={
1255    { .uname  = "ANY",
1256      .udesc  = "Cycles stalled due to Resource Related reason",
1257      .ucode = 0x100,
1258      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1259    },
1260    { .uname  = "LB",
1261      .udesc  = "Cycles stalled due to lack of load buffers",
1262      .ucode = 0x200,
1263    },
1264    { .uname  = "RS",
1265      .udesc  = "Cycles stalled due to no eligible RS entry available",
1266      .ucode = 0x400,
1267    },
1268    { .uname  = "SB",
1269      .udesc  = "Cycles stalled due to no store buffers available (not including draining from sync)",
1270      .ucode = 0x800,
1271    },
1272    { .uname  = "ROB",
1273      .udesc  = "Cycles stalled due to re-order buffer full",
1274      .ucode = 0x1000,
1275    },
1276    { .uname  = "FCSW",
1277      .udesc  = "Cycles stalled due to writing the FPU control word",
1278      .ucode = 0x2000,
1279    },
1280    { .uname  = "MXCSR",
1281      .udesc  = "Cycles stalled due to the MXCSR register ranme occurring too close to a previous MXCSR rename",
1282      .ucode = 0x4000,
1283    },
1284    { .uname  = "MEM_RS",
1285      .udesc  = "Cycles stalled due to LB, SB or RS being completely in use",
1286      .ucode = 0xe00,
1287      .uequiv = "LB:SB:RS",
1288    },
1289 };
1290
1291 static const intel_x86_umask_t snb_resource_stalls2[]={
1292    { .uname  = "ALL_FL_EMPTY",
1293      .udesc  = "Cycles stalled due to free list empty",
1294      .ucode = 0xc00,
1295    },
1296    { .uname  = "ALL_PRF_CONTROL",
1297      .udesc  = "Cycles stalls due to control structures full for physical registers",
1298      .ucode = 0xf00,
1299    },
1300    { .uname  = "ANY_PRF_CONTROL",
1301      .udesc  = "Cycles stalls due to control structures full for physical registers",
1302      .ucode = 0xf00,
1303      .uequiv = "ALL_PRF_CONTROL",
1304    },
1305    { .uname  = "BOB_FULL",
1306      .udesc  = "Cycles Allocator is stalled due Branch Order Buffer",
1307      .ucode = 0x4000,
1308    },
1309    { .uname  = "OOO_RSRC",
1310      .udesc  = "Cycles stalled due to out of order resources full",
1311      .ucode = 0x4f00,
1312    },
1313 };
1314
1315 static const intel_x86_umask_t snb_rob_misc_events[]={
1316    { .uname  = "LBR_INSERTS",
1317      .udesc  = "Count each time an new LBR record is saved by HW",
1318      .ucode = 0x2000,
1319      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1320    },
1321 };
1322
1323 static const intel_x86_umask_t snb_rs_events[]={
1324    { .uname  = "EMPTY_CYCLES",
1325      .udesc  = "Cycles the RS is empty for this thread",
1326      .ucode = 0x100,
1327      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1328    },
1329 };
1330
1331 static const intel_x86_umask_t snb_simd_fp_256[]={
1332    { .uname  = "PACKED_SINGLE",
1333      .udesc  = "Counts 256-bit packed single-precision",
1334      .ucode = 0x100,
1335      .uflags= INTEL_X86_NCOMBO,
1336    },
1337    { .uname  = "PACKED_DOUBLE",
1338      .udesc  = "Counts 256-bit packed double-precision",
1339      .ucode = 0x200,
1340      .uflags= INTEL_X86_NCOMBO,
1341    },
1342 };
1343
1344 static const intel_x86_umask_t snb_sq_misc[]={
1345    { .uname  = "SPLIT_LOCK",
1346      .udesc  = "Split locks in SQ",
1347      .ucode = 0x1000,
1348      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1349    },
1350 };
1351
1352 static const intel_x86_umask_t snb_tlb_flush[]={
1353    { .uname  = "DTLB_THREAD",
1354      .udesc  = "Number of DTLB flushes of thread-specific entries",
1355      .ucode = 0x100,
1356      .uflags= INTEL_X86_NCOMBO,
1357    },
1358    { .uname  = "STLB_ANY",
1359      .udesc  = "Number of STLB flushes",
1360      .ucode = 0x2000,
1361      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1362    },
1363 };
1364
1365 static const intel_x86_umask_t snb_uops_dispatched[]={
1366    { .uname  = "CORE",
1367      .udesc  = "Counts total number of uops dispatched from any thread",
1368      .ucode = 0x200,
1369      .uflags= INTEL_X86_NCOMBO,
1370    },
1371    { .uname  = "STALL_CYCLES",
1372      .udesc  = "Counts number of cycles no uops were dispatched on this thread",
1373      .uequiv = "THREAD:c=1:i=1",
1374      .ucode = 0x100 | INTEL_X86_MOD_INV | (0x1 << INTEL_X86_CMASK_BIT),
1375      .uflags= INTEL_X86_NCOMBO,
1376    },
1377    { .uname  = "THREAD",
1378      .udesc  = "Counts total number of uops to be dispatched per-thread each cycle",
1379      .ucode = 0x100,
1380      .uflags= INTEL_X86_NCOMBO,
1381    },
1382 };
1383
1384 static const intel_x86_umask_t snb_uops_dispatched_port[]={
1385    { .uname  = "PORT_0",
1386      .udesc  = "Cycles which a Uop is dispatched on port 0",
1387      .ucode = 0x100,
1388      .uflags= INTEL_X86_NCOMBO,
1389    },
1390    { .uname  = "PORT_1",
1391      .udesc  = "Cycles which a Uop is dispatched on port 1",
1392      .ucode = 0x200,
1393      .uflags= INTEL_X86_NCOMBO,
1394    },
1395    { .uname  = "PORT_2_LD",
1396      .udesc  = "Cycles in which a load uop is dispatched on port 2",
1397      .ucode = 0x400,
1398      .uflags= INTEL_X86_NCOMBO,
1399    },
1400    { .uname  = "PORT_2_STA",
1401      .udesc  = "Cycles in which a store uop is dispatched on port 2",
1402      .ucode = 0x800,
1403      .uflags= INTEL_X86_NCOMBO,
1404    },
1405    { .uname  = "PORT_2",
1406      .udesc  = "Cycles in which a uop is dispatched on port 2",
1407      .ucode = 0xc00,
1408      .uflags= INTEL_X86_NCOMBO,
1409    },
1410    { .uname  = "PORT_3_LD",
1411      .udesc  = "Cycles in which a load uop is dispatched on port 3",
1412      .ucode = 0x1000,
1413      .uflags= INTEL_X86_NCOMBO,
1414    },
1415    { .uname  = "PORT_3_STA",
1416      .udesc  = "Cycles in which a store uop is dispatched on port 3",
1417      .ucode = 0x2000,
1418      .uflags= INTEL_X86_NCOMBO,
1419    },
1420    { .uname  = "PORT_3",
1421      .udesc  = "Cycles in which a uop is dispatched on port 3",
1422      .ucode = 0x3000,
1423      .uflags= INTEL_X86_NCOMBO,
1424    },
1425    { .uname  = "PORT_4",
1426      .udesc  = "Cycles which a uop is dispatched on port 4",
1427      .ucode = 0x4000,
1428      .uflags= INTEL_X86_NCOMBO,
1429    },
1430    { .uname  = "PORT_5",
1431      .udesc  = "Cycles which a Uop is dispatched on port 5",
1432      .ucode = 0x8000,
1433      .uflags= INTEL_X86_NCOMBO,
1434    },
1435 };
1436
1437 static const intel_x86_umask_t snb_uops_issued[]={
1438    { .uname  = "ANY",
1439      .udesc  = "Number of uops issued by the RAT to the Reservation Station (RS)",
1440      .ucode = 0x100,
1441      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1442    },
1443    { .uname  = "CORE_STALL_CYCLES",
1444      .udesc  = "Cycles no uops issued on this core (by any thread)",
1445      .uequiv = "ANY:c=1:i=1:t=1",
1446      .ucode = 0x100 | INTEL_X86_MOD_ANY | INTEL_X86_MOD_INV | (0x1 << INTEL_X86_CMASK_BIT),
1447      .uflags= INTEL_X86_NCOMBO,
1448    },
1449    { .uname  = "STALL_CYCLES",
1450      .udesc  = "Cycles no uops issued by this thread",
1451      .uequiv = "ANY:c=1:i=1",
1452      .ucode = 0x100 | INTEL_X86_MOD_INV | (0x1 << INTEL_X86_CMASK_BIT),
1453      .uflags= INTEL_X86_NCOMBO,
1454    },
1455 };
1456
1457 static const intel_x86_umask_t snb_uops_retired[]={
1458    { .uname  = "ALL",
1459      .udesc  = "All uops that actually retired (Precise Event)",
1460      .ucode = 0x100,
1461      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS | INTEL_X86_DFL,
1462    },
1463    { .uname  = "ANY",
1464      .udesc  = "All uops that actually retired (Precise Event)",
1465      .ucode = 0x100,
1466      .uequiv= "ALL",
1467      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1468    },
1469    { .uname  = "RETIRE_SLOTS",
1470      .udesc  = "Number of retirement slots used (Precise Event)",
1471      .ucode = 0x200,
1472      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1473    },
1474    { .uname  = "STALL_CYCLES",
1475      .udesc  = "Cycles no executable uop retired (Precise Event)",
1476      .uequiv = "ALL:c=1:i=1",
1477      .ucode = 0x100 | INTEL_X86_MOD_INV | (0x1 << INTEL_X86_CMASK_BIT),
1478      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1479    },
1480    { .uname  = "TOTAL_CYCLES",
1481      .udesc  = "Total cycles using precise uop retired event (Precise Event)",
1482      .uequiv = "ALL:c=16",
1483      .ucode = 0x100 | (0x10 << INTEL_X86_CMASK_BIT),
1484      .uflags= INTEL_X86_NCOMBO | INTEL_X86_PEBS,
1485    },
1486 };
1487
1488 static const intel_x86_umask_t snb_offcore_response[]={
1489    { .uname  = "DMND_DATA_RD",
1490      .udesc  = "Request: number of demand and DCU prefetch data reads of full and partial cachelines as well as demand data page table entry cacheline reads. Does not count L2 data read prefetches or instruction fetches",
1491      .ucode = 1ULL << (0 + 8),
1492      .grpid = 0,
1493    },
1494    { .uname  = "DMND_RFO",
1495      .udesc  = "Request: number of demand and DCU prefetch reads for ownership (RFO) requests generated by a write to data cacheline. Does not count L2 RFO prefetches",
1496      .ucode = 1ULL << (1 + 8),
1497      .grpid = 0,
1498    },
1499    { .uname  = "DMND_IFETCH",
1500      .udesc  = "Request: number of demand and DCU prefetch instruction cacheline reads. Does not count L2 code read prefetches",
1501      .ucode = 1ULL << (2 + 8),
1502      .grpid = 0,
1503    },
1504    { .uname  = "WB",
1505      .udesc  = "Request: number of writebacks (modified to exclusive) transactions",
1506      .ucode = 1ULL << (3 + 8),
1507      .grpid = 0,
1508    },
1509    { .uname  = "PF_DATA_RD",
1510      .udesc  = "Request: number of data cacheline reads generated by L2 prefetchers",
1511      .ucode = 1ULL << (4 + 8),
1512      .grpid = 0,
1513    },
1514    { .uname  = "PF_RFO",
1515      .udesc  = "Request: number of RFO requests generated by L2 prefetchers",
1516      .ucode = 1ULL << (5 + 8),
1517      .grpid = 0,
1518    },
1519    { .uname  = "PF_IFETCH",
1520      .udesc  = "Request: number of code reads generated by L2 prefetchers",
1521      .ucode = 1ULL << (6 + 8),
1522      .grpid = 0,
1523    },
1524    { .uname  = "PF_LLC_DATA_RD",
1525      .udesc  = "Request: number of L3 prefetcher requests to L2 for loads",
1526      .ucode = 1ULL << (7 + 8),
1527      .grpid = 0,
1528    },
1529    { .uname  = "PF_LLC_RFO",
1530      .udesc  = "Request: number of RFO requests generated by L2 prefetcher",
1531      .ucode = 1ULL << (8 + 8),
1532      .grpid = 0,
1533    },
1534    { .uname  = "PF_LLC_IFETCH",
1535      .udesc  = "Request: number of L2 prefetcher requests to L3 for instruction fetches",
1536      .ucode = 1ULL << (9 + 8),
1537      .grpid = 0,
1538    },
1539    { .uname  = "BUS_LOCKS",
1540      .udesc  = "Request: number bus lock and split lock requests",
1541      .ucode = 1ULL << (10 + 8),
1542      .grpid = 0,
1543    },
1544    { .uname  = "STRM_ST",
1545      .udesc  = "Request: number of streaming store requests",
1546      .ucode = 1ULL << (11 + 8),
1547      .grpid = 0,
1548    },
1549    { .uname  = "OTHER",
1550      .udesc  = "Request: counts one of the following transaction types, including L3 invalidate, I/O, full or partial writes, WC or non-temporal stores, CLFLUSH, Fences, lock, unlock, split lock",
1551      .ucode = 1ULL << (15+8),
1552      .grpid = 0,
1553    },
1554    { .uname  = "ANY_IFETCH",
1555      .udesc  = "Request: combination of PF_IFETCH | DMND_IFETCH | PF_LLC_IFETCH",
1556      .uequiv = "PF_IFETCH:DMND_IFETCH:PF_LLC_IFETCH",
1557      .ucode = 0x24400,
1558      .grpid = 0,
1559    },
1560    { .uname  = "ANY_REQUEST",
1561      .udesc  = "Request: combination of all request umasks",
1562      .uequiv = "DMND_DATA_RD:DMND_RFO:DMND_IFETCH:WB:PF_DATA_RD:PF_RFO:PF_IFETCH:PF_LLC_DATA_RD:PF_LLC_RFO:PF_LLC_IFETCH:BUS_LOCKS:STRM_ST:OTHER",
1563      .ucode = 0x8fff00,
1564      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1565      .grpid = 0,
1566    },
1567    { .uname  = "ANY_DATA",
1568      .udesc  = "Request: combination of DMND_DATA | PF_DATA_RD | PF_LLC_DATA_RD",
1569      .uequiv = "DMND_DATA_RD:PF_DATA_RD:PF_LLC_DATA_RD",
1570      .ucode = 0x9100,
1571      .grpid = 0,
1572    },
1573    { .uname  = "ANY_RFO",
1574      .udesc  = "Request: combination of DMND_RFO | PF_RFO | PF_LLC_RFO",
1575      .uequiv = "DMND_RFO:PF_RFO:PF_LLC_RFO",
1576      .ucode = 0x12200,
1577      .grpid = 0,
1578    },
1579
1580    { .uname  = "ANY_RESPONSE",
1581      .udesc  = "Response: count any response type",
1582      .ucode = 1ULL << (16+8),
1583      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL | INTEL_X86_EXCL_GRP_GT,
1584      .grpid = 1,
1585    },
1586    { .uname  = "NO_SUPP",
1587      .udesc  = "Supplier: counts number of times supplier information is not available",
1588      .ucode = 1ULL << (17+8),
1589      .grpid = 1,
1590    },
1591    { .uname  = "LLC_HITM",
1592      .udesc  = "Supplier: counts L3 hits in M-state (initial lookup)",
1593      .ucode = 1ULL << (18+8),
1594      .grpid = 1,
1595    },
1596    { .uname  = "LLC_HITE",
1597      .udesc  = "Supplier: counts L3 hits in E-state",
1598      .ucode = 1ULL << (19+8),
1599      .grpid = 1,
1600    },
1601    { .uname  = "LLC_HITS",
1602      .udesc  = "Supplier: counts L3 hits in S-state",
1603      .ucode = 1ULL << (20+8),
1604      .grpid = 1,
1605    },
1606    { .uname  = "LLC_HITF",
1607      .udesc  = "Supplier: counts L3 hits in F-state",
1608      .ucode = 1ULL << (21+8),
1609      .grpid = 1,
1610    },
1611    { .uname  = "LLC_MISS_LOCAL_DRAM",
1612      .udesc  = "Supplier: counts L3 misses to local DRAM",
1613      .ucode = 1ULL << (22+8),
1614      .uequiv = "MISS_DRAM",
1615      .grpid = 1,
1616    },
1617    { .uname  = "LLC_MISS_LOCAL",
1618      .udesc  = "Supplier: counts L3 misses to local DRAM",
1619      .ucode = 1ULL << (22+8),
1620      .uequiv = "MISS_DRAM",
1621      .grpid = 1,
1622    },
1623    { .uname  = "MISS_DRAM",
1624      .udesc  = "Supplier: counts L3 misses to local DRAM",
1625      .ucode = 1ULL << (22+8),
1626      .grpid = 1,
1627    },
1628    { .uname  = "LLC_HITMESF",
1629      .udesc  = "Supplier: counts L3 hits in any state (M, E, S, F)",
1630      .ucode  = 0xfULL << (18+8),
1631      .uequiv = "LLC_HITM:LLC_HITE:LLC_HITS:LLC_HITF",
1632      .grpid  = 1,
1633    },
1634    { .uname  = "SNP_NONE",
1635      .udesc  = "Snoop: counts number of times no snoop-related information is available",
1636      .ucode = 1ULL << (31+8),
1637      .grpid = 2,
1638    },
1639    { .uname  = "SNP_NOT_NEEDED",
1640      .udesc  = "Snoop: counts the number of times no snoop was needed to satisfy the request",
1641      .ucode = 1ULL << (32+8),
1642      .grpid = 2,
1643    },
1644    { .uname  = "NO_SNP_NEEDED",
1645      .udesc  = "Snoop: counts the number of times no snoop was needed to satisfy the request",
1646      .ucode = 1ULL << (32+8),
1647      .uequiv = "SNP_NOT_NEEDED",
1648      .grpid = 2,
1649    },
1650    { .uname  = "SNP_MISS",
1651      .udesc  = "Snoop: counts number of times a snoop was needed and it missed all snooped caches",
1652      .ucode = 1ULL << (33+8),
1653      .grpid = 2,
1654    },
1655    { .uname  = "SNP_NO_FWD",
1656      .udesc  = "Snoop: counts number of times a snoop was needed and it hit in at leas one snooped cache",
1657      .ucode = 1ULL << (34+8),
1658      .grpid = 2,
1659    },
1660    { .uname  = "SNP_FWD",
1661      .udesc  = "Snoop: counts number of times a snoop was needed and data was forwarded from a remote socket",
1662      .ucode = 1ULL << (35+8),
1663      .grpid = 2,
1664    },
1665    { .uname  = "HITM",
1666      .udesc  = "Snoop: counts number of times a snoop was needed and it hitM-ed in local or remote cache",
1667      .ucode = 1ULL << (36+8),
1668      .grpid = 2,
1669    },
1670    { .uname  = "NON_DRAM",
1671      .udesc  = "Snoop:  counts number of times target was a non-DRAM system address. This includes MMIO transactions",
1672      .ucode = 1ULL << (37+8),
1673      .grpid = 2,
1674    },
1675    { .uname  = "SNP_ANY",
1676      .udesc  = "Snoop: any snoop reason",
1677      .ucode = 0x7fULL << (31+8),
1678      .uequiv = "SNP_NONE:SNP_NOT_NEEDED:SNP_MISS:SNP_NO_FWD:SNP_FWD:HITM:NON_DRAM",
1679      .uflags= INTEL_X86_DFL,
1680      .grpid = 2,
1681    },
1682 };
1683
1684 static const intel_x86_umask_t snb_baclears[]={
1685    { .uname  = "ANY",
1686      .udesc  = "Counts the number of times the front end is re-steered, mainly when the BPU cannot provide a correct prediction and this is corrected by other branch handling mechanisms at the front end",
1687      .ucode = 0x1f00,
1688      .uflags= INTEL_X86_NCOMBO | INTEL_X86_DFL,
1689    },
1690 };
1691
1692 static const intel_x86_umask_t snb_cycle_activity[]={
1693    { .uname  = "CYCLES_L2_PENDING",
1694      .udesc  = "Cycles with pending L2 miss loads",
1695      .ucode  = 0x0100 | (0x1 << INTEL_X86_CMASK_BIT),
1696      .uflags = INTEL_X86_NCOMBO,
1697      .ucntmsk= 0xf,
1698    },
1699    { .uname  = "CYCLES_L1D_PENDING",
1700      .udesc  = "Cycles with pending L1D load cache misses",
1701      .ucode  = 0x0200 | (0x2 << INTEL_X86_CMASK_BIT),
1702      .ucntmsk= 0x4,
1703      .uflags = INTEL_X86_NCOMBO,
1704    },
1705    { .uname  = "CYCLES_NO_DISPATCH",
1706      .udesc  = "Cycles of dispatch stalls",
1707      .ucode  = 0x0400 | (0x4 << INTEL_X86_CMASK_BIT),
1708      .ucntmsk= 0xf,
1709      .uflags = INTEL_X86_NCOMBO,
1710    },
1711    { .uname  = "STALLS_L2_PENDING",
1712      .udesc  = "Execution stalls due to L2 pending loads",
1713      .ucode  = 0x0500 | (0x5 << INTEL_X86_CMASK_BIT),
1714      .ucntmsk= 0xf,
1715      .uflags = INTEL_X86_NCOMBO,
1716    },
1717    { .uname  = "STALLS_L1D_PENDING",
1718      .udesc  = "Execution stalls due to L1D pending loads",
1719      .ucode  = 0x0600 | (0x6 << INTEL_X86_CMASK_BIT),
1720      .ucntmsk= 0x4,
1721      .uflags = INTEL_X86_NCOMBO,
1722    },
1723 };
1724
1725 static const intel_x86_entry_t intel_snb_pe[]={
1726 { .name   = "AGU_BYPASS_CANCEL",
1727   .desc   = "Number of executed load operations with all the following traits: 1. addressing of the format [base + offset], 2. the offset is between 1 and 2047, 3. the address specified in the base register is in one page and the address [base+offset] is in another page",
1728   .modmsk = INTEL_V3_ATTRS,
1729   .cntmsk = 0xff,
1730   .code = 0xb6,
1731   .numasks = LIBPFM_ARRAY_SIZE(snb_agu_bypass_cancel),
1732   .ngrp = 1,
1733   .umasks = snb_agu_bypass_cancel,
1734 },
1735 { .name   = "ARITH",
1736   .desc   = "Counts arithmetic multiply operations",
1737   .modmsk = INTEL_V3_ATTRS,
1738   .cntmsk = 0xff,
1739   .code = 0x14,
1740   .numasks = LIBPFM_ARRAY_SIZE(snb_arith),
1741   .ngrp = 1,
1742   .umasks = snb_arith,
1743 },
1744 { .name   = "BACLEARS",
1745   .desc   = "Branch re-steered",
1746   .modmsk = INTEL_V3_ATTRS,
1747   .cntmsk = 0xff,
1748   .code = 0xe6,
1749   .numasks = LIBPFM_ARRAY_SIZE(snb_baclears),
1750   .ngrp = 1,
1751   .umasks = snb_baclears,
1752 },
1753 { .name   = "BR_INST_EXEC",
1754   .desc   = "Branch instructions executed",
1755   .modmsk = INTEL_V3_ATTRS,
1756   .cntmsk = 0xff,
1757   .code = 0x88,
1758   .numasks = LIBPFM_ARRAY_SIZE(snb_br_inst_exec),
1759   .ngrp = 1,
1760   .umasks = snb_br_inst_exec,
1761 },
1762 { .name   = "BR_INST_RETIRED",
1763   .desc   = "Retired branch instructions",
1764   .modmsk = INTEL_V3_ATTRS,
1765   .cntmsk = 0xff,
1766   .code = 0xc4,
1767   .flags= INTEL_X86_PEBS,
1768   .numasks = LIBPFM_ARRAY_SIZE(snb_br_inst_retired),
1769   .ngrp = 1,
1770   .umasks = snb_br_inst_retired,
1771 },
1772 { .name   = "BR_MISP_EXEC",
1773   .desc   = "Mispredicted branches executed",
1774   .modmsk = INTEL_V3_ATTRS,
1775   .cntmsk = 0xff,
1776   .code = 0x89,
1777   .numasks = LIBPFM_ARRAY_SIZE(snb_br_misp_exec),
1778   .ngrp = 1,
1779   .umasks = snb_br_misp_exec,
1780 },
1781 { .name   = "BR_MISP_RETIRED",
1782   .desc   = "Mispredicted retired branches",
1783   .modmsk = INTEL_V3_ATTRS,
1784   .cntmsk = 0xff,
1785   .code = 0xc5,
1786   .flags= INTEL_X86_PEBS,
1787   .numasks = LIBPFM_ARRAY_SIZE(snb_br_misp_retired),
1788   .ngrp = 1,
1789   .umasks = snb_br_misp_retired,
1790 },
1791 { .name   = "BRANCH_INSTRUCTIONS_RETIRED",
1792   .desc   = "Count branch instructions at retirement. Specifically, this event counts the retirement of the last micro-op of a branch instruction",
1793   .modmsk = INTEL_V3_ATTRS,
1794   .equiv = "BR_INST_RETIRED:ALL_BRANCHES",
1795   .cntmsk = 0xff,
1796   .code = 0xc4,
1797 },
1798 { .name   = "MISPREDICTED_BRANCH_RETIRED",
1799   .desc   = "Count mispredicted branch instructions at retirement. Specifically, this event counts at retirement of the last micro-op of a branch instruction in the architectural path of the execution and experienced misprediction in the branch prediction hardware",
1800   .modmsk = INTEL_V3_ATTRS,
1801   .equiv = "BR_MISP_RETIRED:ALL_BRANCHES",
1802   .cntmsk = 0xff,
1803   .code = 0xc5,
1804 },
1805 { .name   = "LOCK_CYCLES",
1806   .desc   = "Locked cycles in L1D and L2",
1807   .modmsk = INTEL_V3_ATTRS,
1808   .cntmsk = 0xff,
1809   .code = 0x63,
1810   .numasks = LIBPFM_ARRAY_SIZE(snb_lock_cycles),
1811   .ngrp = 1,
1812   .umasks = snb_lock_cycles,
1813 },
1814 { .name   = "CPL_CYCLES",
1815   .desc   = "Unhalted core cycles at a specific ring level",
1816   .modmsk = INTEL_V3_ATTRS,
1817   .cntmsk = 0xff,
1818   .code = 0x5c,
1819   .numasks = LIBPFM_ARRAY_SIZE(snb_cpl_cycles),
1820   .ngrp = 1,
1821   .umasks = snb_cpl_cycles,
1822 },
1823 { .name   = "CPU_CLK_UNHALTED",
1824   .desc   = "Cycles when processor is not in halted state",
1825   .modmsk = INTEL_V3_ATTRS,
1826   .cntmsk = 0xff,
1827   .code = 0x3c,
1828   .numasks = LIBPFM_ARRAY_SIZE(snb_cpu_clk_unhalted),
1829   .ngrp = 1,
1830   .umasks = snb_cpu_clk_unhalted,
1831 },
1832 { .name   = "DSB2MITE_SWITCHES",
1833   .desc   = "Number of DSB to MITE switches",
1834   .modmsk = INTEL_V3_ATTRS,
1835   .cntmsk = 0xff,
1836   .code = 0xab,
1837   .numasks = LIBPFM_ARRAY_SIZE(snb_dsb2mite_switches),
1838   .ngrp = 1,
1839   .umasks = snb_dsb2mite_switches,
1840 },
1841 { .name   = "DSB_FILL",
1842   .desc   = "DSB fills",
1843   .modmsk = INTEL_V3_ATTRS,
1844   .cntmsk = 0xff,
1845   .code = 0xac,
1846   .numasks = LIBPFM_ARRAY_SIZE(snb_dsb_fill),
1847   .ngrp = 1,
1848   .umasks = snb_dsb_fill,
1849 },
1850 { .name   = "DTLB_LOAD_MISSES",
1851   .desc   = "Data TLB load misses",
1852   .modmsk = INTEL_V3_ATTRS,
1853   .cntmsk = 0xff,
1854   .code = 0x8,
1855   .numasks = LIBPFM_ARRAY_SIZE(snb_dtlb_load_misses),
1856   .ngrp = 1,
1857   .umasks = snb_dtlb_load_misses,
1858 },
1859 { .name   = "DTLB_STORE_MISSES",
1860   .desc   = "Data TLB store misses",
1861   .modmsk = INTEL_V3_ATTRS,
1862   .cntmsk = 0xff,
1863   .code = 0x49,
1864   .numasks = LIBPFM_ARRAY_SIZE(snb_dtlb_store_misses),
1865   .ngrp = 1,
1866   .umasks = snb_dtlb_store_misses,
1867 },
1868 { .name   = "FP_ASSIST",
1869   .desc   = "X87 Floating point assists",
1870   .modmsk = INTEL_V3_ATTRS,
1871   .cntmsk = 0xff,
1872   .code = 0xca,
1873   .numasks = LIBPFM_ARRAY_SIZE(snb_fp_assist),
1874   .ngrp = 1,
1875   .umasks = snb_fp_assist,
1876 },
1877 { .name   = "FP_COMP_OPS_EXE",
1878   .desc   = "Counts number of floating point events",
1879   .modmsk = INTEL_V3_ATTRS,
1880   .cntmsk = 0xff,
1881   .code = 0x10,
1882   .numasks = LIBPFM_ARRAY_SIZE(snb_fp_comp_ops_exe),
1883   .ngrp = 1,
1884   .umasks = snb_fp_comp_ops_exe,
1885 },
1886 { .name   = "HW_INTERRUPTS",
1887   .desc   = "Number of hardware interrupts received by the processor",
1888   .modmsk = INTEL_V3_ATTRS,
1889   .cntmsk = 0xff,
1890   .code = 0xcb,
1891   .numasks = LIBPFM_ARRAY_SIZE(snb_hw_interrupts),
1892   .ngrp = 1,
1893   .umasks = snb_hw_interrupts,
1894 },
1895 { .name   = "HW_PRE_REQ",
1896   .desc   = "Hardware prefetch requests",
1897   .modmsk = INTEL_V3_ATTRS,
1898   .cntmsk = 0xff,
1899   .code = 0x4e,
1900   .numasks = LIBPFM_ARRAY_SIZE(snb_hw_pre_req),
1901   .ngrp = 1,
1902   .umasks = snb_hw_pre_req,
1903 },
1904 { .name   = "ICACHE",
1905   .desc   = "Instruction Cache accesses",
1906   .modmsk = INTEL_V3_ATTRS,
1907   .cntmsk = 0xff,
1908   .code = 0x80,
1909   .numasks = LIBPFM_ARRAY_SIZE(snb_icache),
1910   .ngrp = 1,
1911   .umasks = snb_icache,
1912 },
1913 { .name   = "IDQ",
1914   .desc   = "IDQ operations",
1915   .modmsk = INTEL_V3_ATTRS,
1916   .cntmsk = 0xff,
1917   .code = 0x79,
1918   .numasks = LIBPFM_ARRAY_SIZE(snb_idq),
1919   .ngrp = 1,
1920   .umasks = snb_idq,
1921 },
1922 { .name   = "IDQ_UOPS_NOT_DELIVERED",
1923   .desc   = "Uops not delivered",
1924   .modmsk = INTEL_V3_ATTRS,
1925   .cntmsk = 0xff,
1926   .code = 0x9c,
1927   .numasks = LIBPFM_ARRAY_SIZE(snb_idq_uops_not_delivered),
1928   .ngrp = 1,
1929   .umasks = snb_idq_uops_not_delivered,
1930 },
1931 { .name   = "ILD_STALL",
1932   .desc   = "Instruction Length Decoder stalls",
1933   .modmsk = INTEL_V3_ATTRS,
1934   .cntmsk = 0xff,
1935   .code = 0x87,
1936   .numasks = LIBPFM_ARRAY_SIZE(snb_ild_stall),
1937   .ngrp = 1,
1938   .umasks = snb_ild_stall,
1939 },
1940 { .name   = "INSTS_WRITTEN_TO_IQ",
1941   .desc   = "Instructions written to IQ",
1942   .modmsk = INTEL_V3_ATTRS,
1943   .cntmsk = 0xff,
1944   .code = 0x17,
1945   .numasks = LIBPFM_ARRAY_SIZE(snb_insts_written_to_iq),
1946   .ngrp = 1,
1947   .umasks = snb_insts_written_to_iq,
1948 },
1949 { .name   = "INST_RETIRED",
1950   .desc   = "Instructions retired",
1951   .modmsk = INTEL_V3_ATTRS,
1952   .cntmsk = 0xff,
1953   .code = 0xc0,
1954   .flags= INTEL_X86_PEBS,
1955   .numasks = LIBPFM_ARRAY_SIZE(snb_inst_retired),
1956   .ngrp = 1,
1957   .umasks = snb_inst_retired,
1958 },
1959 { .name   = "INSTRUCTION_RETIRED",
1960   .desc   = "Number of instructions at retirement",
1961   .modmsk = INTEL_V3_ATTRS,
1962   .cntmsk = 0x10000000full,
1963   .code = 0xc0,
1964 },
1965 { .name   = "INSTRUCTIONS_RETIRED",
1966   .desc   = "This is an alias for INSTRUCTION_RETIRED",
1967   .modmsk = INTEL_V3_ATTRS,
1968   .equiv = "INSTRUCTION_RETIRED",
1969   .cntmsk = 0x10000000full,
1970   .code = 0xc0,
1971 },
1972 { .name   = "INT_MISC",
1973   .desc   = "Miscellaneous internals",
1974   .modmsk = INTEL_V3_ATTRS,
1975   .cntmsk = 0xff,
1976   .code = 0xd,
1977   .numasks = LIBPFM_ARRAY_SIZE(snb_int_misc),
1978   .ngrp = 1,
1979   .umasks = snb_int_misc,
1980 },
1981 { .name   = "ITLB",
1982   .desc   = "Instruction TLB",
1983   .modmsk = INTEL_V3_ATTRS,
1984   .cntmsk = 0xff,
1985   .code = 0xae,
1986   .numasks = LIBPFM_ARRAY_SIZE(snb_itlb),
1987   .ngrp = 1,
1988   .umasks = snb_itlb,
1989 },
1990 { .name   = "ITLB_MISSES",
1991   .desc   = "Instruction TLB misses",
1992   .modmsk = INTEL_V3_ATTRS,
1993   .cntmsk = 0xff,
1994   .code = 0x85,
1995   .numasks = LIBPFM_ARRAY_SIZE(snb_dtlb_store_misses),
1996   .ngrp = 1,
1997   .umasks = snb_dtlb_store_misses, /* identical to actual umasks list for this event */
1998 },
1999 { .name   = "L1D",
2000   .desc   = "L1D cache",
2001   .modmsk = INTEL_V3_ATTRS,
2002   .cntmsk = 0xff,
2003   .code = 0x51,
2004   .numasks = LIBPFM_ARRAY_SIZE(snb_l1d),
2005   .ngrp = 1,
2006   .umasks = snb_l1d,
2007 },
2008 { .name   = "L1D_BLOCKS",
2009   .desc   = "L1D is blocking",
2010   .modmsk = INTEL_V3_ATTRS,
2011   .cntmsk = 0xff,
2012   .code = 0xbf,
2013   .numasks = LIBPFM_ARRAY_SIZE(snb_l1d_blocks),
2014   .ngrp = 1,
2015   .umasks = snb_l1d_blocks,
2016 },
2017 { .name   = "L1D_PEND_MISS",
2018   .desc   = "L1D pending misses",
2019   .modmsk = INTEL_V3_ATTRS,
2020   .cntmsk = 0x4,
2021   .code = 0x48,
2022   .numasks = LIBPFM_ARRAY_SIZE(snb_l1d_pend_miss),
2023   .ngrp = 1,
2024   .umasks = snb_l1d_pend_miss,
2025 },
2026 { .name   = "L2_L1D_WB_RQSTS",
2027   .desc   = "Writeback requests from L1D to L2",
2028   .modmsk = INTEL_V3_ATTRS,
2029   .cntmsk = 0xff,
2030   .code = 0x28,
2031   .numasks = LIBPFM_ARRAY_SIZE(snb_l2_l1d_wb_rqsts),
2032   .ngrp = 1,
2033   .umasks = snb_l2_l1d_wb_rqsts,
2034 },
2035 { .name   = "L2_LINES_IN",
2036   .desc   = "L2 lines allocated",
2037   .modmsk = INTEL_V3_ATTRS,
2038   .cntmsk = 0xff,
2039   .code = 0xf1,
2040   .numasks = LIBPFM_ARRAY_SIZE(snb_l2_lines_in),
2041   .ngrp = 1,
2042   .umasks = snb_l2_lines_in,
2043 },
2044 { .name   = "L2_LINES_OUT",
2045   .desc   = "L2 lines evicted",
2046   .modmsk = INTEL_V3_ATTRS,
2047   .cntmsk = 0xff,
2048   .code = 0xf2,
2049   .numasks = LIBPFM_ARRAY_SIZE(snb_l2_lines_out),
2050   .ngrp = 1,
2051   .umasks = snb_l2_lines_out,
2052 },
2053 { .name   = "L2_RQSTS",
2054   .desc   = "L2 requests",
2055   .modmsk = INTEL_V3_ATTRS,
2056   .cntmsk = 0xff,
2057   .code = 0x24,
2058   .numasks = LIBPFM_ARRAY_SIZE(snb_l2_rqsts),
2059   .ngrp = 1,
2060   .umasks = snb_l2_rqsts,
2061 },
2062 { .name   = "L2_STORE_LOCK_RQSTS",
2063   .desc   = "L2 store lock requests",
2064   .modmsk = INTEL_V3_ATTRS,
2065   .cntmsk = 0xff,
2066   .code = 0x27,
2067   .numasks = LIBPFM_ARRAY_SIZE(snb_l2_store_lock_rqsts),
2068   .ngrp = 1,
2069   .umasks = snb_l2_store_lock_rqsts,
2070 },
2071 { .name   = "L2_TRANS",
2072   .desc   = "L2 transactions",
2073   .modmsk = INTEL_V3_ATTRS,
2074   .cntmsk = 0xff,
2075   .code = 0xf0,
2076   .numasks = LIBPFM_ARRAY_SIZE(snb_l2_trans),
2077   .ngrp = 1,
2078   .umasks = snb_l2_trans,
2079 },
2080 { .name   = "LAST_LEVEL_CACHE_MISSES",
2081   .desc   = "This is an alias for L3_LAT_CACHE:MISS",
2082   .modmsk = INTEL_V3_ATTRS,
2083   .equiv = "L3_LAT_CACHE:MISS",
2084   .cntmsk = 0xff,
2085   .code = 0x412e,
2086 },
2087 { .name   = "LLC_MISSES",
2088   .desc   = "Alias for LAST_LEVEL_CACHE_MISSES",
2089   .modmsk = INTEL_V3_ATTRS,
2090   .equiv = "LAST_LEVEL_CACHE_MISSES",
2091   .cntmsk = 0xff,
2092   .code = 0x412e,
2093 },
2094 { .name   = "LAST_LEVEL_CACHE_REFERENCES",
2095   .desc   = "This is an alias for L3_LAT_CACHE:REFERENCE",
2096   .modmsk = INTEL_V3_ATTRS,
2097   .equiv = "L3_LAT_CACHE:REFERENCE",
2098   .cntmsk = 0xff,
2099   .code = 0x4f2e,
2100 },
2101 { .name   = "LLC_REFERENCES",
2102   .desc   = "Alias for LAST_LEVEL_CACHE_REFERENCES",
2103   .modmsk = INTEL_V3_ATTRS,
2104   .equiv = "LAST_LEVEL_CACHE_REFERENCES",
2105   .cntmsk = 0xff,
2106   .code = 0x4f2e,
2107 },
2108 { .name   = "LD_BLOCKS",
2109   .desc   = "Blocking loads",
2110   .modmsk = INTEL_V3_ATTRS,
2111   .cntmsk = 0xff,
2112   .code = 0x3,
2113   .numasks = LIBPFM_ARRAY_SIZE(snb_ld_blocks),
2114   .ngrp = 1,
2115   .umasks = snb_ld_blocks,
2116 },
2117 { .name   = "LD_BLOCKS_PARTIAL",
2118   .desc   = "Partial load blocks",
2119   .modmsk = INTEL_V3_ATTRS,
2120   .cntmsk = 0xff,
2121   .code = 0x7,
2122   .numasks = LIBPFM_ARRAY_SIZE(snb_ld_blocks_partial),
2123   .ngrp = 1,
2124   .umasks = snb_ld_blocks_partial,
2125 },
2126 { .name   = "LOAD_HIT_PRE",
2127   .desc   = "Load dispatches that hit fill buffer",
2128   .modmsk = INTEL_V3_ATTRS,
2129   .cntmsk = 0xff,
2130   .code = 0x4c,
2131   .numasks = LIBPFM_ARRAY_SIZE(snb_load_hit_pre),
2132   .ngrp = 1,
2133   .umasks = snb_load_hit_pre,
2134 },
2135 { .name   = "L3_LAT_CACHE",
2136   .desc   = "Core-originated cacheable demand requests to L3",
2137   .modmsk = INTEL_V3_ATTRS,
2138   .cntmsk = 0xff,
2139   .code = 0x2e,
2140   .numasks = LIBPFM_ARRAY_SIZE(snb_l3_lat_cache),
2141   .ngrp = 1,
2142   .umasks = snb_l3_lat_cache,
2143 },
2144 { .name   = "MACHINE_CLEARS",
2145   .desc   = "Machine clear asserted",
2146   .modmsk = INTEL_V3_ATTRS,
2147   .cntmsk = 0xff,
2148   .code = 0xc3,
2149   .numasks = LIBPFM_ARRAY_SIZE(snb_machine_clears),
2150   .ngrp = 1,
2151   .umasks = snb_machine_clears,
2152 },
2153 { .name   = "MEM_LOAD_UOPS_LLC_HIT_RETIRED",
2154   .desc   = "L3 hit loads uops retired",
2155   .modmsk = INTEL_V3_ATTRS,
2156   .cntmsk = 0xff,
2157   .code = 0xd2,
2158   .flags= INTEL_X86_PEBS,
2159   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_load_uops_llc_hit_retired),
2160   .ngrp = 1,
2161   .umasks = snb_mem_load_uops_llc_hit_retired,
2162 },
2163 { .name   = "MEM_LOAD_LLC_HIT_RETIRED",
2164   .desc   = "L3 hit loads uops retired (deprecated use MEM_LOAD_UOPS_LLC_HIT_RETIRED)",
2165   .modmsk = INTEL_V3_ATTRS,
2166   .cntmsk = 0xff,
2167   .code = 0xd2,
2168   .equiv = "MEM_LOAD_UOPS_LLC_HIT_RETIRED",
2169   .flags= INTEL_X86_PEBS,
2170   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_load_uops_llc_hit_retired),
2171   .ngrp = 1,
2172   .umasks = snb_mem_load_uops_llc_hit_retired,
2173 },
2174 { .name   = "MEM_LOAD_UOPS_MISC_RETIRED",
2175   .desc   = "Loads and some non simd split loads uops retired",
2176   .modmsk = INTEL_V3_ATTRS,
2177   .cntmsk = 0xff,
2178   .code = 0xd4,
2179   .flags= INTEL_X86_PEBS,
2180   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_load_uops_misc_retired),
2181   .ngrp = 1,
2182   .umasks = snb_mem_load_uops_misc_retired,
2183 },
2184 { .name   = "MEM_LOAD_MISC_RETIRED",
2185   .desc   = "Loads and some non simd split loads uops retired (deprecated use MEM_LOAD_UOPS_MISC_RETIRED)",
2186   .modmsk = INTEL_V3_ATTRS,
2187   .cntmsk = 0xff,
2188   .code = 0xd4,
2189   .equiv  = "MEM_LOAD_UOPS_MISC_RETIRED",
2190   .flags= INTEL_X86_PEBS,
2191   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_load_uops_misc_retired),
2192   .ngrp = 1,
2193   .umasks = snb_mem_load_uops_misc_retired,
2194 },
2195
2196 { .name   = "MEM_LOAD_UOPS_RETIRED",
2197   .desc   = "Memory loads uops retired",
2198   .modmsk = INTEL_V3_ATTRS,
2199   .cntmsk = 0xff,
2200   .code = 0xd1,
2201   .flags= INTEL_X86_PEBS,
2202   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_load_uops_retired),
2203   .ngrp = 1,
2204   .umasks = snb_mem_load_uops_retired,
2205 },
2206 { .name   = "MEM_LOAD_RETIRED",
2207   .desc   = "Memory loads uops retired (deprecated use MEM_LOAD_UOPS_RETIRED)",
2208   .modmsk = INTEL_V3_ATTRS,
2209   .cntmsk = 0xff,
2210   .code = 0xd1,
2211   .equiv = "MEM_LOAD_UOPS_RETIRED",
2212   .flags= INTEL_X86_PEBS,
2213   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_load_uops_retired),
2214   .ngrp = 1,
2215   .umasks = snb_mem_load_uops_retired,
2216 },
2217 { .name   = "MEM_TRANS_RETIRED",
2218   .desc   = "Memory transactions retired",
2219   .modmsk = INTEL_V3_ATTRS | _INTEL_X86_ATTR_LDLAT,
2220   .cntmsk = 0x8,
2221   .code = 0xcd,
2222   .flags= INTEL_X86_PEBS,
2223   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_trans_retired),
2224   .ngrp = 1,
2225   .umasks = snb_mem_trans_retired,
2226 },
2227 { .name   = "MEM_UOPS_RETIRED",
2228   .desc   = "Memory uops retired",
2229   .modmsk = INTEL_V3_ATTRS,
2230   .cntmsk = 0xff,
2231   .code = 0xd0,
2232   .flags= INTEL_X86_PEBS,
2233   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_uops_retired),
2234   .ngrp = 1,
2235   .umasks = snb_mem_uops_retired,
2236 },
2237 { .name   = "MEM_UOP_RETIRED",
2238   .desc   = "Memory uops retired (deprecated use MEM_UOPS_RETIRED)",
2239   .modmsk = INTEL_V3_ATTRS,
2240   .cntmsk = 0xff,
2241   .code = 0xd0,
2242   .equiv = "MEM_UOPS_RETIRED",
2243   .flags= INTEL_X86_PEBS,
2244   .numasks = LIBPFM_ARRAY_SIZE(snb_mem_uops_retired),
2245   .ngrp = 1,
2246   .umasks = snb_mem_uops_retired,
2247 },
2248
2249 { .name   = "MISALIGN_MEM_REF",
2250   .desc   = "Misaligned memory references",
2251   .modmsk = INTEL_V3_ATTRS,
2252   .cntmsk = 0xff,
2253   .code = 0x5,
2254   .numasks = LIBPFM_ARRAY_SIZE(snb_misalign_mem_ref),
2255   .ngrp = 1,
2256   .umasks = snb_misalign_mem_ref,
2257 },
2258 { .name   = "OFFCORE_REQUESTS",
2259   .desc   = "Offcore requests",
2260   .modmsk = INTEL_V3_ATTRS,
2261   .cntmsk = 0xff,
2262   .code = 0xb0,
2263   .numasks = LIBPFM_ARRAY_SIZE(snb_offcore_requests),
2264   .ngrp = 1,
2265   .umasks = snb_offcore_requests,
2266 },
2267 { .name   = "OFFCORE_REQUESTS_BUFFER",
2268   .desc   = "Offcore requests buffer",
2269   .modmsk = INTEL_V3_ATTRS,
2270   .cntmsk = 0xff,
2271   .code = 0xb2,
2272   .numasks = LIBPFM_ARRAY_SIZE(snb_offcore_requests_buffer),
2273   .ngrp = 1,
2274   .umasks = snb_offcore_requests_buffer,
2275 },
2276 { .name   = "OFFCORE_REQUESTS_OUTSTANDING",
2277   .desc   = "Outstanding offcore requests",
2278   .modmsk = INTEL_V3_ATTRS,
2279   .cntmsk = 0xff,
2280   .code = 0x60,
2281   .numasks = LIBPFM_ARRAY_SIZE(snb_offcore_requests_outstanding),
2282   .ngrp = 1,
2283   .umasks = snb_offcore_requests_outstanding,
2284 },
2285 { .name   = "OTHER_ASSISTS",
2286   .desc   = "Count hardware assists",
2287   .modmsk = INTEL_V3_ATTRS,
2288   .cntmsk = 0xff,
2289   .code = 0xc1,
2290   .numasks = LIBPFM_ARRAY_SIZE(snb_other_assists),
2291   .ngrp = 1,
2292   .umasks = snb_other_assists,
2293 },
2294 { .name   = "PARTIAL_RAT_STALLS",
2295   .desc   = "Partial Register Allocation Table stalls",
2296   .modmsk = INTEL_V3_ATTRS,
2297   .cntmsk = 0xff,
2298   .code = 0x59,
2299   .numasks = LIBPFM_ARRAY_SIZE(snb_partial_rat_stalls),
2300   .ngrp = 1,
2301   .umasks = snb_partial_rat_stalls,
2302 },
2303 { .name   = "RESOURCE_STALLS",
2304   .desc   = "Resource related stall cycles",
2305   .modmsk = INTEL_V3_ATTRS,
2306   .cntmsk = 0xff,
2307   .code = 0xa2,
2308   .numasks = LIBPFM_ARRAY_SIZE(snb_resource_stalls),
2309   .ngrp = 1,
2310   .umasks = snb_resource_stalls,
2311 },
2312 { .name   = "RESOURCE_STALLS2",
2313   .desc   = "Resource related stall cycles",
2314   .modmsk = INTEL_V3_ATTRS,
2315   .cntmsk = 0xff,
2316   .code = 0x5b,
2317   .numasks = LIBPFM_ARRAY_SIZE(snb_resource_stalls2),
2318   .ngrp = 1,
2319   .umasks = snb_resource_stalls2,
2320 },
2321 { .name   = "ROB_MISC_EVENTS",
2322   .desc   = "Reorder buffer events",
2323   .modmsk = INTEL_V3_ATTRS,
2324   .cntmsk = 0xff,
2325   .code = 0xcc,
2326   .numasks = LIBPFM_ARRAY_SIZE(snb_rob_misc_events),
2327   .ngrp = 1,
2328   .umasks = snb_rob_misc_events,
2329 },
2330 { .name   = "RS_EVENTS",
2331   .desc   = "Reservation station events",
2332   .modmsk = INTEL_V3_ATTRS,
2333   .cntmsk = 0xff,
2334   .code = 0x5e,
2335   .numasks = LIBPFM_ARRAY_SIZE(snb_rs_events),
2336   .ngrp = 1,
2337   .umasks = snb_rs_events,
2338 },
2339 { .name   = "SIMD_FP_256",
2340   .desc   = "Counts 256-bit packed floating point instructions",
2341   .modmsk = INTEL_V3_ATTRS,
2342   .cntmsk = 0xff,
2343   .code = 0x11,
2344   .numasks = LIBPFM_ARRAY_SIZE(snb_simd_fp_256),
2345   .ngrp = 1,
2346   .umasks = snb_simd_fp_256,
2347 },
2348 { .name   = "SQ_MISC",
2349   .desc   = "SuperQ events",
2350   .modmsk = INTEL_V3_ATTRS,
2351   .cntmsk = 0xff,
2352   .code = 0xf4,
2353   .numasks = LIBPFM_ARRAY_SIZE(snb_sq_misc),
2354   .ngrp = 1,
2355   .umasks = snb_sq_misc,
2356 },
2357 { .name   = "TLB_FLUSH",
2358   .desc   = "TLB flushes",
2359   .modmsk = INTEL_V3_ATTRS,
2360   .cntmsk = 0xff,
2361   .code = 0xbd,
2362   .numasks = LIBPFM_ARRAY_SIZE(snb_tlb_flush),
2363   .ngrp = 1,
2364   .umasks = snb_tlb_flush,
2365 },
2366 { .name   = "UNHALTED_CORE_CYCLES",
2367   .desc   = "Count core clock cycles whenever the clock signal on the specific core is running (not halted)",
2368   .modmsk = INTEL_V3_ATTRS,
2369   .cntmsk = 0x20000000full,
2370   .code = 0x3c,
2371 },
2372 { .name   = "UNHALTED_REFERENCE_CYCLES",
2373   .desc   = "Unhalted reference cycles",
2374   .modmsk = INTEL_FIXED3_ATTRS,
2375   .cntmsk = 0x400000000ull,
2376   .code = 0x0300, /* pseudo encoding */
2377   .flags = INTEL_X86_FIXED,
2378 },
2379 { .name   = "UOPS_DISPATCHED",
2380   .desc   = "Uops dispatched",
2381   .modmsk = INTEL_V3_ATTRS,
2382   .cntmsk = 0xff,
2383   .code = 0xb1,
2384   .numasks = LIBPFM_ARRAY_SIZE(snb_uops_dispatched),
2385   .ngrp = 1,
2386   .umasks = snb_uops_dispatched,
2387 },
2388 { .name   = "UOPS_DISPATCHED_PORT",
2389   .desc   = "Uops dispatch to specific ports",
2390   .modmsk = INTEL_V3_ATTRS,
2391   .cntmsk = 0xff,
2392   .code = 0xa1,
2393   .numasks = LIBPFM_ARRAY_SIZE(snb_uops_dispatched_port),
2394   .ngrp = 1,
2395   .umasks = snb_uops_dispatched_port,
2396 },
2397 { .name   = "UOPS_ISSUED",
2398   .desc   = "Uops issued",
2399   .modmsk = INTEL_V3_ATTRS,
2400   .cntmsk = 0xff,
2401   .code = 0xe,
2402   .numasks = LIBPFM_ARRAY_SIZE(snb_uops_issued),
2403   .ngrp = 1,
2404   .umasks = snb_uops_issued,
2405 },
2406 { .name   = "UOPS_RETIRED",
2407   .desc   = "Uops retired",
2408   .modmsk = INTEL_V3_ATTRS,
2409   .cntmsk = 0xff,
2410   .code = 0xc2,
2411   .flags= INTEL_X86_PEBS,
2412   .numasks = LIBPFM_ARRAY_SIZE(snb_uops_retired),
2413   .ngrp = 1,
2414   .umasks = snb_uops_retired,
2415 },
2416 { .name   = "CYCLE_ACTIVITY",
2417   .desc   = "Stalled cycles",
2418   .modmsk = INTEL_V3_ATTRS & ~_INTEL_X86_ATTR_C,
2419   .cntmsk = 0xff,
2420   .code = 0xa3,
2421   .numasks = LIBPFM_ARRAY_SIZE(snb_cycle_activity),
2422   .ngrp = 1,
2423   .umasks = snb_cycle_activity,
2424 },
2425 { .name   = "OFFCORE_RESPONSE_0",
2426   .desc   = "Offcore response event (must provide at least one request type and either any_response or any combination of supplier + snoop)",
2427   .modmsk = INTEL_V3_ATTRS,
2428   .cntmsk = 0xf,
2429   .code = 0x1b7,
2430   .flags= INTEL_X86_NHM_OFFCORE,
2431   .numasks = LIBPFM_ARRAY_SIZE(snb_offcore_response),
2432   .ngrp = 3,
2433   .umasks = snb_offcore_response,
2434 },
2435 { .name   = "OFFCORE_RESPONSE_1",
2436   .desc   = "Offcore response event (must provide at least one request type and either any_response or any combination of supplier + snoop)",
2437   .modmsk = INTEL_V3_ATTRS,
2438   .cntmsk = 0xf,
2439   .code = 0x1bb,
2440   .flags= INTEL_X86_NHM_OFFCORE,
2441   .numasks =  LIBPFM_ARRAY_SIZE(snb_offcore_response),
2442   .ngrp = 3,
2443   .umasks = snb_offcore_response, /* identical to actual umasks list for this event */
2444 },
2445 };