1#include "vm_opts.h"
2
3provider ruby {
4  /*
5     ruby:::method-entry(classname, methodname, filename, lineno);
6
7     This probe is fired just before a method is entered.
8
9     * `classname` name of the class (a string)
10     * `methodname` name of the method about to be executed (a string)
11     * `filename` the file name where the method is _being called_ (a string)
12     * `lineno` the line number where the method is _being called_ (an int)
13  */
14  probe method__entry(const char *, const char *, const char *, int);
15  /*
16     ruby:::method-return(classname, methodname, filename, lineno);
17
18     This probe is fired just after a method has returned. The arguments are
19     the same as "ruby:::function-entry".
20  */
21  probe method__return(const char *, const char *, const char *, int);
22
23  /*
24     ruby:::cmethod-entry(classname, methodname, filename, lineno);
25
26     This probe is fired just before a C method is entered. The arguments are
27     the same as "ruby:::function-entry".
28  */
29  probe cmethod__entry(const char *, const char *, const char *, int);
30  /*
31     ruby:::cmethod-return(classname, methodname, filename, lineno);
32
33     This probe is fired just before a C method returns. The arguments are
34     the same as "ruby:::function-entry".
35  */
36  probe cmethod__return(const char *, const char *, const char *, int);
37
38  /*
39     ruby:::require-entry(requiredfile, filename, lineno);
40
41     This probe is fired on calls to `rb_require_safe` (when a file is
42     required).
43
44     * `requiredfile` is the name of the file to be required (string).
45     * `filename` is the file that called "require" (string).
46     * `lineno` is the line number where the call to require was made (int).
47  */
48  probe require__entry(const char *, const char *, int);
49
50  /*
51     ruby:::require-return(requiredfile, filename, lineno);
52
53     This probe is fired just before `rb_require_safe` (when a file is required)
54     returns.  The arguments are the same as "ruby:::require-entry".  This
55     probe will not fire if there was an exception during file require.
56  */
57  probe require__return(const char *, const char *, int);
58
59  /*
60     ruby:::find-require-entry(requiredfile, filename, lineno);
61
62     This probe is fired right before `search_required` is called.
63     `search_required` determines whether the file has already been required by
64     searching loaded features ($"), and if not, figures out which file must be
65     loaded.
66
67     * `requiredfile` is the file to be required (string).
68     * `filename` is the file that called "require" (string).
69     * `lineno` is the line number where the call to require was made (int).
70  */
71  probe find__require__entry(const char *, const char *, int);
72
73  /*
74     ruby:::find-require-return(requiredfile, filename, lineno);
75
76     This probe is fired right after `search_required` returns.  See the
77     documentation for "ruby:::find-require-entry" for more details.  Arguments
78     for this probe are the same as "ruby:::find-require-entry".
79  */
80  probe find__require__return(const char *, const char *, int);
81
82  /*
83     ruby:::load-entry(loadedfile, filename, lineno);
84
85     This probe is fired when calls to "load" are made.  The arguments are the
86     same as "ruby:::require-entry".
87  */
88  probe load__entry(const char *, const char *, int);
89
90  /*
91     ruby:::load-return(loadedfile, filename, lineno);
92
93     This probe is fired when "load" returns.  The arguments are the same as
94     "ruby:::load-entry".
95  */
96  probe load__return(const char *, const char *, int);
97
98  /*
99     ruby:::raise(classname, filename, lineno);
100
101     This probe is fired when an exception is raised.
102
103     * `classname` is the class name of the raised exception (string)
104     * `filename` the name of the file where the exception was raised (string)
105     * `lineno` the line number in the file where the exception was raised (int)
106  */
107  probe raise(const char *, const char *, int);
108
109  /*
110     ruby:::object-create(classname, filename, lineno);
111
112     This probe is fired when an object is about to be allocated.
113
114      * `classname` the class of the allocated object (string)
115      * `filename` the name of the file where the object is allocated (string)
116      * `lineno` the line number in the file where the object is allocated (int)
117  */
118  probe object__create(const char *, const char *, int);
119
120  /*
121     ruby:::array-create(length, filename, lineno);
122
123     This probe is fired when an Array is about to be allocated.
124
125      * `length` the size of the array (long)
126      * `filename` the name of the file where the array is allocated (string)
127      * `lineno` the line number in the file where the array is allocated (int)
128  */
129  probe array__create(long, const char *, int);
130
131  /*
132     ruby:::hash-create(length, filename, lineno);
133
134     This probe is fired when a Hash is about to be allocated.
135
136      * `length` the size of the hash (long)
137      * `filename` the name of the file where the hash is allocated (string)
138      * `lineno` the line number in the file where the hash is allocated (int)
139  */
140  probe hash__create(long, const char *, int);
141
142  /*
143     ruby:::string-create(length, filename, lineno);
144
145     This probe is fired when a String is about to be allocated.
146
147      * `length` the size of the string (long)
148      * `filename` the name of the file where the string is allocated (string)
149      * `lineno` the line number in the file where the string is allocated (int)
150  */
151  probe string__create(long, const char *, int);
152
153  /*
154     ruby:::parse-begin(sourcefile, lineno);
155
156     Fired just before parsing and compiling a source file.
157
158     * `sourcefile` the file being parsed (string)
159     * `lineno` the line number where the source starts (int)
160  */
161  probe parse__begin(const char *, int);
162
163  /*
164     ruby:::parse-end(sourcefile, lineno);
165
166     Fired just after parsing and compiling a source file.
167
168     * `sourcefile` the file being parsed (string)
169     * `lineno` the line number where the source ended (int)
170  */
171  probe parse__end(const char *, int);
172
173#if VM_COLLECT_USAGE_DETAILS
174  probe insn(const char *);
175  probe insn__operand(const char *, const char *);
176#endif
177
178  /*
179     ruby:::gc-mark-begin();
180
181     Fired at the beginning of a mark phase.
182  */
183  probe gc__mark__begin();
184
185  /*
186     ruby:::gc-mark-end();
187
188     Fired at the end of a mark phase.
189  */
190  probe gc__mark__end();
191
192  /*
193     ruby:::gc-sweep-begin();
194
195     Fired at the beginning of a sweep phase.
196  */
197  probe gc__sweep__begin();
198
199  /*
200     ruby:::gc-sweep-end();
201
202     Fired at the end of a sweep phase.
203  */
204  probe gc__sweep__end();
205};
206
207#pragma D attributes Stable/Evolving/Common provider ruby provider
208#pragma D attributes Stable/Evolving/Common provider ruby module
209#pragma D attributes Stable/Evolving/Common provider ruby function
210#pragma D attributes Evolving/Evolving/Common provider ruby name
211#pragma D attributes Evolving/Evolving/Common provider ruby args
212