Skip to content

Commit 8dddcab

Browse files
ojhuntahmedbougacha
ojhunt
authored and
ahmedbougacha
committed
Update code style
1 parent 088a5f2 commit 8dddcab

File tree

5 files changed

+212
-210
lines changed

5 files changed

+212
-210
lines changed

‎clang/lib/CodeGen/CGPointerAuth.cpp

Lines changed: 134 additions & 135 deletions
Original file line numberDiff line numberDiff line change
@@ -23,42 +23,42 @@ using namespace CodeGen;
2323
/// Given a pointer-authentication schema, return a concrete "other"
2424
/// discriminator for it.
2525
llvm::ConstantInt *CodeGenModule::getPointerAuthOtherDiscriminator(
26-
const PointerAuthSchema &schema, GlobalDecl decl, QualType type) {
27-
switch (schema.getOtherDiscrimination()) {
26+
const PointerAuthSchema &Schema, GlobalDecl Decl, QualType Type) {
27+
switch (Schema.getOtherDiscrimination()) {
2828
case PointerAuthSchema::Discrimination::None:
2929
return nullptr;
3030

3131
case PointerAuthSchema::Discrimination::Type:
3232
llvm_unreachable("type discrimination not implemented yet");
3333

3434
case PointerAuthSchema::Discrimination::Decl:
35-
assert(decl.getDecl() &&
35+
assert(Decl.getDecl() &&
3636
"declaration not provided for decl-discriminated schema");
3737
return llvm::ConstantInt::get(IntPtrTy,
38-
getPointerAuthDeclDiscriminator(decl));
38+
getPointerAuthDeclDiscriminator(Decl));
3939

4040
case PointerAuthSchema::Discrimination::Constant:
41-
return llvm::ConstantInt::get(IntPtrTy, schema.getConstantDiscrimination());
41+
return llvm::ConstantInt::get(IntPtrTy, Schema.getConstantDiscrimination());
4242
}
4343
llvm_unreachable("bad discrimination kind");
4444
}
4545

4646
uint16_t CodeGen::getPointerAuthDeclDiscriminator(CodeGenModule &CGM,
47-
GlobalDecl declaration) {
48-
return CGM.getPointerAuthDeclDiscriminator(declaration);
47+
GlobalDecl Declaration) {
48+
return CGM.getPointerAuthDeclDiscriminator(Declaration);
4949
}
5050

5151
/// Return the "other" decl-specific discriminator for the given decl.
5252
uint16_t
53-
CodeGenModule::getPointerAuthDeclDiscriminator(GlobalDecl declaration) {
54-
uint16_t &entityHash = PtrAuthDiscriminatorHashes[declaration];
53+
CodeGenModule::getPointerAuthDeclDiscriminator(GlobalDecl Declaration) {
54+
uint16_t &EntityHash = PtrAuthDiscriminatorHashes[Declaration];
5555

56-
if (entityHash == 0) {
57-
StringRef name = getMangledName(declaration);
58-
entityHash = llvm::getPointerAuthStableSipHash(name);
56+
if (EntityHash == 0) {
57+
StringRef Name = getMangledName(Declaration);
58+
EntityHash = llvm::getPointerAuthStableSipHash(Name);
5959
}
6060

61-
return entityHash;
61+
return EntityHash;
6262
}
6363

6464
/// Return the abstract pointer authentication schema for a pointer to the given
@@ -80,38 +80,38 @@ CGPointerAuthInfo CodeGenModule::getFunctionPointerAuthInfo(QualType T) {
8080
}
8181

8282
llvm::Value *
83-
CodeGenFunction::EmitPointerAuthBlendDiscriminator(llvm::Value *storageAddress,
84-
llvm::Value *discriminator) {
85-
storageAddress = Builder.CreatePtrToInt(storageAddress, IntPtrTy);
86-
auto intrinsic = CGM.getIntrinsic(llvm::Intrinsic::ptrauth_blend);
87-
return Builder.CreateCall(intrinsic, {storageAddress, discriminator});
83+
CodeGenFunction::EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress,
84+
llvm::Value *Discriminator) {
85+
StorageAddress = Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
86+
auto Intrinsic = CGM.getIntrinsic(llvm::Intrinsic::ptrauth_blend);
87+
return Builder.CreateCall(Intrinsic, {StorageAddress, Discriminator});
8888
}
8989

9090
/// Emit the concrete pointer authentication informaton for the
9191
/// given authentication schema.
9292
CGPointerAuthInfo CodeGenFunction::EmitPointerAuthInfo(
93-
const PointerAuthSchema &schema, llvm::Value *storageAddress,
94-
GlobalDecl schemaDecl, QualType schemaType) {
95-
if (!schema)
93+
const PointerAuthSchema &Schema, llvm::Value *StorageAddress,
94+
GlobalDecl SchemaDecl, QualType SchemaType) {
95+
if (!Schema)
9696
return CGPointerAuthInfo();
9797

98-
llvm::Value *discriminator =
99-
CGM.getPointerAuthOtherDiscriminator(schema, schemaDecl, schemaType);
98+
llvm::Value *Discriminator =
99+
CGM.getPointerAuthOtherDiscriminator(Schema, SchemaDecl, SchemaType);
100100

101-
if (schema.isAddressDiscriminated()) {
102-
assert(storageAddress &&
101+
if (Schema.isAddressDiscriminated()) {
102+
assert(StorageAddress &&
103103
"address not provided for address-discriminated schema");
104104

105-
if (discriminator)
106-
discriminator =
107-
EmitPointerAuthBlendDiscriminator(storageAddress, discriminator);
105+
if (Discriminator)
106+
Discriminator =
107+
EmitPointerAuthBlendDiscriminator(StorageAddress, Discriminator);
108108
else
109-
discriminator = Builder.CreatePtrToInt(storageAddress, IntPtrTy);
109+
Discriminator = Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
110110
}
111111

112-
return CGPointerAuthInfo(schema.getKey(), schema.getAuthenticationMode(),
113-
schema.isIsaPointer(),
114-
schema.authenticatesNullValues(), discriminator);
112+
return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
113+
Schema.isIsaPointer(),
114+
Schema.authenticatesNullValues(), Discriminator);
115115
}
116116

117117
llvm::Constant *
@@ -140,55 +140,53 @@ CodeGenModule::getConstantSignedPointer(llvm::Constant *Pointer, unsigned Key,
140140
}
141141

142142
/// Does a given PointerAuthScheme require us to sign a value
143-
static bool shouldSignPointer(const PointerAuthSchema &schema) {
144-
auto authenticationMode = schema.getAuthenticationMode();
145-
return authenticationMode == PointerAuthenticationMode::SignAndStrip ||
146-
authenticationMode == PointerAuthenticationMode::SignAndAuth;
143+
static bool shouldSignPointer(const PointerAuthSchema &Schema) {
144+
auto AuthenticationMode = Schema.getAuthenticationMode();
145+
return AuthenticationMode == PointerAuthenticationMode::SignAndStrip ||
146+
AuthenticationMode == PointerAuthenticationMode::SignAndAuth;
147147
}
148148

149149
/// Sign a constant pointer using the given scheme, producing a constant
150150
/// with the same IR type.
151151
llvm::Constant *CodeGenModule::getConstantSignedPointer(
152-
llvm::Constant *pointer, const PointerAuthSchema &schema,
153-
llvm::Constant *storageAddress, GlobalDecl schemaDecl,
154-
QualType schemaType) {
155-
assert(shouldSignPointer(schema));
156-
llvm::ConstantInt *otherDiscriminator =
157-
getPointerAuthOtherDiscriminator(schema, schemaDecl, schemaType);
158-
159-
return getConstantSignedPointer(pointer, schema.getKey(), storageAddress,
160-
otherDiscriminator);
152+
llvm::Constant *Pointer, const PointerAuthSchema &Schema,
153+
llvm::Constant *StorageAddress, GlobalDecl SchemaDecl,
154+
QualType SchemaType) {
155+
assert(shouldSignPointer(Schema));
156+
llvm::ConstantInt *OtherDiscriminator =
157+
getPointerAuthOtherDiscriminator(Schema, SchemaDecl, SchemaType);
158+
159+
return getConstantSignedPointer(Pointer, Schema.getKey(), StorageAddress,
160+
OtherDiscriminator);
161161
}
162162

163163
/// Sign the given pointer and add it to the constant initializer
164164
/// currently being built.
165165
void ConstantAggregateBuilderBase::addSignedPointer(
166-
llvm::Constant *pointer, const PointerAuthSchema &schema,
167-
GlobalDecl calleeDecl, QualType calleeType) {
168-
if (!schema || !shouldSignPointer(schema))
169-
return add(pointer);
170-
171-
llvm::Constant *storageAddress = nullptr;
172-
if (schema.isAddressDiscriminated()) {
173-
storageAddress = getAddrOfCurrentPosition(pointer->getType());
174-
}
175-
176-
llvm::Constant *signedPointer = Builder.CGM.getConstantSignedPointer(
177-
pointer, schema, storageAddress, calleeDecl, calleeType);
178-
add(signedPointer);
166+
llvm::Constant *Pointer, const PointerAuthSchema &Schema,
167+
GlobalDecl CalleeDecl, QualType CalleeType) {
168+
if (!Schema || !shouldSignPointer(Schema))
169+
return add(Pointer);
170+
171+
llvm::Constant *StorageAddress = nullptr;
172+
if (Schema.isAddressDiscriminated())
173+
StorageAddress = getAddrOfCurrentPosition(Pointer->getType());
174+
175+
llvm::Constant *SignedPointer = Builder.CGM.getConstantSignedPointer(
176+
Pointer, Schema, StorageAddress, CalleeDecl, CalleeType);
177+
add(SignedPointer);
179178
}
180179

181180
void ConstantAggregateBuilderBase::addSignedPointer(
182-
llvm::Constant *pointer, unsigned key, bool useAddressDiscrimination,
183-
llvm::ConstantInt *otherDiscriminator) {
184-
llvm::Constant *storageAddress = nullptr;
185-
if (useAddressDiscrimination) {
186-
storageAddress = getAddrOfCurrentPosition(pointer->getType());
187-
}
188-
189-
llvm::Constant *signedPointer = Builder.CGM.getConstantSignedPointer(
190-
pointer, key, storageAddress, otherDiscriminator);
191-
add(signedPointer);
181+
llvm::Constant *Pointer, unsigned Key, bool UseAddressDiscrimination,
182+
llvm::ConstantInt *OtherDiscriminator) {
183+
llvm::Constant *StorageAddress = nullptr;
184+
if (UseAddressDiscrimination)
185+
StorageAddress = getAddrOfCurrentPosition(Pointer->getType());
186+
187+
llvm::Constant *SignedPointer = Builder.CGM.getConstantSignedPointer(
188+
Pointer, Key, StorageAddress, OtherDiscriminator);
189+
add(SignedPointer);
192190
}
193191

194192
/// If applicable, sign a given constant function pointer with the ABI rules for
@@ -215,111 +213,112 @@ llvm::Constant *CodeGenModule::getFunctionPointer(GlobalDecl GD,
215213
}
216214

217215
std::optional<PointerAuthQualifier>
218-
CodeGenModule::computeVTPointerAuthentication(const CXXRecordDecl *thisClass) {
219-
auto defaultAuthentication = getCodeGenOpts().PointerAuth.CXXVTablePointers;
220-
if (!defaultAuthentication)
216+
CodeGenModule::computeVTPointerAuthentication(const CXXRecordDecl *ThisClass) {
217+
auto DefaultAuthentication = getCodeGenOpts().PointerAuth.CXXVTablePointers;
218+
if (!DefaultAuthentication)
221219
return std::nullopt;
222-
const CXXRecordDecl *primaryBase =
223-
Context.baseForVTableAuthentication(thisClass);
224-
225-
unsigned key = defaultAuthentication.getKey();
226-
bool addressDiscriminated = defaultAuthentication.isAddressDiscriminated();
227-
auto defaultDiscrimination = defaultAuthentication.getOtherDiscrimination();
228-
unsigned typeBasedDiscriminator =
229-
Context.getPointerAuthVTablePointerDiscriminator(primaryBase);
230-
unsigned discriminator;
231-
if (defaultDiscrimination == PointerAuthSchema::Discrimination::Type) {
232-
discriminator = typeBasedDiscriminator;
233-
} else if (defaultDiscrimination ==
220+
const CXXRecordDecl *PrimaryBase =
221+
Context.baseForVTableAuthentication(ThisClass);
222+
223+
unsigned Key = DefaultAuthentication.getKey();
224+
bool AddressDiscriminated = DefaultAuthentication.isAddressDiscriminated();
225+
auto DefaultDiscrimination = DefaultAuthentication.getOtherDiscrimination();
226+
unsigned TypeBasedDiscriminator =
227+
Context.getPointerAuthVTablePointerDiscriminator(PrimaryBase);
228+
unsigned Discriminator;
229+
if (DefaultDiscrimination == PointerAuthSchema::Discrimination::Type) {
230+
Discriminator = TypeBasedDiscriminator;
231+
} else if (DefaultDiscrimination ==
234232
PointerAuthSchema::Discrimination::Constant) {
235-
discriminator = defaultAuthentication.getConstantDiscrimination();
233+
Discriminator = DefaultAuthentication.getConstantDiscrimination();
236234
} else {
237-
assert(defaultDiscrimination == PointerAuthSchema::Discrimination::None);
238-
discriminator = 0;
235+
assert(DefaultDiscrimination == PointerAuthSchema::Discrimination::None);
236+
Discriminator = 0;
239237
}
240-
if (auto explicitAuthentication =
241-
primaryBase->getAttr<VTablePointerAuthenticationAttr>()) {
242-
auto explicitKey = explicitAuthentication->getKey();
243-
auto explicitAddressDiscrimination =
244-
explicitAuthentication->getAddressDiscrimination();
245-
auto explicitDiscriminator =
246-
explicitAuthentication->getExtraDiscrimination();
247-
if (explicitKey == VTablePointerAuthenticationAttr::NoKey) {
238+
if (auto ExplicitAuthentication =
239+
PrimaryBase->getAttr<VTablePointerAuthenticationAttr>()) {
240+
auto ExplicitKey = ExplicitAuthentication->getKey();
241+
auto ExplicitAddressDiscrimination =
242+
ExplicitAuthentication->getAddressDiscrimination();
243+
auto ExplicitDiscriminator =
244+
ExplicitAuthentication->getExtraDiscrimination();
245+
if (ExplicitKey == VTablePointerAuthenticationAttr::NoKey) {
248246
return std::nullopt;
249247
}
250-
if (explicitKey != VTablePointerAuthenticationAttr::DefaultKey) {
251-
if (explicitKey == VTablePointerAuthenticationAttr::ProcessIndependent)
252-
key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDA;
248+
if (ExplicitKey != VTablePointerAuthenticationAttr::DefaultKey) {
249+
if (ExplicitKey == VTablePointerAuthenticationAttr::ProcessIndependent)
250+
Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDA;
253251
else {
254-
assert(explicitKey ==
252+
assert(ExplicitKey ==
255253
VTablePointerAuthenticationAttr::ProcessDependent);
256-
key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDB;
254+
Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDB;
257255
}
258256
}
259257

260-
if (explicitAddressDiscrimination !=
258+
if (ExplicitAddressDiscrimination !=
261259
VTablePointerAuthenticationAttr::DefaultAddressDiscrimination) {
262-
addressDiscriminated =
263-
explicitAddressDiscrimination ==
260+
AddressDiscriminated =
261+
ExplicitAddressDiscrimination ==
264262
VTablePointerAuthenticationAttr::AddressDiscrimination;
265263
}
266264

267-
if (explicitDiscriminator ==
265+
if (ExplicitDiscriminator ==
268266
VTablePointerAuthenticationAttr::TypeDiscrimination) {
269-
discriminator = typeBasedDiscriminator;
270-
} else if (explicitDiscriminator ==
267+
Discriminator = TypeBasedDiscriminator;
268+
} else if (ExplicitDiscriminator ==
271269
VTablePointerAuthenticationAttr::CustomDiscrimination) {
272-
discriminator = explicitAuthentication->getCustomDiscriminationValue();
273-
} else if (explicitDiscriminator == VTablePointerAuthenticationAttr::NoExtraDiscrimination) {
274-
discriminator = 0;
270+
Discriminator = ExplicitAuthentication->getCustomDiscriminationValue();
271+
} else if (ExplicitDiscriminator ==
272+
VTablePointerAuthenticationAttr::NoExtraDiscrimination) {
273+
Discriminator = 0;
275274
}
276275
}
277-
return PointerAuthQualifier::Create(key, addressDiscriminated, discriminator,
276+
return PointerAuthQualifier::Create(Key, AddressDiscriminated, Discriminator,
278277
PointerAuthenticationMode::SignAndAuth,
279-
/* isIsaPointer */ false,
280-
/* authenticatesNullValues */ false);
278+
/* IsIsaPointer */ false,
279+
/* AuthenticatesNullValues */ false);
281280
}
282281

283282
std::optional<PointerAuthQualifier>
284-
CodeGenModule::getVTablePointerAuthentication(const CXXRecordDecl *record) {
285-
if (!record->getDefinition() || !record->isPolymorphic())
283+
CodeGenModule::getVTablePointerAuthentication(const CXXRecordDecl *Record) {
284+
if (!Record->getDefinition() || !Record->isPolymorphic())
286285
return std::nullopt;
287286

288-
auto existing = VTablePtrAuthInfos.find(record);
289-
std::optional<PointerAuthQualifier> authentication;
290-
if (existing != VTablePtrAuthInfos.end()) {
291-
authentication = existing->getSecond();
287+
auto Existing = VTablePtrAuthInfos.find(Record);
288+
std::optional<PointerAuthQualifier> Authentication;
289+
if (Existing != VTablePtrAuthInfos.end()) {
290+
Authentication = Existing->getSecond();
292291
} else {
293-
authentication = computeVTPointerAuthentication(record);
294-
VTablePtrAuthInfos.insert(std::make_pair(record, authentication));
292+
Authentication = computeVTPointerAuthentication(Record);
293+
VTablePtrAuthInfos.insert(std::make_pair(Record, Authentication));
295294
}
296-
return authentication;
295+
return Authentication;
297296
}
298297

299298
std::optional<CGPointerAuthInfo>
300299
CodeGenModule::getVTablePointerAuthInfo(CodeGenFunction *CGF,
301-
const CXXRecordDecl *record,
302-
llvm::Value *storageAddress) {
303-
auto authentication = getVTablePointerAuthentication(record);
304-
if (!authentication)
300+
const CXXRecordDecl *Record,
301+
llvm::Value *StorageAddress) {
302+
auto Authentication = getVTablePointerAuthentication(Record);
303+
if (!Authentication)
305304
return std::nullopt;
306305

307-
llvm::Value *discriminator = nullptr;
308-
if (auto extraDiscriminator = authentication->getExtraDiscriminator()) {
309-
discriminator = llvm::ConstantInt::get(IntPtrTy, extraDiscriminator);
306+
llvm::Value *Discriminator = nullptr;
307+
if (auto ExtraDiscriminator = Authentication->getExtraDiscriminator()) {
308+
Discriminator = llvm::ConstantInt::get(IntPtrTy, ExtraDiscriminator);
310309
}
311-
if (authentication->isAddressDiscriminated()) {
312-
assert(storageAddress &&
310+
if (Authentication->isAddressDiscriminated()) {
311+
assert(StorageAddress &&
313312
"address not provided for address-discriminated schema");
314-
if (discriminator)
315-
discriminator =
316-
CGF->EmitPointerAuthBlendDiscriminator(storageAddress, discriminator);
313+
if (Discriminator)
314+
Discriminator =
315+
CGF->EmitPointerAuthBlendDiscriminator(StorageAddress, Discriminator);
317316
else
318-
discriminator = CGF->Builder.CreatePtrToInt(storageAddress, IntPtrTy);
317+
Discriminator = CGF->Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
319318
}
320319

321-
return CGPointerAuthInfo(authentication->getKey(),
320+
return CGPointerAuthInfo(Authentication->getKey(),
322321
PointerAuthenticationMode::SignAndAuth,
323322
/* IsIsaPointer */ false,
324-
/* authenticatesNullValues */ false, discriminator);
323+
/* AuthenticatesNullValues */ false, Discriminator);
325324
}

0 commit comments

Comments
 (0)