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